package com.aspose.pdf.examples.workingwithdocuments;

 

import com.aspose.pdf.Document;

import com.aspose.pdf.Page;

import com.aspose.pdf.TextFragment;

import com.aspose.pdf.devices.PngDevice;

import com.aspose.pdf.devices.Resolution;

import com.aspose.pdf.examples.ExampleConfig;

import com.aspose.pdf.examples.ExampleDataDirs;

import com.aspose.pdf.examples.ExampleRunner;

 

import javax.imageio.ImageIO;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.Scanner;

import java.util.concurrent.TimeUnit;

 

public final class CreatePdfDocumentExamples {

// Change this to match your installation, or use "tesseract" for PATH lookup.

private static final String TESSERACT_PATH = "C:\\Program Files\\Tesseract-OCR\\tesseract.exe";

private static final long TESSERACT_TIMEOUT_MINUTES = 2;

 

private CreatePdfDocumentExamples() {

}

 

public static void createNewDocument(Path outputFile) {

try (Document document = new Document()) {

Page page = document.getPages().add();

page.getParagraphs().add(new TextFragment("Hello World!"));

document.save(outputFile.toString());

}

}

 

// Begin examples Searchable PDF

public static void createSearchablePdf_1(Path inputFile, Path outputFile) {

Path tempDir = outputFile.toAbsolutePath().getParent().resolve("ocr-temp");

 

// Create callBack - logic recognize text for PDF images. Use outer OCR supports

// HOCR standard(en.wikipedia.org

// We have used free google tesseract

// OCR(en.wikipedia.org

 

Document.CallBackGetHocr callBackGetHocr = new Document.CallBackGetHocr() {

@Override

public String invoke(java.awt.image.BufferedImage img) {

File outputfile = tempDir.resolve("test.jpg").toFile();

try {

Files.createDirectories(tempDir);

ImageIO.write(img, "jpg", outputfile);

} catch (IOException e1) {

throw new java.io.UncheckedIOException("Failed to write OCR image.", e1);

}

 

try {

Path outputBase = tempDir.resolve("out");

runTesseract(outputfile.toPath(), outputBase, "hocr", tempDir.resolve("tesseract.log"));

} catch (IOException e) {

throw new java.io.UncheckedIOException("Tesseract OCR failed.", e);

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

throw new IllegalStateException("Tesseract OCR was interrupted.", e);

}

 

// reading out.html to string

File file = tempDir.resolve("out.hocr").toFile();

StringBuilder fileContents = new StringBuilder((int) file.length());

Scanner scanner = null;

try {

scanner = new Scanner(file);

String lineSeparator = System.getProperty("line.separator");

 

while (scanner.hasNextLine()) {

fileContents.append(scanner.nextLine() + lineSeparator);

}

} catch (FileNotFoundException e) {

throw new java.io.UncheckedIOException("Tesseract OCR failed.", e);

} finally {

if (scanner != null)

scanner.close();

}

 

// deleting temp files

File fileOut = tempDir.resolve("out.hocr").toFile();

if (fileOut.exists()) {

fileOut.delete();

}

File fileLog = tempDir.resolve("tesseract.log").toFile();

if (fileLog.exists()) {

fileLog.delete();

}

File fileTest = tempDir.resolve("test.jpg").toFile();

if (fileTest.exists()) {

fileTest.delete();

}

 

return fileContents.toString();

}

};

// End callBack

try (Document document = new Document(inputFile.toString())) {

if (!document.convert(callBackGetHocr))

throw new RuntimeException("Failed to convert document.");

document.save(outputFile.toString());

}

}

 

/**

* Creates a searchable PDF using Tesseract 4 or newer with English LSTM data.

*/

public static void createSearchablePdf_2(Path inputFile, Path outputFile)

throws IOException, InterruptedException {

Path outputDirectory = outputFile.toAbsolutePath().getParent();

Files.createDirectories(outputDirectory);

Path tempDir = Files.createTempDirectory(outputDirectory, "ocr-");

Path tempImage = tempDir.resolve("page.png");

Path tempDoc = tempDir.resolve("page");

Path tempPdf = tempDir.resolve("page.pdf");

Path tempLog = tempDir.resolve("page.log");

Throwable failure = null;

try (Document inputDocument = new Document(inputFile.toString());

Document outputDocument = new Document()) {

PngDevice pngDevice = new PngDevice(new Resolution(600));

for (Page page : inputDocument.getPages()) {

pngDevice.process(page, tempImage.toString());

runTesseract(tempImage, tempDoc, "pdf", tempLog);

outputDocument.merge(tempPdf.toString());

Files.deleteIfExists(tempPdf);

}

outputDocument.save(outputFile.toString());

} catch (InterruptedException e) {

failure = e;

Thread.currentThread().interrupt();

throw e;

} catch (IOException | RuntimeException | Error e) {

failure = e;

throw e;

} finally {

IOException cleanupFailure = null;

for (Path path : new Path[]{tempImage, tempPdf, tempLog, tempDir}) {

try {

Files.deleteIfExists(path);

} catch (IOException e) {

if (cleanupFailure == null) {

cleanupFailure = e;

} else {

cleanupFailure.addSuppressed(e);

}

}

}

if (cleanupFailure != null) {

if (failure != null) {

failure.addSuppressed(cleanupFailure);

} else {

throw cleanupFailure;

}

}

}

}

 

 

private static void runTesseract(Path image, Path outputBase, String format, Path log)

throws IOException, InterruptedException {

Path result = Path.of(outputBase + "." + format);

Files.deleteIfExists(result);

ProcessBuilder builder = new ProcessBuilder(

TESSERACT_PATH, image.toString(), outputBase.toString(),

"-l", "eng", "--oem", "1", "--psm", "3", format);

builder.redirectErrorStream(true);

builder.redirectOutput(log.toFile());

Process process = builder.start();

try {

process.getOutputStream().close();

if (!process.waitFor(TESSERACT_TIMEOUT_MINUTES, TimeUnit.MINUTES)) {

throw new IOException("Tesseract timed out after "

+ TESSERACT_TIMEOUT_MINUTES + " minutes while processing " + image);

}

if (process.exitValue() != 0 || !Files.isRegularFile(result)

|| Files.size(result) == 0) {

throw new IOException("Tesseract failed (exit " + process.exitValue()

+ ") while processing " + image + ": " + Files.readString(log));

}

} finally {

if (process.isAlive()) {

process.destroyForcibly();

process.onExit().join();

}

}

}

 

// End examples Searchable PDF

public static void runAllExamples(String licensePath) throws Exception {

ExampleConfig.setLicense(licensePath);

ExampleDataDirs dirs = ExampleConfig.initializeDataDir("working_with_documents");

 

ExampleRunner.run("Create new document",

() -> createNewDocument(dirs.outputFile("create_new_document.pdf")));

ExampleRunner.run("Create searchable PDF (Method 1)",

() -> createSearchablePdf_1(

dirs.inputFile("sample5.pdf"),

dirs.outputFile("create_searchable_pdf_1.pdf")));

ExampleRunner.run("Create searchable PDF (Method 2)",

() -> createSearchablePdf_2(

dirs.inputFile("sample5.pdf"),

dirs.outputFile("create_searchable_pdf_2.pdf")));

 

System.out.println();

System.out.println("All PDF creation examples finished.");

}

 

public static void main(String[] args) throws Exception {

runAllExamples(ExampleConfig.resolveLicensePath(args));

}

}