Documentation – Developer's reference

Java: Preparing content for recognition

Wed, 26 Apr 2023 00:00:00 +0000

Aspose.OCR for Java provides a versatile way to prepare your content for OCR. A package of recognized files/directories/URLs, regardless of their number and type, is constructed as an instance of the OcrInput class. With this approach, you can easily process a single image or a large number of images from an auto-feed scanner in a single API call.

The object constructor takes the type of the provided content and optional processing filters that will be applied to all images in a batch.

Supported content types

You can only pack sources of the same type into one instance of the OcrInput class. The type is specified in the constructor and cannot be changed later.

Source content type	Supported file formats
`InputType.SingleImage`	One or more GIF, PNG, JPEG, BMP, or single-page TIFF images. The images can be provided by their absolute or relative paths, as `BufferedImage` objects, or as arrays of pixels. You can add images of different types in a single batch.
`InputType.PDF`	One or more PDF documents, containing scanned pages. The files can be provided by their absolute or relative paths or as `BufferedImage` objects.
`InputType.TIFF`	One or more multi-page TIFF images. The files can be provided by their absolute or relative paths or as `BufferedImage` objects.
`InputType.DJVU`	One or more DjVu files, provided by their absolute or relative paths or as `BufferedImage` objects.
`InputType.URL`	One or more web links to GIF, PNG, JPEG, BMP, or single-page TIFF images. Aspose.OCR for Java will download them automatically before processing. Limitations: Aspose.OCR for Java does not support authentication and can only work with public URLs. The URL must point directly to the image. Aspose.OCR for Java cannot extract images from HTML pages.
`InputType.Directory`	Absolute or relative paths to one or more directories containing GIF, PNG, JPEG, BMP, or single-page TIFF images. Unless specifically configured, all nested images will be recognized. Subdirectories and nested archives will not be processed!
`InputType.Zip`	Absolute or relative paths to one or more ZIP archives containing GIF, PNG, JPEG, BMP, or single-page TIFF images. Unless specifically configured, all archived images will be recognized. Nested archives and directories will not be processed!
`InputType.Base64`	One or more GIF, PNG, JPEG, BMP, or single-page TIFF images provided as Base64-encoded strings.

Combination of different content types (for example, images and PDF documents) within a single OcrInput object is not supported.

Adding source content

To manage a batch of images, scanned PDFs, URLs, directories, and other OCR content, use the following methods of the OcrInput class:

Method	Description
`add(string)`	Add an absolute or relative path to a file/directory, or a URL to an image file on the web.
`add(string, int, int)`	Add an absolute or relative path to a multi-page image, PDF document, ZIP archive or directory, specifying the images/pages for recognition.
`add(BufferedImage)`	Add a `BufferedImage` object, containing a file to be recognized.
`add(BufferedImage, int, int)`	Add a `BufferedImage` object, containing a milti-page image, PDF document, or ZIP archive, specifying the images/pages for recognition.
`add(InputStream)`	Add a `InputStream` stream, containing a file to be recognized.
`add(InputStream, int, int)`	Add a `InputStream` stream, containing a milti-page image, PDF document, or ZIP archive, specifying the images/pages for recognition.
`add(int[], int, int, PixelType)`	Add an image provided as an array of pixels. You must specify the width, height and the color depth (number of bits per pixel).
`addBase64(string)`	Add an image encoded as Base64 string.

To get the number of items in the batch, use size() method of the OcrInput class.

Removing source content

To clear a batch, use clear() method of the OcrInput class.

Applying image processing filters

The accuracy and reliability of text recognition is highly dependent on the quality of the original image. Aspose.OCR for Java offers a large number of fully automated and manual image processing filters that enhance an image before it is sent to the OCR engine.

To apply processing filters to all images in the batch, provide them in the OcrInput object constructor, or later using replaceFilters() method.

To remove all processing filters from a batch, use clearFilters() method of the OcrInput class.

Examples

The following code samples demonstrates how to prepare content for recognition:

Provide multiple images

OcrInput source = new OcrInput(InputType.SingleImage);
source.add("image1.png");
source.add("image2.jpg");

Provide scanned PDF

OcrInput source = new OcrInput(InputType.PDF);
// Recognize pages 2 to 8
source.add("scan.pdf", 1, 7);

Apply processing filters

// Automatically deskew all images
PreprocessingFilter filters = new PreprocessingFilter();
filters.add(Models.PreprocessingFilters.PreprocessingFilter.AutoSkew());
// Prepare batch
OcrInput source = new OcrInput(InputType.SingleImage, filters);
source.add("image1.png");
source.add("image2.jpg");

Java: Image processing

Fri, 14 Jul 2023 00:00:00 +0000

The accuracy and reliability of text recognition is highly dependent on the quality of the original image. Aspose.OCR offers a large number of fully automated and manual image processing filters that enhance an image before it is sent to the OCR engine.

Each preprocessing filter increases the image processing time. The approximate amount of additional time required for pre-processing (as a percentage of the minimum image processing pipeline) is listed in the Performance Impact column.

