Overview

Optical Character Recognition (OCR) using Tesseract in Java allows you to extract text from images. Tesseract is a powerful open-source OCR engine maintained by Google.

1. Setup and Dependencies

Maven Dependencies

<!-- pom.xml --> <dependencies> <!-- Tesseract OCR --> <dependency> <groupId>net.sourceforge.tess4j</groupId> <artifactId>tess4j</artifactId> <version>5.8.0</version> </dependency> <!-- Image processing --> <dependency> <groupId>com.twelvemonkeys.imageio</groupId> <artifactId>imageio</artifactId> <version>3.9.4</version> </dependency> <!-- JavaFX for GUI (optional) --> <dependency> <groupId>org.openjfx</groupId> <artifactId>javafx-controls</artifactId> <version>17.0.2</version> </dependency> </dependencies>

Tesseract Installation

Windows:

1. Download Tesseract from GitHub releases
2. Install to C:\Program Files\Tesseract-OCR\
3. Add to PATH or set TESSDATA_PREFIX environment variable

Linux (Ubuntu/Debian):

sudo apt-get update sudo apt-get install tesseract-ocr sudo apt-get install libtesseract-dev

macOS:

brew install tesseract brew install tesseract-lang

2. Basic OCR Implementation

Simple Text Extraction

import net.sourceforge.tess4j.Tesseract; import net.sourceforge.tess4j.TesseractException; import java.io.File; public class BasicOCR { public static String extractTextFromImage(String imagePath) { try { Tesseract tesseract = new Tesseract(); // Set tessdata path (where language data files are located) tesseract.setDatapath("tessdata"); // Set language (default is English) tesseract.setLanguage("eng"); // Perform OCR String result = tesseract.doOCR(new File(imagePath)); return result; } catch (TesseractException e) { System.err.println("OCR Error: " + e.getMessage()); return null; } } public static void main(String[] args) { String imagePath = "sample.png"; String extractedText = extractTextFromImage(imagePath); if (extractedText != null) { System.out.println("Extracted Text:"); System.out.println(extractedText); } else { System.out.println("Failed to extract text from image."); } } }

Advanced OCR Configuration

import net.sourceforge.tess4j.Tesseract; import net.sourceforge.tess4j.TesseractException; import net.sourceforge.tess4j.util.ImageHelper; import java.awt.image.BufferedImage; import java.io.File; import javax.imageio.ImageIO; public class AdvancedOCR { private Tesseract tesseract; public AdvancedOCR() { initializeTesseract(); } private void initializeTesseract() { tesseract = new Tesseract(); // Basic configuration tesseract.setDatapath("tessdata"); tesseract.setLanguage("eng"); // Advanced configuration tesseract.setPageSegMode(6); // 6 = Uniform block of text tesseract.setOcrEngineMode(1); // 1 = Neural nets LSTM engine // Performance settings tesseract.setTessVariable("preserve_interword_spaces", "1"); tesseract.setTessVariable("user_defined_dpi", "300"); } public String extractText(String imagePath) throws TesseractException { return tesseract.doOCR(new File(imagePath)); } public String extractTextWithPreprocessing(String imagePath) throws Exception { BufferedImage image = ImageIO.read(new File(imagePath)); // Preprocess image for better OCR results BufferedImage processedImage = preprocessImage(image); return tesseract.doOCR(processedImage); } private BufferedImage preprocessImage(BufferedImage image) { // Convert to grayscale BufferedImage grayscale = ImageHelper.convertImageToGrayscale(image); // Increase contrast BufferedImage highContrast = ImageHelper.convertImageToBinary(grayscale); // Resize image if too small (minimum 300 DPI recommended) if (highContrast.getWidth() < 600) { double scale = 600.0 / highContrast.getWidth(); highContrast = ImageHelper.getScaledInstance( highContrast, (int)(highContrast.getWidth() * scale), (int)(highContrast.getHeight() * scale) ); } return highContrast; } // Method to get confidence scores public void analyzeOCRConfidence(String imagePath) throws TesseractException { File imageFile = new File(imagePath); // Get OCR result with confidence information String result = tesseract.doOCR(imageFile); // Note: Tess4j doesn't directly provide confidence scores in current version // You might need to use different approaches or libraries for confidence analysis System.out.println("OCR Result:"); System.out.println(result); } public static void main(String[] args) { try { AdvancedOCR ocr = new AdvancedOCR(); String imagePath = "document.png"; String text = ocr.extractTextWithPreprocessing(imagePath); System.out.println("Extracted Text:"); System.out.println(text); } catch (Exception e) { e.printStackTrace(); } } }

3. Image Preprocessing for Better OCR

Comprehensive Image Preprocessing

import java.awt.Color; import java.awt.Graphics2D; import java.awt.Image; import java.awt.RenderingHints; import java.awt.image.BufferedImage; import java.awt.image.ConvolveOp; import java.awt.image.Kernel; import java.io.File; import javax.imageio.ImageIO; public class ImagePreprocessor { public static BufferedImage preprocessForOCR(BufferedImage originalImage) { BufferedImage processed = originalImage; // Step 1: Convert to grayscale processed = convertToGrayscale(processed); // Step 2: Noise reduction processed = reduceNoise(processed); // Step 3: Enhance contrast processed = enhanceContrast(processed); // Step 4: Sharpen image processed = sharpenImage(processed); // Step 5: Deskew if needed processed = deskewImage(processed); // Step 6: Resize for better OCR (if image is too small) processed = resizeImage(processed, 2.0); // Double the size return processed; } public static BufferedImage convertToGrayscale(BufferedImage image) { BufferedImage grayscale = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_BYTE_GRAY); Graphics2D g = grayscale.createGraphics(); g.drawImage(image, 0, 0, null); g.dispose(); return grayscale; } public static BufferedImage reduceNoise(BufferedImage image) { // Apply Gaussian blur for noise reduction float[] matrix = { 1/16f, 2/16f, 1/16f, 2/16f, 4/16f, 2/16f, 1/16f, 2/16f, 1/16f }; Kernel kernel = new Kernel(3, 3, matrix); ConvolveOp op = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null); return op.filter(image, null); } public static BufferedImage enhanceContrast(BufferedImage image) { // Simple contrast enhancement by stretching histogram int width = image.getWidth(); int height = image.getHeight(); BufferedImage contrasted = new BufferedImage(width, height, image.getType()); int[] histogram = new int[256]; // Build histogram for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { Color color = new Color(image.getRGB(x, y)); int gray = (color.getRed() + color.getGreen() + color.getBlue()) / 3; histogram[gray]++; } } // Find min and max values (ignoring extremes) int min = 0, max = 255; for (int i = 0; i < 256; i++) { if (histogram[i] > width * height * 0.001) { // Ignore extreme darks min = i; break; } } for (int i = 255; i >= 0; i--) { if (histogram[i] > width * height * 0.001) { // Ignore extreme brights max = i; break; } } // Apply contrast stretch for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { Color color = new Color(image.getRGB(x, y)); int gray = (color.getRed() + color.getGreen() + color.getBlue()) / 3; // Stretch contrast int newGray = (gray - min) * 255 / (max - min); newGray = Math.max(0, Math.min(255, newGray)); Color newColor = new Color(newGray, newGray, newGray); contrasted.setRGB(x, y, newColor.getRGB()); } } return contrasted; } public static BufferedImage sharpenImage(BufferedImage image) { // Sharpening kernel float[] matrix = { -1, -1, -1, -1, 9, -1, -1, -1, -1 }; Kernel kernel = new Kernel(3, 3, matrix); ConvolveOp op = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null); return op.filter(image, null); } public static BufferedImage deskewImage(BufferedImage image) { // Simple deskewing by detecting text angle // This is a simplified version - real deskewing is more complex return image; // Implement proper deskewing as needed } public static BufferedImage resizeImage(BufferedImage image, double scale) { int newWidth = (int) (image.getWidth() * scale); int newHeight = (int) (image.getHeight() * scale); Image scaled = image.getScaledInstance(newWidth, newHeight, Image.SCALE_SMOOTH); BufferedImage resized = new BufferedImage(newWidth, newHeight, image.getType()); Graphics2D g2d = resized.createGraphics(); g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); g2d.drawImage(scaled, 0, 0, null); g2d.dispose(); return resized; } public static void saveImage(BufferedImage image, String outputPath) throws Exception { File output = new File(outputPath); ImageIO.write(image, "png", output); } public static void main(String[] args) { try { // Load original image BufferedImage original = ImageIO.read(new File("input.jpg")); // Preprocess image BufferedImage processed = preprocessForOCR(original); // Save processed image saveImage(processed, "processed.png"); System.out.println("Image preprocessing completed."); } catch (Exception e) { e.printStackTrace(); } } }

4. Multi-language OCR

Supporting Multiple Languages

import net.sourceforge.tess4j.Tesseract; import net.sourceforge.tess4j.TesseractException; import java.io.File; import java.util.HashMap; import java.util.Map; public class MultiLanguageOCR { private Tesseract tesseract; private Map<String, String> languageMap; public MultiLanguageOCR() { initializeTesseract(); initializeLanguages(); } private void initializeTesseract() { tesseract = new Tesseract(); tesseract.setDatapath("tessdata"); tesseract.setPageSegMode(6); } private void initializeLanguages() { languageMap = new HashMap<>(); languageMap.put("english", "eng"); languageMap.put("spanish", "spa"); languageMap.put("french", "fra"); languageMap.put("german", "deu"); languageMap.put("chinese", "chi_sim"); languageMap.put("japanese", "jpn"); languageMap.put("korean", "kor"); languageMap.put("arabic", "ara"); languageMap.put("russian", "rus"); } public String detectLanguage(String imagePath) throws TesseractException { // Simple language detection by trying multiple languages String bestLanguage = "eng"; int bestScore = 0; for (String langCode : languageMap.values()) { try { tesseract.setLanguage(langCode); String result = tesseract.doOCR(new File(imagePath)); // Simple scoring based on valid characters and word count int score = calculateOCRScore(result); if (score > bestScore) { bestScore = score; bestLanguage = langCode; } } catch (TesseractException e) { // Language data might not be available continue; } } return bestLanguage; } private int calculateOCRScore(String text) { if (text == null || text.trim().isEmpty()) { return 0; } // Count words (simple whitespace splitting) String[] words = text.trim().split("\\s+"); int wordCount = words.length; // Count valid characters (alphanumeric and common punctuation) int validChars = 0; for (char c : text.toCharArray()) { if (Character.isLetterOrDigit(c) || ".,!?;:-'\"()[]{} ".indexOf(c) >= 0) { validChars++; } } return wordCount * 10 + validChars; } public OCRResult extractText(String imagePath, String language) throws TesseractException { String langCode = languageMap.getOrDefault(language.toLowerCase(), "eng"); tesseract.setLanguage(langCode); long startTime = System.currentTimeMillis(); String text = tesseract.doOCR(new File(imagePath)); long endTime = System.currentTimeMillis(); return new OCRResult(text, langCode, endTime - startTime); } public OCRResult extractTextAutoLanguage(String imagePath) throws TesseractException { String detectedLanguage = detectLanguage(imagePath); return extractText(imagePath, getLanguageName(detectedLanguage)); } private String getLanguageName(String langCode) { for (Map.Entry<String, String> entry : languageMap.entrySet()) { if (entry.getValue().equals(langCode)) { return entry.getKey(); } } return "english"; } public static class OCRResult { private final String text; private final String language; private final long processingTime; public OCRResult(String text, String language, long processingTime) { this.text = text; this.language = language; this.processingTime = processingTime; } // Getters public String getText() { return text; } public String getLanguage() { return language; } public long getProcessingTime() { return processingTime; } @Override public String toString() { return String.format("Language: %s\nProcessing Time: %dms\nText:\n%s", language, processingTime, text); } } public static void main(String[] args) { try { MultiLanguageOCR ocr = new MultiLanguageOCR(); String imagePath = "multi_language_document.png"; // Auto-detect language OCRResult result = ocr.extractTextAutoLanguage(imagePath); System.out.println("Auto-detected Result:"); System.out.println(result); // Extract with specific language OCRResult frenchResult = ocr.extractText(imagePath, "french"); System.out.println("\nFrench-specific Result:"); System.out.println(frenchResult); } catch (Exception e) { e.printStackTrace(); } } }

5. Batch Processing and PDF OCR

Batch Image Processing

import net.sourceforge.tess4j.Tesseract; import net.sourceforge.tess4j.TesseractException; import java.io.*; import java.nio.file.*; import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; public class BatchOCRProcessor { private Tesseract tesseract; private ExecutorService executorService; public BatchOCRProcessor() { initializeTesseract(); executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); } private void initializeTesseract() { tesseract = new Tesseract(); tesseract.setDatapath("tessdata"); tesseract.setLanguage("eng"); tesseract.setPageSegMode(6); } public List<OCRJobResult> processDirectory(String directoryPath) throws Exception { List<Path> imageFiles = findImageFiles(directoryPath); List<Future<OCRJobResult>> futures = new ArrayList<>(); for (Path imageFile : imageFiles) { Callable<OCRJobResult> task = () -> processSingleFile(imageFile); futures.add(executorService.submit(task)); } List<OCRJobResult> results = new ArrayList<>(); for (Future<OCRJobResult> future : futures) { try { results.add(future.get()); } catch (Exception e) { System.err.println("Error processing file: " + e.getMessage()); } } return results; } private List<Path> findImageFiles(String directoryPath) throws IOException { List<Path> imageFiles = new ArrayList<>(); Files.walk(Paths.get(directoryPath)) .filter(path -> { String fileName = path.getFileName().toString().toLowerCase(); return fileName.endsWith(".jpg") || fileName.endsWith(".jpeg") || fileName.endsWith(".png") || fileName.endsWith(".tiff") || fileName.endsWith(".bmp") || fileName.endsWith(".gif"); }) .forEach(imageFiles::add); return imageFiles; } private OCRJobResult processSingleFile(Path imageFile) { try { long startTime = System.currentTimeMillis(); String text = tesseract.doOCR(imageFile.toFile()); long endTime = System.currentTimeMillis(); return new OCRJobResult( imageFile.getFileName().toString(), text, endTime - startTime, true, null ); } catch (TesseractException e) { return new OCRJobResult( imageFile.getFileName().toString(), "", 0, false, e.getMessage() ); } } public void exportResults(List<OCRJobResult> results, String outputDir) throws IOException { Path outputPath = Paths.get(outputDir); Files.createDirectories(outputPath); for (OCRJobResult result : results) { if (result.isSuccess()) { String outputFileName = result.getFileName().replaceAll("\\.[^.]*$", "") + ".txt"; Path outputFile = outputPath.resolve(outputFileName); Files.write(outputFile, result.getText().getBytes()); } } // Create summary report createSummaryReport(results, outputPath.resolve("ocr_summary.csv")); } private void createSummaryReport(List<OCRJobResult> results, Path summaryPath) throws IOException { StringBuilder csv = new StringBuilder(); csv.append("File Name,Success,Processing Time (ms),Text Length,Error\n"); for (OCRJobResult result : results) { csv.append(String.format("\"%s\",%s,%d,%d,\"%s\"\n", result.getFileName(), result.isSuccess(), result.getProcessingTime(), result.getText().length(), result.getError() != null ? result.getError() : "" )); } Files.write(summaryPath, csv.toString().getBytes()); } public void shutdown() { executorService.shutdown(); try { if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) { executorService.shutdownNow(); } } catch (InterruptedException e) { executorService.shutdownNow(); Thread.currentThread().interrupt(); } } public static class OCRJobResult { private final String fileName; private final String text; private final long processingTime; private final boolean success; private final String error; public OCRJobResult(String fileName, String text, long processingTime, boolean success, String error) { this.fileName = fileName; this.text = text; this.processingTime = processingTime; this.success = success; this.error = error; } // Getters public String getFileName() { return fileName; } public String getText() { return text; } public long getProcessingTime() { return processingTime; } public boolean isSuccess() { return success; } public String getError() { return error; } } public static void main(String[] args) { BatchOCRProcessor processor = null; try { processor = new BatchOCRProcessor(); String inputDirectory = "images/"; String outputDirectory = "ocr_results/"; System.out.println("Starting batch OCR processing..."); List<OCRJobResult> results = processor.processDirectory(inputDirectory); System.out.println("Exporting results..."); processor.exportResults(results, outputDirectory); // Print summary long totalFiles = results.size(); long successfulFiles = results.stream().filter(OCRJobResult::isSuccess).count(); long totalProcessingTime = results.stream().mapToLong(OCRJobResult::getProcessingTime).sum(); System.out.printf("Batch Processing Complete:%n"); System.out.printf("Total Files: %d%n", totalFiles); System.out.printf("Successful: %d%n", successfulFiles); System.out.printf("Failed: %d%n", totalFiles - successfulFiles); System.out.printf("Total Processing Time: %dms%n", totalProcessingTime); System.out.printf("Average Time per File: %.2fms%n", (double) totalProcessingTime / totalFiles); } catch (Exception e) { e.printStackTrace(); } finally { if (processor != null) { processor.shutdown(); } } } }

6. JavaFX OCR Application

GUI OCR Application

import javafx.application.Application; import javafx.geometry.Insets; import javafx.scene.Scene; import javafx.scene.control.*; import javafx.scene.image.Image; import javafx.scene.image.ImageView; import javafx.scene.layout.*; import javafx.stage.FileChooser; import javafx.stage.Stage; import net.sourceforge.tess4j.Tesseract; import net.sourceforge.tess4j.TesseractException; import java.io.File; public class OCRGUIApplication extends Application { private Tesseract tesseract; private TextArea resultTextArea; private ImageView imageView; private Label statusLabel; private File currentImageFile; @Override public void start(Stage primaryStage) { initializeTesseract(); setupUI(primaryStage); } private void initializeTesseract() { tesseract = new Tesseract(); tesseract.setDatapath("tessdata"); tesseract.setLanguage("eng"); } private void setupUI(Stage stage) { // Create UI components BorderPane root = new BorderPane(); root.setPadding(new Insets(10)); // Top menu MenuBar menuBar = createMenuBar(stage); // Image display imageView = new ImageView(); imageView.setFitWidth(400); imageView.setFitHeight(300); imageView.setPreserveRatio(true); VBox imageBox = new VBox(10, new Label("Selected Image:"), imageView); imageBox.setPadding(new Insets(10)); // Result area resultTextArea = new TextArea(); resultTextArea.setPromptText("Extracted text will appear here..."); resultTextArea.setWrapText(true); VBox resultBox = new VBox(10, new Label("Extracted Text:"), resultTextArea); resultBox.setPadding(new Insets(10)); // Control buttons Button extractButton = new Button("Extract Text"); extractButton.setOnAction(e -> extractText()); Button clearButton = new Button("Clear"); clearButton.setOnAction(e -> clearResults()); HBox buttonBox = new HBox(10, extractButton, clearButton); buttonBox.setPadding(new Insets(10)); // Status bar statusLabel = new Label("Ready"); statusLabel.setPadding(new Insets(5)); // Layout HBox contentBox = new HBox(20, imageBox, resultBox); VBox mainBox = new VBox(10, menuBar, contentBox, buttonBox, statusLabel); root.setCenter(mainBox); Scene scene = new Scene(root, 900, 600); stage.setTitle("OCR Text Extraction Tool"); stage.setScene(scene); stage.show(); } private MenuBar createMenuBar(Stage stage) { MenuBar menuBar = new MenuBar(); // File menu Menu fileMenu = new Menu("File"); MenuItem openItem = new MenuItem("Open Image"); openItem.setOnAction(e -> openImage(stage)); MenuItem saveItem = new MenuItem("Save Text"); saveItem.setOnAction(e -> saveText()); MenuItem exitItem = new MenuItem("Exit"); exitItem.setOnAction(e -> stage.close()); fileMenu.getItems().addAll(openItem, new SeparatorMenuItem(), saveItem, exitItem); // Language menu Menu languageMenu = new Menu("Language"); RadioMenuItem englishItem = new RadioMenuItem("English"); englishItem.setSelected(true); englishItem.setOnAction(e -> tesseract.setLanguage("eng")); RadioMenuItem spanishItem = new RadioMenuItem("Spanish"); spanishItem.setOnAction(e -> tesseract.setLanguage("spa")); RadioMenuItem frenchItem = new RadioMenuItem("French"); frenchItem.setOnAction(e -> tesseract.setLanguage("fra")); ToggleGroup languageGroup = new ToggleGroup(); englishItem.setToggleGroup(languageGroup); spanishItem.setToggleGroup(languageGroup); frenchItem.setToggleGroup(languageGroup); languageMenu.getItems().addAll(englishItem, spanishItem, frenchItem); menuBar.getMenus().addAll(fileMenu, languageMenu); return menuBar; } private void openImage(Stage stage) { FileChooser fileChooser = new FileChooser(); fileChooser.setTitle("Open Image File"); fileChooser.getExtensionFilters().addAll( new FileChooser.ExtensionFilter("Image Files", "*.png", "*.jpg", "*.jpeg", "*.gif", "*.bmp"), new FileChooser.ExtensionFilter("All Files", "*.*") ); File file = fileChooser.showOpenDialog(stage); if (file != null) { currentImageFile = file; displayImage(file); statusLabel.setText("Image loaded: " + file.getName()); } } private void displayImage(File file) { try { Image image = new Image(file.toURI().toString()); imageView.setImage(image); } catch (Exception e) { showAlert("Error", "Could not load image: " + e.getMessage()); } } private void extractText() { if (currentImageFile == null) { showAlert("Warning", "Please select an image first."); return; } try { statusLabel.setText("Extracting text..."); // Run OCR in background thread new Thread(() -> { try { String extractedText = tesseract.doOCR(currentImageFile); // Update UI on JavaFX thread javafx.application.Platform.runLater(() -> { resultTextArea.setText(extractedText); statusLabel.setText("Text extraction completed successfully."); }); } catch (TesseractException e) { javafx.application.Platform.runLater(() -> { showAlert("OCR Error", "Failed to extract text: " + e.getMessage()); statusLabel.setText("Text extraction failed."); }); } }).start(); } catch (Exception e) { showAlert("Error", "Unexpected error: " + e.getMessage()); } } private void clearResults() { resultTextArea.clear(); imageView.setImage(null); currentImageFile = null; statusLabel.setText("Ready"); } private void saveText() { if (resultTextArea.getText().isEmpty()) { showAlert("Warning", "No text to save."); return; } FileChooser fileChooser = new FileChooser(); fileChooser.setTitle("Save Text"); fileChooser.getExtensionFilters().add( new FileChooser.ExtensionFilter("Text Files", "*.txt") ); File file = fileChooser.showSaveDialog(resultTextArea.getScene().getWindow()); if (file != null) { try { java.nio.file.Files.write(file.toPath(), resultTextArea.getText().getBytes()); statusLabel.setText("Text saved to: " + file.getName()); } catch (Exception e) { showAlert("Error", "Could not save file: " + e.getMessage()); } } } private void showAlert(String title, String message) { Alert alert = new Alert(Alert.AlertType.INFORMATION); alert.setTitle(title); alert.setHeaderText(null); alert.setContentText(message); alert.showAndWait(); } @Override public void stop() { // Cleanup resources if needed } public static void main(String[] args) { launch(args); } }

Key Features Covered:

1. Basic OCR Setup - Tesseract configuration and simple text extraction
2. Image Preprocessing - Techniques to improve OCR accuracy
3. Multi-language Support - Working with different languages
4. Batch Processing - Processing multiple files efficiently
5. GUI Application - User-friendly OCR tool with JavaFX
6. Performance Optimization - Threading and efficient processing

This comprehensive OCR implementation provides everything needed to integrate text recognition capabilities into Java applications, from basic usage to advanced features like multi-language support and batch processing.