Ora

How to Perform Optical Character Recognition (OCR) on Files in Java

Published in OCR in Java 8 mins read

To read the content of files using Optical Character Recognition (OCR) in Java, you'll primarily be performing text extraction from images or PDFs. The most widely used and effective solution for this in Java involves leveraging the Tesseract OCR engine with a suitable Java wrapper.

Introduction to OCR in Java

Optical Character Recognition (OCR) is a technology that enables you to convert different types of documents, such as scanned paper documents, PDFs, or image files (like JPEGs, PNGs, TIFFs), into editable and searchable data. Instead of simply "reading an OCR file" in the sense of parsing a pre-existing structured output, the common goal is often to perform OCR on an input file (usually an image or PDF) to extract its text content.

The first step in performing OCR in Java is to install the Tesseract OCR engine. Tesseract OCR is a powerful, freely accessible engine that directly performs text extraction from images. You can easily find and access it on GitHub where its source code and releases are maintained.

Prerequisites for OCR in Java

Before you start, ensure you have the following installed:

  • Java Development Kit (JDK): Version 8 or higher.
  • Apache Maven or Gradle: For project dependency management.
  • Tesseract OCR Engine: The native Tesseract command-line tool must be installed on your system, as Java wrappers interact with this underlying executable.

Step-by-Step Guide to Performing OCR with Tesseract and Java

This guide will walk you through setting up a Java project to extract text from an image using the popular Tess4J library, a Java wrapper for Tesseract.

Step 1: Install the Tesseract OCR Engine

Tess4J acts as an interface to the native Tesseract engine. Therefore, the native Tesseract binaries must be installed and accessible on your system's PATH.

  • Windows:
    • Download the installer from the Tesseract-OCR for Windows GitHub page.
    • Run the installer, making sure to select any language data you might need and add Tesseract to your system's PATH.
  • macOS:
    • Using Homebrew: brew install tesseract
  • Linux (Debian/Ubuntu):
    • sudo apt update
    • sudo apt install tesseract-ocr
    • sudo apt install libtesseract-dev (for development libraries)
    • Install language packs as needed, e.g., sudo apt install tesseract-ocr-eng for English.

Verify the installation by running tesseract --version in your terminal.

Step 2: Add Tess4J Dependency to Your Java Project

Create a new Maven or Gradle project and add the Tess4J dependency.

Maven:
In your pom.xml file, add the following dependency:

<dependencies>
    <dependency>
        <groupId>net.sourceforge.tess4j</groupId>
        <artifactId>tess4j</artifactId>
        <version>5.11.0</version> <!-- Use the latest stable version -->
    </dependency>
</dependencies>

Gradle:
In your build.gradle file, add the following dependency:

dependencies {
    implementation 'net.sourceforge.tess4j:tess4j:5.11.0' // Use the latest stable version
}

Step 3: Prepare Your Input File

Tesseract works best with clean, high-resolution images. Common input formats include PNG, JPEG, TIFF, and BMP. For PDFs, you'll typically convert each page into an image before passing it to Tesseract.

  • Example Image: Let's assume you have an image file named document.png in your project's root directory or a specified path.

Step 4: Perform Text Extraction (OCR) in Java

Now, write the Java code to use Tess4J for OCR.

import net.sourceforge.tess4j.ITesseract;
import net.sourceforge.tess4j.Tesseract;
import net.sourceforge.tess4j.TesseractException;

import java.io.File;

public class OCRExample {

    public static void main(String[] args) {
        // Create an instance of Tesseract
        ITesseract tesseract = new Tesseract();

        // **IMPORTANT**: Set the path to the Tesseract tessdata directory.
        // This directory contains language training data files.
        // For Windows users, it's typically in the Tesseract installation directory.
        // For Linux/macOS, it might be /usr/share/tesseract-ocr/4.00/tessdata or similar.
        // You can also place the tessdata folder directly in your project root.
        tesseract.setDatapath("C:/Program Files/Tesseract-OCR/tessdata"); // Example for Windows
        // tesseract.setDatapath("/usr/local/share/tessdata"); // Example for macOS/Linux Homebrew

        // Set the language (e.g., English). For multiple languages, use "eng+deu".
        tesseract.setLanguage("eng");

        // Set the path to your image file
        File imageFile = new File("path/to/your/document.png"); // Replace with your image path

        try {
            // Perform OCR on the image
            String result = tesseract.doOCR(imageFile);
            System.out.println("Extracted Text:\n" + result);
        } catch (TesseractException e) {
            System.err.println("Error while performing OCR: " + e.getMessage());
        }
    }
}

Remember to replace "path/to/your/document.png" with the actual path to your image file and "C:/Program Files/Tesseract-OCR/tessdata" (or similar) with the correct path to your Tesseract tessdata directory.

Step 5: Configure Tesseract (Optional but Recommended)

Tesseract offers various configuration options to improve OCR accuracy. You can set them using Tess4J methods:

  • Language (setLanguage()): Specify the language(s) of the text. E.g., "eng", "fra", "eng+deu".
  • Tessdata Path (setDatapath()): Crucial for Tesseract to find its language training files.
  • Page Segmentation Mode (PSM) (setPageSegMode()): How Tesseract processes the page layout.
  • OCR Engine Mode (OEM) (setOcrEngineMode()): Which Tesseract engine to use.