Filter	Action	Performance impact	Usage scenarios
Skew correction	Automatically straighten images aligned at a slight angle to the horizontal.	12%	Skewed images
Rotation	Manually rotate severely skewed images.	7.5%	Rotated images
Noise removal	Automatically remove dirt, spots, scratches, glare, unwanted gradients, and other noise from photos and scans.	175% extra time 38% more memory ⁽¹⁾	Photos Old books Newspapers Postcards Documents with stains and dirt
Contrast correction	Automatically adjust the image contrast.	7.5%	Photos Old papers Text on a background
Resizing	Proportionally scale images up / down, or manually define the width and height of the image.	up to 100% ⁽²⁾	Medication guides Food labels Full-sized photos from modern cameras and smartphones Scanned images at very high DPI
Binarization	Convert images to black and white automatically or manually adjust the criteria that determines whether a pixel is considered black or white.	0.9%	Always used for text detection and most automatic image corrections
Conversion to grayscale	Discard color information from images and leave only shades of gray.	0.5%	Photos Scanned ID cards Full-color scans
Color inversion	Swap image colors so that light areas appear dark and dark areas appear light.	0.25%	White text on black background Advertisements Business cards Screenshots
Dilation	Increase the thickness of characters in an image by adding pixels to the edges of high-contrast objects, such as letters.	3.1%	Receipts Printouts with very thin font
Median filter	Blur noisy images while preserving the edges of high-contrast objects like letters.	6.25%	Photos taken in low light conditions Poor quality printouts Highly compressed JPEG’s
Dewarping	Straighten page curvature and fix camera lens distortion for page photos. This method requires significant resources and time! Consider using it only if the image has geometric distortions preventing accurate recognition.	30-40 seconds; Up to 4 times more memory ⁽³⁾	Photos of curved pages Ultra wide-angle and fisheye photos Photos from entry-level smartphones

Notes

Automatic noise removal uses a powerful artificial intelligence algorithm that consumes significant computing resources and RAM. Use it with care, especially when developing public websites and mobile apps.
Resizing takes between 6% and 100% more time than the minimum processing pipeline, depending on the original image size.
Due to the high complexity of the underlying neural network, dewarping is resource- and time-intensive. Actual numbers may vary greatly depending on the performance of the computer and the characteristics of the original image.

Chaining preprocessing filters

Multiple preprocessing filters can be applied to the same image to further improve the recognition quality. The filters are applied one by one in the order they are added to PreprocessingFilter object.

Note that each filter requires additional time and resources on the computer running the application. Do not add extra filters if you are satisfied with the recognition accuracy, especially when developing web applications.

Set binarization threshold

Correct skew

Rotate

Remove noise

Adjust contrast

Scale

Resize

Convert to grayscale

Invert colors

Dilate

Apply median filter

PreprocessingFilter filters = new PreprocessingFilter();
filters.add(PreprocessingFilter.Threshold({THRESHOLD}));
filters.add(PreprocessingFilter.AutoSkew());
filters.add(PreprocessingFilter.Rotate({ANGLE}));
filters.add(PreprocessingFilter.AutoDenoising());
filters.add(PreprocessingFilter.ContrastCorrectionFilter());
filters.add(PreprocessingFilter.Scale({RATIO}));
filters.add(PreprocessingFilter.Resize({WIDTH}, {HEIGHT}));
filters.add(PreprocessingFilter.ToGrayscale());
filters.add(PreprocessingFilter.Invert());
filters.add(PreprocessingFilter.Dilate());
filters.add(PreprocessingFilter.Median());

Approximate increase of processing time: 0%

Image regions preprocessing

Most preprocessing filters can be applied to specific regions of an image. For example, you can invert a newspaper headline written in white on black, leaving the rest of the article unchanged.

Multiple preprocessing filters can be applied to different regions of the same image. If the regions intersect each other, filters are applied to the intersection in their chaining order in PreprocessingFilter object.

To apply a filter to an area, specify its top left corner along with width and height as Rectangle object. If the region is omitted, the filter is applied to the entire image.

// Define image regions
Rectangle blackRectangle = new Rectangle(5, 161, 340, 113);
PreprocessingFilter filters = new PreprocessingFilter();
// (1) Invert black region
filters.add(PreprocessingFilter.Invert(blackRectangle));
// (2) Denoise entire image
filters.add(PreprocessingFilter.AutoDenoising());

The following filters can be applied to regions:

Previewing and saving processed images

Aspose.OCR for Java offers an easy way to access or save processed images using the methods of the static ImageProcessing class:

Method	Return value	Description
`Render`	`OcrInput`	Applies processing filters to all images in a batch and returns a new batch with processed images. This batch can later be submitted for recognition or used for optimization.
`Save`	`OcrInput`	Applies processing filters to all images in batch and saves the resulting images in the specified folder. That method also returns a new batch with processed images, that can be later submitted for the recognition.

You can use these methods to analyze the effectiveness of processing filters, exclude unnecessary filters that consume resources without affecting the result, or show the result of image processing in the user interface.

Processing filters are applied to all images in the batch, including those without text.
PDF documents can contain more than one image per page. Therefore, the resulting OcrInput object can contain more images than the number of pages in the document.

// Set processing filters
PreprocessingFilter filters = new PreprocessingFilter();
filters.add(PreprocessingFilter.AutoDenoising());
filters.add(PreprocessingFilter.Median());
// Prepare batch
OcrInput images = new OcrInput(InputType.SingleImage, filters);
images.add("image1.png");
images.add("image2.jpg");
// Save processed images from the provided PDF to the folder
ImageProcessing.Save(images, "C:\\images");

Java: Recognition languages

Mon, 16 Dec 2024 00:00:00 +0000

To recognize text in certain languages, you must install additional recognition models:

Cyrillic text recognition: aspose-ocr-cyrillic-v1
Chinese text recognition: aspose-ocr-chinese-v2
Indic (Devanagari) text recognition: aspose-ocr-hindi-v2
Arabic text recognition: aspose-ocr-arabic-v1
Persian (Farsi) text recognition: aspose-ocr-arabic-v1
Uyghur text recognition: aspose-ocr-arabic-v1
Urdu text recognition: aspose-ocr-arabic-v1
Japanese text recognition: aspose-ocr-japanese-v1
Korean text recognition: aspose-ocr-korean-v1
Kannada text recognition: aspose-ocr-kannada-v1
Tamil text recognition: aspose-ocr-tamil-v1
Telugu text recognition: aspose-ocr-telugu-v1
Mixed-language Cyrillic/English recognition: aaspose-ocr-cyrillic-v2
Mongolian text recognition: aspose-ocr-cyrillic-v1

Aspose.OCR for Java can recognize a text in a large number of languages and all popular writing scripts, including texts with mixed languages.

To specify a language for recognition, provide one of the following values in setLanguage method of RecognitionSettings class:

Mixed-language Cyrillic/English text recognition is experimental. If you are absolutely sure about the text language (for example, Ukrainian), it is recommended to specify the language directly.

Value	Alphabet
`Language.MULTILANGUAGE` `Language.AUTO` `Language.UNIVERSAL`	Automatically detects the language. Supports multiple language families, including Latin, Cyrillic, Arabic, Chinese and more.
`Language.ExtLatin`	Auto-detect all supported Latin characters and diacritics
`Language.Cyrillic`	All supported Cyrillic characters (auto-detect)
`Language.Chinese`	All Chinese languages. Mixed-language Chinese/English texts also supported.
`Language.Devanagari` `Language.Indic`	Indic texts based on Devanagari script, including mixed Devanagari/English texts.
`Language.European`	Mixed-language Cyrillic/English texts (experimental).
`Language.PersoArabic` `Language.Islamic`	Mixed-language texts with Arabic, Persian and English.
`Language.Afr`	Afrikaans
`Language.Aln`	Albanian
`Language.Ara`	Arabic (mixed texts in Arabic and English are also supported)
`Language.Awa`	Awadhi
`Language.Azb`	Azerbaijani (Azeri)
`Language.Bcl`	Bikol
`Language.Bel`	Belarusan (Belorussian)
`Language.Bem`	Bemba (Chibemba)
`Language.Bew`	Betawi
`Language.Bgc`	Haryanvi
`Language.Bho`	Bhojpuri
`Language.Bhr`	Malagasy
`Language.Bjj`	Kanauji
`Language.Bos`	Bosnian
`Language.Bul`	Bulgarian
`Language.Cat`	Catalan
`Language.Ccx`	Zhuang
`Language.Cdo`	Min Dong
`Language.Ceb`	Cebuano
`Language.Ces`	Czech
`Language.Che`	Chechen
`Language.Cmn`	Mandarin (Chinese)
`Language.Cpx`	Pu-Xian
`Language.Dan`	Danish
`Language.Deu`	German
`Language.Dhd`	Dhundari
`Language.Diq`	Dimli
`Language.Doc`	Dong
`Language.Eng`	English
`Language.Est`	Estonian
`Language.Fin`	Finnish
`Language.Fra`	French
`Language.Gan`	Gan
`Language.Gax`	Oromo
`Language.Gbm`	Garhwali
`Language.Glg`	Galician
`Language.Glk`	Gilaki
`Language.Guz`	Gusii
`Language.Hak`	Hakka
`Language.Hau`	Hausa
`Language.Hbs`	Serbo-Croatian (Latin)
`Language.Hil`	Hiligaynon
`Language.Hin`	Hindi
`Language.Hmn`	Hmong
`Language.Hne`	Chattisgarhi (Laria, Khaltahi)
`Language.Hrv`	Croatian
`Language.Hsn`	Xiang
`Language.Hun`	Hungarian (Magyar)
`Language.Ilo`	Ilocano
`Language.Ind`	Indonesian
`Language.Ita`	Italian
`Language.Jpn`	Japanese (mixed texts in Japanese and English are also supported)
`Language.Kan`	Mixed-language Kannada/English texts.
`Language.Kaz`	Kazakh
`Language.Kbd`	Kabardian
`Language.Kfy`	Kumauni
`Language.Kin`	Rwanda
`Language.Kln`	Nandi
`Language.Kmr`	Kurdish (Kurmanji)
`Language.Knc`	Kanuri
`Language.Knn`	Konkani
`Language.Kon`	Kikongo
`Language.Kor`	Korean (mixed texts in Korean and English are also supported)
`Language.Latin`	Latin
`Language.Lav`	Latvian
`Language.Lit`	Lithuanian
`Language.Lmn`	Lamani (Lambadi)
`Language.Lnc`	Occitan
`Language.Luo`	Luo
`Language.Mag`	Magahi
`Language.Mai`	Maithili
`Language.Mak`	Makassar (Makasar)
`Language.Mar`	Marathi
`Language.Mer`	Meru
`Language.Min`	Minangkabau
`Language.Mly`	Malay (Melayu)
`Language.Mnp`	Min Bei
`Language.Mon`	Mongolian
`Language.Mtq`	Muong
`Language.Mtr`	Mewari
`Language.Mui`	Musi
`Language.Mup`	Malvi
`Language.Nan`	Min Nan
`Language.Nbl`	Ndebele
`Language.Nds`	Low German
`Language.Nep`	Nepali
`Language.Nld`	Dutch
`Language.Nor`	Norwegian
`Language.Nso`	Sotho (Northern)
`Language.Nya`	Chichewa (Chewa, Nyanja)
`Language.Pag`	Pangasinan
`Language.Pam`	Kapampangan
`Language.Pcc`	Bouyei (Buyi, Giáy)
`Language.Pes`	Persian (Farsi); mixed texts in Persian and English are also supported
`Language.Plm`	Palembang
`Language.Pol`	Polish
`Language.Por`	Portuguese
`Language.Quc`	K’iche'
`Language.Qxa`	Quechua
`Language.Rjb`	Rajbanshi
`Language.Ron`	Romanian
`Language.Ruf`	Luguru
`Language.Rus`	Russian
`Language.Rwr`	Marwari
`Language.Sas`	Sasak
`Language.Slk`	Slovak
`Language.Slv`	Slovene (Slovenian)
`Language.Sna`	Shona (Karanga)
`Language.Som`	Somali
`Language.Sot`	Sotho (Southern)
`Language.Spa`	Spanish
`Language.Srp`	Serbian (Cyrillic)
`Language.Srr`	Serer-Sine
`Language.Ssw`	Swati (Swazi)
`Language.Suk`	Sukuma
`Language.Sun`	Sundanese (Sunda)
`Language.Swe`	Swedish
`Language.Swh`	Swahili
`Language.Tam`	Mixed-language Tamil/English texts.
`Language.Tel`	Mixed-language Telugu/English texts.
`Language.Tgl`	Tagalog (Pilipino)
`Language.Toi`	Tonga
`Language.Tsn`	Tswana
`Language.Tso`	Tsonga
`Language.Tuk`	Turkmen
`Language.Tum`	Tumbuka
`Language.Tur`	Turkish
`Language.Uig`	Uyghur; mixed texts in Uyghur and English are also supported
`Language.Ukr`	Ukrainian
`Language.Umb`	Umbundu
`Language.Urd`	Urdu; mixed texts in Urdu and English are also supported
`Language.Vie`	Vietnamese
`Language.Vmw`	Makua (Makhuwa)
`Language.Wal`	Wolaytta
`Language.War`	Waray-Waray
`Language.Wbr`	Wagdi
`Language.Wtm`	Mewati
`Language.Wuu`	Wu (Changzhou)
`Language.Xho`	Xhosa
`Language.Yao`	Yao
`Language.Yor`	Yoruba
`Language.Yue`	Cantonese
`Language.Zul`	Zulu