Tesseract Configuration Options

Option Description Recommended Use
setLanguage() Specifies the language(s) for OCR. E.g., "eng", "fra". Use + for multiple languages ("eng+deu"). Essential for accurate recognition of specific languages.
setDatapath() Points to the tessdata directory where language training files are stored. Mandatory for Tesseract to function correctly.
setPageSegMode() Defines how Tesseract expects to find the text structure on the page. Ranges from 0 (OSD only) to 13 (raw line). ITesseract.DEFAULT_PAGE_SEG_MODE (3) for auto-segmentation, 6 for a single uniform block of text. Often needs tuning.
setOcrEngineMode() Selects the Tesseract engine mode. 0 for original, 1 for LSTM (neural net), 2 for old+LSTM, 3 for default. ITesseract.DEFAULT_OCR_ENGINE_MODE (3) for optimal results, as it combines legacy and LSTM.

Example of setting configuration:

// ... inside main method
tesseract.setDatapath("/path/to/tessdata");
tesseract.setLanguage("eng");
tesseract.setPageSegMode(ITesseract.DEFAULT_PAGE_SEG_MODE); // Auto page segmentation
tesseract.setOcrEngineMode(ITesseract.DEFAULT_OCR_ENGINE_MODE); // Default engine mode (legacy + LSTM)

Advanced Considerations

Image Preprocessing

For optimal OCR accuracy, especially with low-quality scans or complex layouts, consider image preprocessing:

  • Binarization: Convert the image to black and white.
  • Deskewing: Correct rotational misalignment.
  • Noise Reduction: Remove speckles and artifacts.
  • Upscaling: Increase image resolution (e.g., to 300 DPI).

Libraries like OpenCV Java or Marvin Image Processing Framework can be used for these tasks before passing the image to Tess4J.

Handling PDF Files

Tesseract itself does not directly process PDF files. To perform OCR on a PDF in Java:

  1. Extract Pages as Images: Use a library like Apache PDFBox to render each PDF page into an image (e.g., JPEG or PNG).
  2. Perform OCR on Each Image: Iterate through the generated images and apply Tess4J's doOCR() method to each.
  3. Combine Results: Concatenate the extracted text from all pages.

Here's a snippet for converting a PDF page to an image using PDFBox:

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class PDFToImageConverter {

    public static void convertPdfPageToImage(String pdfPath, String outputPath, int pageNumber) throws IOException {
        try (PDDocument document = PDDocument.load(new File(pdfPath))) {
            PDFRenderer pdfRenderer = new PDFRenderer(document);
            BufferedImage image = pdfRenderer.renderImageWithDPI(pageNumber, 300); // Render at 300 DPI
            ImageIO.write(image, "PNG", new File(outputPath + "page_" + (pageNumber + 1) + ".png"));
            System.out.println("Page " + (pageNumber + 1) + " converted to image.");
        }
    }

    public static void main(String[] args) throws IOException {
        String pdfFilePath = "path/to/your/document.pdf"; // Replace with your PDF path
        String outputDir = "temp_images/"; // Directory to save temporary images
        new File(outputDir).mkdirs(); // Create directory if it doesn't exist

        try (PDDocument document = PDDocument.load(new File(pdfFilePath))) {
            for (int i = 0; i < document.getNumberOfPages(); i++) {
                convertPdfPageToImage(pdfFilePath, outputDir, i);
            }
        }
    }
}

After converting, you can pass temp_images/page_X.png files to Tess4J for OCR.

Reading Tesseract Output Files (Structured OCR Data)

While the primary use of Tesseract in Java is performing OCR, Tesseract can also generate output in various structured formats, which could be considered "OCR files." If you have such a file (e.g., from a previous Tesseract run), "reading" it means parsing its specific format:

  • Plain Text (.txt): Tesseract's default output. Easily read line by line.
  • hOCR (.html): An HTML-based format that embeds recognized text, bounding box information, and confidence scores. You can parse this using Java's built-in XML/HTML parsers (like Jsoup, DOM parser, SAX parser) to extract structured data.
  • ALTO XML (.xml): A standard XML format for describing text and layout information of digitized documents. Similar to hOCR, you would use standard XML parsing libraries (JAXB, DOM, SAX) to process this data.

For example, to parse an hOCR file, you might use a library like Jsoup:

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import java.io.File;
import java.io.IOException;

public class HocrParser {
    public static void main(String[] args) throws IOException {
        File hocrFile = new File("path/to/your/output.hocr"); // Assume Tesseract generated this
        Document doc = Jsoup.parse(hocrFile, "UTF-8");

        Elements ocrLines = doc.select(".ocr_line");
        for (Element line : ocrLines) {
            String lineText = line.text();
            String title = line.attr("title"); // Contains bounding box info, e.g., "bbox 0 0 100 20"
            System.out.println("Line: " + lineText + " (Title: " + title + ")");
        }
    }
}

This demonstrates how to parse an existing "OCR file" if it contains structured output like hOCR, complementing the text extraction process.

← Previous Article
How to practice badminton?
Next Article →
How to Do Wall Crunches?