If this parameter is omitted, the OCR engine will assume that the text is written in extended Latin.

Make sure you specify the correct language for the image. If you try to recognize Cyrillic text using Language.Eng, only the characters that look the same in both languages (for example, с and c) will be correctly recognized. Other characters will be replaced with similar-looking alternatives.

Example

The following code sample demonstrates how to specify the recognition language:

AsposeOCR api = new AsposeOCR();
RecognitionSettings recognitionSettings = new RecognitionSettings();
// Recognize Ukrainian text
recognitionSettings.setLanguage(Language.Ukr);
RecognitionResult result = api.RecognizePage("source.png", recognitionSettings);
System.out.println("Recognition result:\n" + result.recognitionText + "\n\n");

Java: Defining recognized characters

Fri, 23 Sep 2022 00:00:00 +0000

Aspose.OCR supports a large list of extended Latin, Cyrillic, and Chinese characters. However, a typical image contains no more than half of these characters. You can greatly improve the accuracy and performance of recognition by specifying which characters the OCR engine will look for.

The full workflow is as follows:

Identifying the characters on an image.
Aspose.OCR provides detailed information about the characters found in the image and their possible alternatives.
Defining the whitelist of characters.
Limit the set of characters Aspose.OCR engine will look for.
Defining the blacklist of characters.
Explicitly ignore certain image defects that may be incorrectly recognized as characters.

Java: Language detecton

Wed, 19 Mar 2025 00:00:00 +0000

To use language detection, install (aspose-ocr-language-classification-v1) advanced OCR model to your project.

Aspose.OCR for Java can automatically identify the following languages and language families used on the provided image using DetectLanguages method:

Latin
Cyrillic
Arabic
Chinese
Japanese
Korean
Hindi
Tamil
Telugu
Kannada

The method accepts the collection of images in any of the supported formats and returns them as a list of LanguageDetectionOutput objects with the following properties:

Property	Type	Description
`source`	`string`	The full path or URL of the source file. If the file is provided as a `BufferedImage`, `InputStream`, an array of pixels, or a Base64 string, this value will be empty.
`page`	`int`	Page number. When working with single-page images, this value is always 0.
`languages`	`List<Map.Entry<Language, Float>>`	Lists the recognition languages detected in the image along with their probabilities.

Example

The following code sample demonstrates how to detect the image languages:

OcrInput input = new OcrInput(InputType.SingleImage);
input.add("source.png");
LanguageDetectionOutput result = api.DetectLanguages(input).get(0);
out.println("File: " + result.source);
out.println("Page: " + result.page);
for(Map.Entry<Language, Float> l : result.languages)
out.println("Language: " + l.getKey()+ " : " + l.getValue());

The following code sample demonstrates how to recognize the image with auto detection languages:


AsposeOCR recognitionEngine = new AsposeOCR();
// Add an image to OcrInput object
OcrInput input = new OcrInput(InputType.SingleImage);
input.add("source.png");
// Set language detection and it is level.
RecognitionSettings settings = new RecognitionSettings();
settings.setLanguage(com.aspose.ocr.models.Language.Auto);
settings.setLanguageDetectionLevel(LanguageDetectionLevel.BY_PARAGRAPH);
		
// Recognize with detect languages
List<RecognitionResult> result = recognitionEngine.Recognize(input, );
for (RecognitionResult item : result)
{
    System.out.println("Text: "+item.recognitionText);
}

Java: Layout detecton

Tue, 15 Apr 2025 00:00:00 +0000

Aspose.OCR for Java can automatically analyze image content and identify the different types of layout blocks within it.

This functionality supports PDF, GIF, PNG, JPEG, BMP, or single-page TIFF from files, streams, and can bulk process folders and archives.

Pass one or more images as com.aspose.ocr.OcrInput object to com.aspose.ocr.DetectDocumentLayout method and get the layout blocks as com.aspose.ocr.models.LayoutOutput object.

`com.aspose.ocr.models.LayoutOutput`

This class stores a layout block detected in an image.

Property	Type	Description
`source`	`String`	The full path to the file or URL, if applicable. Empty for images provided as a stream, byte array, or Base64.
`page`	`Integer`	Page number for multi-page images.
`paragraphs`	`ArrayList<com.aspose.ocr.models.ContentArea>`	Detected paragraphs.
`images`	`ArrayList<com.aspose.ocr.models.ContentArea>`	Detected illustrations.
`headers`	`ArrayList<com.aspose.ocr.models.ContentArea>`	Detected headers.
`tables`	`ArrayList<com.aspose.ocr.models.ContentArea>`	Detected tables.
`lists`	`ArrayList<com.aspose.ocr.models.ContentArea>`	Detected lists.
`captions`	`ArrayList<com.aspose.ocr.models.ContentArea>`	Detected captions.
`equations`	`ArrayList<com.aspose.ocr.models.ContentArea>`	Detected equations.

`com.aspose.ocr.models.ContentArea`

This class stores a layout block detected in an image.

Property	Type	Description
`index`	`Integer`	The sequential index of the content area, unique within the entire image.
`image`	`BufferedImage`	Image region with the content.
`rectangle`	`java.awt.Rectangle`	The bounding rectangle of the content area.

Example

The following code demonstrates how to find and recognize tables in an image

AsposeOCR recognitionEngine = new AsposeOCR();
// Add an image to OcrInput object
OcrInput input = new OcrInput(com.aspose.ocr.InputType.SingleImage);
input.add("source.png");
// Detect layout
com.aspose.ocr.models.LayoutOutput layout = recognitionEngine.DetectDocumentLayout(input).get(0);
ArrayList<com.aspose.ocr.models.ContentArea> tables = layout.tables;
// Recognize tables
com.aspose.ocr.OcrInput tableAreas = new OcrInput(com.aspose.ocr.InputType.SingleImage);
for(com.aspose.ocr.models.ContentArea table : tables)
{
    tableAreas.add(table.image);
}

com.aspose.ocr.OcrOutput recognResult = api.Recognize(tableAreas);

Java: Recognition settings

Fri, 14 Jul 2023 00:00:00 +0000

Aspose.OCR for Java provides good recognition accuracy and performance by default. However, there will inevitably be cases where the default settings cannot provide reliable recognition results.

To configure Aspose.OCR recognition settings, specify an optional parameter for the recognition method. The parameter type depends on the recognition method.

Parameter type	Applicable to
`RecognitionSettings`	Extracting text from images, scanned PDFs, DjVu files and other content provided as `OcrInput` object.
`ReceiptRecognitionSettings`	Extracting text from receipts.
`IDCardRecognitionSettings`	Extracting text from ID cards.
`PassportRecognitionSettings`	Extracting text from passports.
`CarPlateRecognitionSettings`	Extracting text from vehicle license plates.
`InvoiceRecognitionSettings`	Extracting text from invoices.

Java: Document areas detection

Wed, 13 Nov 2024 00:00:00 +0000

A scanned image or photograph of a text document may contain a large number of blocks of various content - text paragraphs, tables, illustrations, formulas, and the like. Detecting, ordering, and classifying areas of interest on a page is the cornerstone of successful and accurate OCR. This process is called document areas detection.

Aspose.OCR offers several document areas detection algorithms, allowing you to choose the one that works best for your specific content.

Area detection modes

You can manually override the default document areas detection method if you are unhappy with the results or get unwanted artifacts.

Document structure analysis algorithm is specified using setDetectAreasMode method of recognition settings.

// Create instance of OCR API
AsposeOCR api = new AsposeOCR();
// Enable automatic document areas detection
RecognitionSettings recognitionSettings = new RecognitionSettings();
recognitionSettings.setDetectAreasMode(DetectAreasMode.UNIVERSAL);
// Prepare batch
OcrInput images = new OcrInput(InputType.SingleImage);
images.add("image.png");
// Recognize images
ArrayList<RecognitionResult> results = api.Recognize(images, recognitionSettings);
System.out.println("Recognition result:\n" + results[0].recognitionText + "\n\n");

Aspose.OCR for Java supports the following document structure analysis methods provided in DetectAreasMode enumeration:

Name	Description	Use cases
`DetectAreasMode.UNIVERSAL`	Finds small text blocks inside complex images. See DetectAreasMode.UNIVERSAL for additional details.	Driver’s licenses Social security cards Government and work IDs Visas Photos Screenshots Advertisements Street photos
`DetectAreasMode.MULTICOLUMN`	Detects large blocks of text formatted in columns. Optimal for multi-column documents with illustrations. See DetectAreasMode.MULTICOLUMN for additional details.	Contracts Books Articles Newspapers High-quality scans
`DetectAreasMode.TABLE`	Detects cells in tabular structures. See DetectAreasMode.TABLE for additional details.	Tables Invoices
`DetectAreasMode.CURVED_TEXT`	Auto-straightens curved lines and finds text blocks inside the resulting image. See DetectAreasMode.CURVED_TEXT for additional details.	Photos of books, magazine articles, and other curved pages.
`DetectAreasMode.NONE`	Prioritizes speed and reduces resource consumption by omitting support for complex layouts.	Simple images containing a few lines of text without illustrations or formatting. Applications requiring maximum recognition speed Web applications

Java: Table recognition

Wed, 19 Nov 2025 00:00:00 +0000

Aspose.OCR for Java now provides a dedicated API for detecting table layout and recognizing table data in images, scanned documents, screenshots, or photos. To extract table text, simply call the universal com.aspose.ocr.AsposeOCR.Recognize method with DetectAreasMode.TABLE settings.

This method accepts an OcrInput object and optional recognition settings.

Recognition results are returned as a list of com.aspose.ocr.AsposeOCR.RecognitionResult objects. Each result contains extracted table data, detected regions, and allows exporting to various formats. Additionally, you can retrieve the table’s row and column structure using the GetTableData() method.

DetectAreasMode.TABLE and GetTableData

The following code example shows how to extract text from table and get rows and columns structure:

com.aspose.ocr.AsposeOCR recognitionEngine = new com.aspose.ocr.AsposeOCR();
// Add images to OcrInput object
com.aspose.ocr.OcrInput input = new com.aspose.ocr.OcrInput(InputType.SingleImage);
input.add("source1.png");
input.add("source2.jpg");
// Configure recognition settings for tables
com.aspose.ocr.RecognitionSettings settings = new com.aspose.ocr.RecognitionSettings();
settings.setDetectAreasMode(DetectAreasMode.TABLE);
// Recognize tables on the image
com.aspose.ocr.OcrOutput results = recognitionEngine.Recognize(input, recognitionSettings);
ArrayList<com.aspose.ocr.models.OCRTablePage> allTables = results.GetTableData();
com.aspose.ocr.models.OCRTablePage tablePage = allTables.get(0);

results.forEach((result) -> {
	System.out.println(result.recognition_text);
});


// Print recognized table data in rows and cols
for(OCRTable table : tablePage.getTables()) {
    System.out.println("table index: "+table.getTableIndex());
    for(OCRTableRow row : table.getRows()) {
        System.out.println("row index: "+row.getRowIndex());
        for(OCRTableCell cell : row.getCells()) {
            System.out.print("cell index: "+cell.getColumnIndex()+": ");
            System.out.println(cell.getText());
        }
    }
}

Java: Formula recognition

Wed, 19 Nov 2025 00:00:00 +0000

Aspose.OCR for Java now provides a dedicated API for detecting and recognizing mathematical formulas in images, scanned documents, screenshots, or photos. To extract formula text, simply call the universal aspose.ocr.com.AsposeOCR.RecognizeFormula method.

This method accepts an OcrInput object and optional recognition settings. Internally, formula detection uses the DetectAreasMode.FORMULA mode to locate mathematical expressions before recognition.

Recognition results are returned as a list of aspose.ocr.com.RecognitionResult objects. Each result contains extracted formula text, detected regions, and allows exporting to various formats.

DetectAreasMode.FORMULA

The following code example shows how to extract text from table and get rows and columns structure:

com.aspose.ocr.AsposeOCR recognitionEngine = new com.aspose.ocr.AsposeOCR();
// Add images to OcrInput object
com.aspose.ocr.OcrInput input = new com.aspose.ocr.OcrInput(InputType.SingleImage);
input.add("source1.png");
input.add("source2.jpg");
// Configure recognition settings for formulas
com.aspose.ocr.RecognitionSettings settings = new com.aspose.ocr.RecognitionSettings();
settings.setDetectAreasMode(DetectAreasMode.FORMULA);
// Recognize formulas on the image
com.aspose.ocr.OcrOutput results = recognitionEngine.Recognize(input, recognitionSettings);

results.forEach((result) -> {
	System.out.println(result.recognition_text);
});

RecognizeFormula(OcrInput images, bool detectAreas = true)

com.aspose.ocr.AsposeOCR recognitionEngine = new com.aspose.ocr.AsposeOCR();
// Add images to OcrInput object
com.aspose.ocr.OcrInput input = new com.aspose.ocr.OcrInput(InputType.SingleImage);
input.add("source1.png");
input.add("source2.jpg");

// Recognize formulas with areas detection
com.aspose.ocr.OcrOutput results = recognitionEngine.RecognizeFormula(input, true);
// Parameter bool detectAreas - if set to true, automatically detects and isolates formula regions before performing recognition. If false, processes the entire image as a formula.

results.forEach((result) -> {
	System.out.println(result.recognition_text);
});

Live demo

recognitionEngine.RecognizeFormula(input, true)

x_{c} ( t )=\\sin\ ( 2 \\pi( 1 0 0 ) t \ )
T=1 / 4 0 0
x [ n ]
x [ n ]
x [ n ]=\\cos\ ( {\\frac{\\pi} {4}} n \ ) \\qquad-\\infty< n < \\infty.

Live demo

recognitionEngine.RecognizeFormula(input, false)

x [ n ]=\\cos\ ( {\\frac{\\pi} {4}} n \ ) . \\qquad-\\infty< n < \\infty.

Java: Recognition

Wed, 13 Nov 2024 00:00:00 +0000

Reading text from any content in Aspose.OCR for Java is as easy as calling a universal Recognize method.

This method takes OcrInput object and optional recognition settings.

Recognition results are returned as a list of RecognitionResult objects, that allow you to perform advanced manipulations with recognition results: automatically correct spelling, get image regions and save results in various formats.

Example

The following code example shows how to extract text from multiple images:

AsposeOCR api = new AsposeOCR();
// Add images to the recognition batch
OcrInput images  = new OcrInput(InputType.SingleImage);
images.add("image1.png");
images.add("image2.png");
// Recognition settings
RecognitionSettings recognitionSettings = new RecognitionSettings();
recognitionSettings.setLanguage(Language.Ukr);
// Recognize images
ArrayList<RecognitionResult> results = api.Recognize(images, recognitionSettings);
results.forEach((result) -> {
	System.out.println(result.recognition_text);
});

Java: Defect detection

Fri, 07 Jun 2024 00:00:00 +0000

Image defects can significantly impact the accuracy of OCR. They can be caused by the quality of the image acquisition process, environmental conditions, and the hardware used to capture the image. To improve recognition accuracy, it is essential to preprocess and enhance images to mitigate these defects whenever possible.

Aspose.OCR for Java can automatically find potentially problematic areas of image and return the information on the type of defect and its coordinates. The following types of defects can be found:

Defect	Enumeration	Description	Impact	How to mitigate
Salt-and-pepper noise	`DefectType.SALT_PEPPER_NOISE`	Appears as random white and black pixels scattered across the area. Often occurs in digital photographs.	Some characters are misidentified Unnecessary dots or commas appear in recognition results	Apply median filter Use automatic noise removal
Low contrast between text and background	`DefectType.LOW_CONTRAST`	Highlights and shadows typically appear on curved pages.	Low recognition accuracy Text not recognized (ignored by OCR engine)	Automatically adjust contrast Convert to grayscale Binarize with high threshold
Blur	`DefectType.BLUR`	The entire image or some of its areas are out of focus. Important: This detection algorithm can only identify the entire image as blurry. Specific areas cannot be detected.	Characters are not recognized correctly Text not recognized (ignored by OCR engine)	Use automatic contrast correction Convert image to grayscale
Glare	`DefectType.GLARE`	Highlight areas in an image caused by uneven lighting, such as spot lights or flash.	Low recognition accuracy Text not recognized (ignored by OCR engine)	Automatically adjust contrast Convert to grayscale Binarize with high threshold
All supported defects	`DefectType.ALL`	All above-mentioned defects.	See the corresponding defect for details.	See the corresponding defect for details.

You can highlight problem areas when previewing an image and even OCR them using alternative recognition settings to get a better result.

Detecting defects

To find defects on images, provide the collection of images and specify the type of defect to DetectDefects() method.

The method returns DefectOutput object with the following properties:

Property	Type	Description
`Source`	`string`	Image path.
`Page`	`int`	Page number of multi-page images.
`defectAreas`	`List<DefectAreas>`	The list of defects and areas of an image where they were found.

// Initialize Aspose.OCR recognition API
AsposeOCR api = new AsposeOCR();
// Add image to the recognition batch
OcrInput source = new OcrInput(InputType.SingleImage);
source.add("image.png");
// Find shadows and highlights
ArrayList<DefectOutput> defects =  api.DetectDefects(input, DefectType.LOW_CONTRAST);
for(DefectOutput d : result) {
	for (DefectAreas ar : d.defectAreas) {
		System.out.println(ar.defectType);
		for (Rectangle r : ar.rectangles) {
			System.out.println(r.x + " " + r.y + " " + r.width + " " + r.height);
		}
	}
}

Live demo

Java: Specialized recognition methods

Wed, 18 Oct 2023 00:00:00 +0000

Aspose.OCR for Java offers fine-tuned OCR methods for extracting text from certain types of images:

Extracting text from ID cards
Automatically read text from scanned or photographed ID cards.
Extracting text from passports
Digitize scans or photos of passports.
Extracting text from vehicle license plates
Reading vehicle license plates without manual retyping.
Extracting text from invoices
Digitizing scanned invoices without manual retyping.
Extracting text from receipts
Digitizing scanned receipts without manual retyping.
Extracting text from street photos
Extracting text from street photos, price tags, menus, catalogs and other images with sparse text and noisy/colored backgrounds.

Java: Performance optimization

Fri, 14 Jul 2023 00:00:00 +0000

Aspose.OCR for Java allows for very flexible balancing of recognition speed, quality, and resource usage for each use case:

Fast recognition for simple and clear images, such as high-quality scans. About twice as fast as regular recognition.
Limiting the number of threads used by the recognition engine.
Fine-tuning image preprocessing filters.
Customizing recognition accuracy, performance, and other settings.

Java: Comparing text in images

Fri, 14 Jul 2023 00:00:00 +0000

Aspose.OCR for Java can compare texts on two images, regardless of the font, text size, case, styles, and colors.

To simply find out if two images contain the same text, use the CompareImageTexts method of the AsposeOcr class. To find the degree of similarity between texts in images, use the ImageTextDiff method of the AsposeOcr class. These methods allow you to further fine-tune recognition accuracy, performance, and other settings.

You can perform case-sensitive or case-insensitive comparison. Set the ignoreCase parameter to true to perform a case-insensitive comparison.

ImageTextDiff returns a number representing how similar the compared images are. The return value is a floating point number from 0 to 1; the lower the number, the more different image texts are. 0 means that the texts are completely different; 1 means the texts are identical. Fonts and styles are ignored. The difference between image texts is calculated as the Levenshtein distance. Simply put, it is the minimum number of changes required to transform one string into another by inserting, deleting or replacing a single character.

AsposeOCR api = new AsposeOCR();
// case-insensitive comparison of image texts
if(!api.CompareImageTexts("image1.png", "image2.png"))
{
	System.out.println("Images contain the same text");
}
// percentage of similarity between texts
else
{
	float distance = api.ImageTextDiff("image1.png", "image2.png");
	System.out.println("The image texts are " + (distance*100) + "% similar");
}

Java: Finding text in an image

Fri, 14 Jul 2023 00:00:00 +0000

Aspose.OCR for Java makes searching for text in images as easy as finding the text fragment in a string. In a single line of code, you can search for a case-sensitive or case-insensitive string, and even validate an image text against a pattern.

To search for a text in an image, use ImageHasText method of AsposeOcr class. The method either takes a text fragment or a regular expression and returns true if the text is found or false if not.

ImageHasText method allows you to optionally customize recognition accuracy, performance, and other settings.

AsposeOCR api = new AsposeOCR();
if(!api.ImageHasText("image.png", "Aspose"))
{
	System.out.println("The image contains the word \"Aspose\"");
}
else
{
	System.out.println("The image doesn't contain the word \"Aspose\"");
}

Java: Working with image regions

Mon, 17 Jul 2023 00:00:00 +0000

Aspose.OCR allows you to find and read only certain areas of an image, not all text. This is very useful for batch processing uniform documents such as ID cards, visas, driver’s licenses, customs declarations, applications, and so on.

Java: Spell checker

Fri, 30 Sep 2022 00:00:00 +0000

Although Aspose.OCR for Java provides high recognition accuracy, printing defects, dirt, or non-standard fonts may cause certain characters or words to be recognized incorrectly. To further improve recognition results, you can turn on spell checker, which finds and automatically corrects spelling errors.

Java: Saving recognition results

Mon, 17 Jul 2023 00:00:00 +0000

Aspose.OCR for Java can save recognition results in multiple formats so they can be shared, stored in a database, displayed, or analyzed:

Java: Logging recognition events

Thu, 26 Jan 2023 00:00:00 +0000

Aspose.OCR for Java can show recognition progress in the console or log it to a file. The logging is activated and configured with a static Logging class. You can use the following properties to activate logging and specify its parameters:

Property	Type	Description
`Logging.console`	`bool`	Set to `true` to enable the display of recognition progress in the console.
`Logging.fileSystem`	`bool`	Set to `true` to write recognition progress to a file specified in `Logging.logFilePath` property.
`Logging.logFilePath`	`string`	Specify an absolute or relative path to the log file. Applicable only when the `Logging.fileSystem` property is set to `true`.
`Logging.loggingLevel`	`LoggingLevel`	Specify the log severity. See Log severity levels for details.

Enable logging

Logging.loggingLevel = LoggingLevel.Debug;
Logging.fileSystem = true;
Logging.console = true;
Logging.logFilePath = "recognition.log";

Result

Open file. Started. 11.01.2023 12:32:58
Open file. Ended. 11.01.2023 12:32:59
Read image data. Started. 11.01.2023 12:32:59
Read image data. Ended. 11.01.2023 12:32:59
Preprocess file. Started. 11.01.2023 12:32:59
Preprocess file. Ended. 11.01.2023 12:33:00
Recognition process. Started. 11.01.2023 12:33:01
Region detection. Started. 11.01.2023 12:33:01
Region detection. Ended. 11.01.2023 12:33:10
Recognize characters. Started. 11.01.2023 12:33:10
Recognize characters. Ended. 11.01.2023 12:33:11
Recognition process. Ended. 11.01.2023 12:33:11

Log severity levels

You can configure the log severity by specifying one of the following values in Logging.loggingLevel property:

Severity	Value	Description
`LoggingLevel.Error`	2	Error events of considerable importance that will affect normal program execution.
`LoggingLevel.Warning`	1	Potentially harmful situations that might still allow the application to continue running.
`LoggingLevel.Debug`	0	Detailed trace messages useful for application developers.
`LoggingLevel.None`	3	No logging. Works the same as turning off logging with `Logging.console` and `Logging.fileSystem` parameters.

Java: Debug mode - Save processing results

Sun, 15 Jun 2025 00:00:00 +0000

Aspose.OCR for Java provides a Debug Mode that allows you to visually inspect how the input image is transformed during recognition.

When debug mode is enabled, the library saves intermediate processing results as image files:

The preprocessed image after filters (e.g., binarization, noise removal, resizing).
The image with highlighted text regions, where red rectangles mark detected text lines or blocks.

This feature is especially useful for troubleshooting recognition errors and fine-tuning preprocessing filters.

Property	Type	Description
`AsposeOCR.DebugMode`	`bool`	Enables or disables debug image saving.
`AsposeOCR.DebugModeSaveDirectory`	`String`	Sets the target folder where images will be saved. If not set, the current working directory is used.

Enabling debug mode

Debug mode is activated using two static properties of the AsposeOCR class:

Output examples

When enabled, you will see image files like:

Preprocessed0.png – image after applying preprocessing filters
DetectedTextLines0.png – the same image with red rectangles drawn around detected text areas

Each image corresponds to the input from OcrInput.addImage(…) or its index.

Notes

Debug images do not affect recognition accuracy.
This feature works with both automatic and manual preprocessing.
If a temporary license is used, debug mode still functions as expected.