Introducing ABBYY FlexiCapture Engine 12

No topics above this level

Introducing ABBYY FlexiCapture Engine 12

Welcome to ABBYY FlexiCapture Engine 12!

ABBYY FlexiCapture Engine 12 is a new release of ABBYY Data Capture SDK delivering new features and technology improvements.

ABBYY FlexiCapture Engine provides development tool for ISVs, OEM vendors and service providers interested in developing data capture solutions for processing documents with fixed forms and semi-structured documents with repetitive layouts. . It can also be used for creating customized data capture applications for various scanning devices and terminals.

Key features

·Supports Data Capture for All Types of Documents

·Automated Document Separation and Classification

·Multi-Core Processing

·Visual Tools for Creating Document Definitions Fast

·An Extensive Code Samples Library

·Optimized Performance in Multi-Threaded Server Applications

·Mobile Data Capture with Camera OCR Technology

·32- and 64-bit Support

·Improved PDF Export

·World’s Widest Language Base

·Creation Document Definitions by Training

Basic usage scenarios

·Fast Response Processing Service

·Embedded data capture solutions for terminals and kiosks

·Mobile data capture solutions

How to use this Help

In this Developer's Help you can find all necessary information about ABBYY FlexiCapture Engine 12.

Guided Tour

See the Guided Tour section to learn about how to use FlexiCapture Engine:

·Tutorial

Basic information about usage of FlexiCapture Engine.

·Advanced Techniques

Advanced information on various programming aspects and solving specific development tasks.

·Best Practices

Offers you some advice on how to prepare images for recognition.

·Samples

Short description of available samples. A detailed description of the samples you can find in the Code Samples Library provided with this distribution pack.

FlexiCapture Engine API Reference

The complete reference of the FlexiCapture Engine API.

Licensing

Important information about ABBYY FlexiCapture Engine licenses and activation.

Distribution

Information about distribution of applications which use the ABBYY FlexiCapture Engine library.

Specifications

The list of supported image formats, predefined languages, text types, barcode types, export formats, system requirements and backward compatibility issues.

Frequently Asked Questions

The extracts of the most important information.

Contact ABBYY

Here you can find the contacts of ABBYY offices and Technical support service.

Visit our website at www.abbyy.com for the most up-to-date information about ABBYY FlexiCapture Engine.


Basic Usage Scenarios Overview

Introduction >

Basic Usage Scenarios Overview

This section describes the most common scenarios in which ABBYY FlexiCapture Engine may be used.

Usage scenario

Details

Fast Response Processing Service

Offering advanced fast-response high-volume data capture services, which can easily streamline the process and deliver critical throughput efficiencies, e.g.:

·Market research forms processing

·Insurance claims

·Questionnaires and surveys

·Product registration forms

·Tax and legal forms

·Healthcare check-up forms processing

·Census forms processing

Embedded data capture solutions for terminals and kiosks

Adding data capture functionality embedded into terminals and kiosks such as:

·Utility bills processing

·Tickets refund

·Gaming and lottery ticket processing

·Election forms processing

Mobile data capture solutions

Mobile data capture scenario is advanced and high-performanced data capture technology to extract and recognize data at the server side. The image quality can be improved by applying image prepocessing tools.

Below is the list of the most obvious usage scenarios:

·Mobile data capture to enhance current service

Gain additional market share by extending your services to the mobile phone and provide more relevant value.

·Mobile data capture as a workgroup tool

Streamline remote processing of information via mobile phones. Get rid of the expensive dedicated devices for Inventory Management, Order processing, etc.

·Mobile data capture as a marketing tool

Use free mobile apps to create a new mobile channel of communication and services with your customers.

ABBYY can provide unique combination of know-hows, experience and proved track records in both mobile and data capture technologies.

See also

Key Features


Key Features

Introduction >

Key Features

Supports Data Capture for All Types of Documents | ABBYY FlexiCapture Engine 12 provides tools for extracting data from documents that have no fixed layout including invoices, contracts and letters. All required data fields can be quickly located and extracted in an appropriate format.
Automated Document Separation | FlexiCapture Engine can be used to separate documents, and to identify document types. Plus, it can assemble one- and multi-page documents out of a mix of pages, enabling automatic classification of documents with variable layouts – and of any complexity.
Multi-Core Processing | A pool of processors can be employed to make full use of a computer's CPU power.
Visual Tools for Creating Document Definitions Fast | FlexiCapture Engine features visual development tools that enable you to develop, test and maintain highly accurate data capture solutions for specific document types – without having to write a single line of code.
An Extensive Code Samples Library | A comprehensive set of code samples explain how to program using the SDK. Each library section has code snippets accompanied by step-by-step instructions on how to perform the relevant task.
Optimized Performance in Multi-Threaded Server Applications | Using FlexiCapture Engine in multiple processes enables you to create a pool of objects that work simultaneously and utilize the full power of a server’s CPU.
Mobile Data Capture with Camera OCR Technology | Provides enterprises and ISVs a platform for fast development of data capture applications with mobile front ends.
32- and 64-bit Support | FlexiCapture Engine can be used in 64-bit processes.
World’s Widest Language Base | Supporting 207 OCR and 112 ICR languages, FlexiCapture Engine simplifies localized application development – enabling developers to meet global customers’ needs more easily.
Improved PDF Export | Save memory space, easily post PDF documents on the Web and e-mail them with ABBYY’s new MRC compression technology.
Creation Document Definitions by Training | Extract data-fields from structured and semi-structured documents that do not contain tables and repeating groups, by creation of simple Document Definitions.

Full functionality

· Document Scanning and Image Import

·Image Preprocessing

·Document Analysis

·Recognition

·Verification

·Export

·Advanced Development Tools

·Code Samples Library


Document Scanning and Image Import

Introduction > Key Features >

Document Scanning and Image Import

ABBYY FlexiCapture Engine can receive images from three types of sources: document scanning, opening from files, or directly from memory.

Document Scanning

·Via TWAIN UI (including ADF support and manual input feeding)

·Setting up scanning setting directly using ABBYY FlexiCapture Engine API

·Asynchronous scanning mode (the images received from scanner can be processed while the new ones are scanning)

ABBYY FlexiCapture Engine 12 enables flexible management of scanning parameters, such as: brightness, colority, resolution, image size, duplex scanning, pause between pages setup and more.

See also Scanning.

Image file formats

The Data Capture SDK supports the majority of image formats, including multi-page TIFF and JPEG 2000 (part1), and works with black-and-white, grayscale and color images. It also opens PDF files by converting them into images with Adobe® PDF Library Technology.

·BMP

·DCX

·DjVu

·GIF

·JBIG2

·JPEG

·JPEG 2000

·PCX

·PNG

·PDF

·TIFF and multi-page TIFF

See more in Supported Image Formats.

Working with source image as a stream in memory

Images can be loaded into memory and preprocessed using either FlexiCapture Engine methods or third party software. The preprocessed image pages are then passed to the FlexiCapture processor for recognition directly from memory, without creating temporary files.

For more details see Setting Up a Custom Image Source.

See also

Key Features


Image Preprocessing

Introduction > Key Features >

Image Preprocessing

Upon receiving images, ABBYY FlexiCapture Engine performs a range of image preprocessing operations to improve the quality of document images for further recognition or archiving.

Automated image de-skewing | It is an essential document imaging function which is applied to scanned documents requiring the compensation for image skew. It does not require leading edge borders or lines. ABBYY FlexiCapture Engine provides several methods for de-skewing images: with pairs of black squares, lines or lines of text.
Image despeckling (or image clean-up) | When scanning poor to medium quality documents, you may get very noisy images with lots of dots or speckles on them. These speckles, when they appear close to the letters or numbers, may affect the quality of OCR. This feature removes such noise. The size of the speckles to be removed may be specified by the user. Can be applied to an image as well as to any individual block (or zone) of the image.
Mirroring and inverting | There is an option to mirror the prepared image around its vertical axis. Also it is possible to invert colors of the prepared image.
Color filtering | Intelligent background filtering and stamp removal are particularly helpful for extracting data from documents printed on color or textured backgrounds.

See also

Key Features


Document Analysis in Data Capture

Introduction > Key Features >

Document Analysis in Data Capture

Document analysis refers to the methods of automatically identifying components of a document. An important feature of the data capture scenario is that only certain fields are recognized. ABBYY FlexiCapture Engine imitates the way humans recognize objects. In order to detect the required data human operator is looking for the special fields on the document. He founds the field and analyzes areas around it. Our product does the same. It finds the required fields on flexible forms by using a special formalized description, called FlexiLayout™ – that created with a special visual tool – ABBYY FlexiLayout Studio. Then the program analyzes the area surrounding each element and make inferences about the nature of the fields and their content. The system can find fields else-where, using any information available: relation to other objects on the page, contents of the field, its size, lines drawn around, etc.

Developing with ABBYY FlexiCapture Engine usually is done in 2 steps:

1.You should analyze the nature of documents to be used for data extraction and create proper Document Definitions that can be based on either Fixed Form Definitions or FlexiLayouts.

2.After that you can integrate the Engine into your application.

ABBYY FlexiCapture Engine can create simple Document Definitions by training without using special tools like ABBYY FlexiLayout Studio or Document Definition Editor. However, comprehensive Document Definitions still should be created using these tools, see details below.

Development of Document Definitions for fixed forms

The Document Definition Editor (a part of ABBYY FlexiCapture 12) allows fast and intuitive development of Document Definitions to process static, fixed forms.

1.Load the different segments of the multipage form to the editor.

2.Define the elements that are used to match the document: anchors, static texts and separators.

3.Define the different recognition areas in a graphical editor where, e.g. text blocks, tables, checkmarks, checkmark groups, barcodes and pictures are located.

4.Set up the recognition properties, for each area, e.g OCR, ICR and attach data type definitions, dictionaries and verification rules.

The detailed instructions for creating fixed layouts you can find in ABBYY FlexiCapture 12 Help.

Development of Document Definitions for flexible documents

ABBYY FlexiLayout Studio user interface is designed to simplify FlexiLayout creation by directing the developer through a set of dialog boxes. In complicated cases requiring more detailed customization and assistance, FlexiCapture Studio provides direct access to its internal structural language for greater flexibility and more control. (ABBYY FlexiLayout Studio is supplied together with ABBYY FlexiCapture 12.)

1.Load a selection of documents with different layouts.

2.Define some generic elements that allow identifying documents and that can be used for orientation within one document, e.g. text strings, lines, spaces between elements.

3.Define search elements for the data you are looking for e.g. text, numbers, date, tables, the length of the sting, the set of characters, one or multiple words, one or multiple lines.

Additionally these elements are set into a relation with other areas set up in 2, for example right or below.

The detailed instructions for creating FlexiLayouts you can find in ABBYY FlexiCapture 12 Help.

Creating Document Definitions on-the-fly

In ABBYY FlexiCapture Engine 12 developers can create Document Definitions on-the-fly using methods provided by ABBYY FlexiCapture Engine.

See also

Key Features


Recognition

Introduction > Key Features >

Recognition

Optical Character Recognition (OCR)

·OCR technology for more than 195 languages. See the full list of supported languages.

·41 languages have dictionary/morphology support.

·Recognition of multilingual documents.

·Recognition of dot-matrix documents — ABBYY FlexiCapture Engine recognizes printed dot matrix texts of many types. It has been trained using several thousand samples produced by a variety of printers including dot matrix, daisy wheel, chain and band printers, as well as using draft and Near Letter Quality (NLQ) printing modes.

·Recognition of typewritten documents.

·Chinese, Japanese, and Korean (CJK) character recognition.

·Thai, Vietnamese and Hebrew OCR.

·Recognition of OCR-A, OCR-B, MICR (E13B) and CMC7.

Intelligent Character Recognition (ICR)

·ICR technology for more than 110 languages.

·About 30 languages (with Latin, Greek and Cyrillic alphabets) with morphology and dictionary support and 85 languages with Latin characters without dictionaries.

·ICR for Indian digits used in Arab states.

·22 regional styles of hand-printing used in different countries and regions of the world (for supported ICR languages).

·Recognition of hand-printed characters in fields and frames – underlined fields, boxes, comb-style fields, etc.

·Multilingual ICR. One of the main advantages of ABBYY ICR technology is that it delivers almost the same high accuracy on digits and digits combined with letters of one or several languages, even if the fields contain both upper and lower case letters.

Optical Mark Recognition (OMR)

The ABBYY’s OMR technology recognizes simple checkmarks, grouped checkmarks, model checkmarks and checkmarks with “corrections” made by hand in different variations:

·checkmarks in square frame

·checkmarks against the empty background

·non-standard checkmark types

OMR delivers accuracy rate of 99.995 %.

Optical Barcode Recognition (OBR)

·1D and 2D barcode types. ABBYY Data Capture SDK supports recognition of popular types of 1D and 2D barcodes. See the full list of supported barcodes.

·Smart barcode extraction. This feature enables automated detection and recognition of barcodes at any angle on a document. It works both for 1D and 2D barcodes.

See also

Key Features


Verification

Introduction > Key Features >

Verification

Data verification is performed by comparing recognition results with the image of any document part. When the program is not absolutely certain about the accuracy of recognition of a certain characters, it marks them as recognized "unreliably." The purpose of the verification process is to verify such characters and correct any errors if necessary.

ABBYY FlexiCapture Engine offers effective and convenient instruments for checking the validity of captured data and tracking recognition errors:

Rules-based verification

Recognized data can automatically be checked if needed. This covers simple range checking, comparison with a known value (e.g. supplied as a regular expression or taken from a database), and comparison of data items within one document. Finally, scripts can be used to create very sophisticated checking rules.

Rules could be easily managed with a separate tool – ABBYY FlexiCapture product that is supplied with ABBYY FlexiCapture Engine to set up Document Definitions. This makes solution maintenance at production stage easier since only Document Definition have to be changed, without touching any line of the code.

Nevertheless if developers prefer the rules to be managed via code this is easily configurable using the product API.

Group verification

Group verification is a verification mode whereby identically recognized characters are submitted for verification in groups. Group verification involves grouping character images recognized as having identical values and displaying them in a verifier screen, enabling the operator to easily identify and correct characters that deviate from the group.

Context verification

Context verification is a verification mode intended for effective correction of errors of "well-recognized" fields, i.e. fields whose range of values is known or can be easily identified. An example of such a field is a field containing a country or city name.

See also

Verifying Recognized Data

Key Features


Export

Introduction > Key Features >

Export

ABBYY FlexiCapture Engine allows you to save all relevant data into backend applications and converts analyzed documents into searchable PDF or PDF/A for archiving purposes. Data capture technologies export data to structured formats (XML, CSV) or other storage location. Sometimes the images of the original documents are also saved.

With ABBYY FlexiCapture Engine developers can benefit from the following enhanced export capabilities:

Redaction

Redaction means preserving confidential or sensitive data. Developers can:

·redact certain fields on the image before export

·for each export destination specify different set of fields for redaction

It is possible to set up Document Definitions in ABBYY FlexiCapture in a way to change the look of images for each export destination by redacting certain fields on the image.

PDF (PDF/A) MRC compression

A special compression technology called MRC (Mixed Raster Content) is used to minimize the size of PDF and PDF/A files.

Document image files are usually very large due to the background, which is often makes up to 90% of the file size. The background may, however, be unnecessary in the resulting document. It is the text and pictures that are important.

The MRC compression technology allows locating the color background and deleting it or compressing to a high degree. This leaves text and pictures against a white background contributing to smaller file size.

Picture objects (diagrams, graphs, logos, photos, drawings, stamps, signatures, etc.) are also slightly compressed, but only to an extent that doesn’t lower the quality.

The MRC technology analyzes the outlines of similar characters in the document, creates an average character template and uses it instead of a character itself. This leads to better readability, because some of the text defects are corrected, and the character outlines become more precise.

As a result, you get a smaller image which looks even better than before. The resulting document will have an unobtrusive bland background with fine text and pictures.

This “reconstruction” of the document can be useful when you have to deal with low quality images due to: bad lighting, out-of-focus photo, incorrect scanning/photo parameters, dark uncoated paper, or document dilapidation.

All this results in the image having a dark background with additional textures. The text appears blurred and difficult to read.

The MRC technology allows for better document appearance and up to 8-10 smaller file size than JPEG.

Enhanced options for export files naming

Name the resulting files according to your business needs. When setting up Document Definitions You can add as much parameters and index field values to their export files naming scheme as you need. It can be done either when setting up Document Definitions in ABBYY FlexiCapture, or via FlexiCapture Engine API. New options provide more flexibility and an extensive choice of tags.

See also

Key Features


Advanced Development Tools

Introduction > Key Features >

Advanced Development Tools

Direct Access to FlexiCapture Technology

ABBYY FlexiCapture Engine 12 includes FlexiCapture Processor – which provides direct access to FlexiCapture technology. This low-level API supplements the existing high-level tools for working with the Object Model of the FlexiCapture product.

Developer can organize his own storage of source data (i.e. images), processing settings (templates, image preprocessing parameters), and interim data (documents in FlexiCapture format) in the end-user application.

FlexiCapture Processor Highlights

Custom Image Source Results in increased flexibility, security and performance | It is possible to implement your own external image queue (custom image source), which will either return references to files on demand or provide the source images as a stream in memory.
Access to a remote storage location Ability of configuring processing environment on-the-fly | By default, string references to templates, images, etc. are interpreted as references to files in the file system. However, it is possible to define a custom Reference Manager which will resolve references either as a path to a file in the local file system or as the binary representation of the requested object in the form of a stream in memory. This approach may be used to organize work with a remote storage location accessed using any protocol.

Three convenient ways to load Engine object

Get better performance when solving specific tasks:

For end-user interactive applications

Loading method

Where to use

Standard

Loading FCEngine.dll manually and working with “naked” interfaces (with no proxy use).

In simple single-threaded applications that does not require administrator privileges to install. This is important for applications which are installed on many computers.

E.g. local business card reader application

In-process server

The Engine is loaded as an in-process server into the same process.

COM infrastructure is responsible for making the calls thread-safe.

In scripts or simple multi-threaded applications focused mostly on simplicity and fail-safety, not performance.

E.g. in script for capturing data from images built in MS Word documents (calling FlexiCapture Engine from VBScript)

For server solutions

Loading method | Where to use
Out-of-process server The Engine is loaded as an out-of-process server into a separate process. | When creating server applications which are installed on a limited number of servers and which require administrator privileges to install and configure. E.g. a dedicated server for batch processing of millions of documents

See also

Key Features


Cloud Licensing

Introduction > Key Features >

Cloud Licensing

Starting with ABBYY FlexiCapture Engine 12, a new type of licenses is available which uses the cloud protection mechanism. Cloud Licenses are primarily intended for applications deployed to a cloud environment, but can also be used on workstations or virtual machines that are connected to the Internet. Cloud protection mechanism is supported both for Developer and Runtime Licenses.

A Cloud License does not bind to a specific host, which makes it much more convenient than licenses with software or hardware keys in cases when FlexiCapture Engine is used in a cloud or virtual environment. Instead of license activation, the Licensing Service installed locally (on the machine that uses the license) communicates with the ABBYY cloud licensing service over the Internet to allow license usage. License checks happen periodically while FlexiCapture Engine is running, so using a Cloud License requires active Internet connection.

A Cloud License does not limit concurrent usage: the same Cloud License can be used simultaneously by a number of cloud instances or Internet-enabled workstations. Cloud protection type limits only the total number of recognized pages, which is checked when performing license synchronization.

note Note: The local Licensing Service (one instance or workstation) can work with only one Cloud License simultaneously.

If the connection to the ABBYY cloud licensing service is lost, the local Licensing Service will be unable to synchronize and the license will be invalidated. However, this does not happen immediately: a certain autonomous run time is allowed after a failed synchronization. If the connection is restored during this time, the license will continue working without any impact to FlexiCapture Engine functionality. This reconnection timeout and the synchronization period are specific parameters of each Cloud License, and can be adjusted to your needs by sales (see the How to Buy section).

Cloud licensing requirements

Using a Cloud License requires:

·Active Internet connection.

·Allowed connections to *.abbyy.com on ports 80 and 443.

For the list of supported environments, see the System Requirements section.

Cloud License information

Cloud License parameters are contained in a password-protected file (license token file) which is used for authorization when connecting to ABBYY cloud licensing services.

When you order a Cloud License, you should receive the following information from sales:

·your Customer Project ID (a string of text),

·a license token file (a file named like SWRTXXXXXXXXXXXXXXXXXXXX.ABBYY.Cloud.ActivationToken), and

·a password to the license token file (another string of text).

The Customer Project ID is required at the time of developer installation and at the run-time. The token file and the password are required at the developer installation and at the run-time, whenever FlexiCapture Engine functions are used.

Developing cloud-licensed applications

The library is loaded with the help of the IEngineLoader::GetEngine method. It supports all license types, including the Cloud License, so that you will not need to rewrite your code when switching from one license type to another. The following information about your Cloud License is to be set with the properties of the IEngineLoader object:

·your Customer Project ID,

·the path to the license token file, and

·the license token password.

For full details, see the description of the Step 1: Load FlexiCapture Engine.


Code Samples Library

Introduction > Key Features >

Code Samples Library

FlexiCapture Engine has a comprehensive set of code samples that explain various particular aspect of programming with the FlexiCapture Engine. Each library section contains one or several code snippets escorted by a step-by-step description how to perform the task.

To open the Code Samples Library, click Start > Programs > ABBYY FlexiCapture Engine 12 > Code Samples Library.

How to…

Get started

You are new to ABBYY FlexiCapture Engine and are looking for a way to recognize a document and export recognition results.

Implement common processing scenarios

You are looking for some tips on implementing common processing scenarios, like customizing the source of images, navigating through a recognized document, or implementing storage of recognized data.

Use advanced techniques

You are an advanced user of ABBYY FlexiCapture Engine and are looking for a way to create and edit Document Definitions, preprocess images, or perform scanning.

Work with FlexiCapture Engine from scripting languages

You intend to use ABBYY FlexiCapture Engine from a script language.

Effectively use resources of a high-performance computer

You intend to create a multi-threaded server application with ABBYY FlexiCapture Engine inside.

Implement Web service

You intend to implement a data capture solution, which is provided as a Web service.

You can modify any code snippet and reuse it in your application.

Technological Advantages Demonstration

Also FlexiCapture Engine 12 includes Sample Applications that demonstrate our technological advantages:

Creating Document Definitions by Training

The ready-to-use tool for creation of simple FlexiLayouts or Document Definitions.

Image Preprocessing

ABBYY FlexiCapture Engine provides a wide variety of image preprocessing tools, which can help to improve recognition quality.

Multi-Core Processing

Built-in multi-processing makes your application scalable and efficient without any efforts from your side.

Mobile Data Capture

ABBYY FlexiCapture Engine provides high quality processing of photos taken with mobile device cameras.

Color Stamps Removal

ABBYY FlexiCapture Engine can remove all overlaid stamps and ink inscriptions from your documents before recognition.

Redaction

ABBYY FlexiCapture Engine allows you to obliterate sensitive information from an image.

Visual Components

ABBYY FlexiCapture Engine provides a set of visual controls, which allow you to construct the graphical user interface of your application with small efforts from your side.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

See also

Key Features


Short Specification

Introduction >

Short Specification

·OCR for 207 languages including:

oEuropean (Armenian, Cyrillic, Greek, Latin alphabets)

oAsian (Chinese, Japanese, Korean, Taiwanese, Vietnamese, Thai, Burmese)

oHebrew

oArabic

·ICR for more than 112 languages (Cyrillic, Greek, Latin alphabets)

·OMR

·Barcodes 1D (21 types) and 2D (PDF417, Aztec, DataMatrix, QR Code)

·Text font types (Matrix, MICR E13B, MICR CMC7, Index, Normal, OCR-A, OCR-B, Typewriter)

·Import formats

oScanning (API, TWAIN UI)

oImage files (BMP, DCX, DjVu, GIF, JBIG2, JPEG, JPEG 2000, PCX, PNG, TIFF)

oImages as a stream in memory

oPDF formats

·Export formats

oData output destinations

§Microsoft Office Excel Workbook (*.XLS)

§Comma Separated Values File (*.CSV)

§Simple text (*.TXT)

§XML Document (*.XML)

oImages output formats

§PDF (PDF/A, with MRC compression)

§BMP

§PCX, DCX

§JPEG (gray, color)

§JPEG 2000

§TIFF

§PNG (black and white, gray, color)

See also

Key Features


Getting Started

Introduction >

Getting Started

Start your work with the Tutorial section, which describes basic steps you need to perform to recognize documents and export results.

For solving sophisticated development tasks you may need some additional information, which you can find in the Advanced Techniques section. We also recommend that you refer to the Programming Aspects section, where some useful information on using ABBYY FlexiCapture Engine in different programming languages can be found.

You can view Sample code provided with the ABBYY FlexiCapture Engine developer package for quick start.


FlexiCapture Engine Guided Tour

No topics above this level

FlexiCapture Engine Guided Tour

This section contains articles which will help you in your work with the FlexiCapture Engine API:

·Tutorial

Describes basic steps you need to perform to recognize documents and export results.

·Advanced Techniques

Provides advanced information about working with ABBYY FlexiCapture Engine API, e.g. information on tuning export parameters, working with connectable objects.

·Best Practices

Offers you some advice on how to prepare images for recognition.

·Samples

Short description of available samples. A detailed description of the samples you can find in the Code Samples Library provided with this distribution pack.


Tutorial

Guided Tour >

Tutorial

This section provides basic information about working with the FlexiCapture Engine API. For advanced details, see the Advanced Techniques section.

ABBYY FlexiCapture Engine 12 can be configured for automated input of structured ("fixed") forms and semi-structured ("flexible") documents:

Structured forms

Definition: These are documents containing a set of marked information fields whose formatting, number, and layout do not change from one document to another. Such documents are also called fixed forms.

Example: Most questionnaires and application forms. Such forms are usually distributed as blank forms and are filled out by hand.

cicon2 Show example

FixedForm

How to extract data: You need to create a fixed layout that will tell the program where to look for the fields with the data to be extracted. Such forms are designed with the help of ABBYY FormDesigner 12 (supplied together with ABBYY FlexiCapture 12). Instructions for creating fixed layouts are available in ABBYY FlexiCapture 12 Help.

Semi-structured documents

Definition: These documents contain a set of information fields whose design, number, and layout may vary significantly from document to document. These documents are also called flexible documents.

Example: Bills, since they often vary both in terms of the number of items and their formatting due to the fact that they are received from different companies. All bills have a bill number and an amount due for payment, but are located in different places.

cicon2 Show example

FlexibleDocuments

How to extract data: You need to create a flexible layout (FlexiLayout) with the help of ABBYY FlexiLayout Studio (supplied together with ABBYY FlexiCapture 12). Instructions for creating flexible layouts are available in ABBYY FlexiCapture 12 Help. Simple FlexiLayouts can be created via API of FlexiCapture Engine.


Processing with a Customizable Processor Object

Guided Tour > Tutorial >

Processing with a Customizable Processor Object

FlexiCapture Engine 12 includes low-level API which provides direct access to FlexiCapture technology. You can organize your own storage of source data (i.e. images), processing settings (Document Definitions, image pre-processing parameters), and interim data (documents in FlexiCapture format) in the end-user application.

FlexiCaptureProcessor is a processor object which converts images into FlexiCapture documents. The processor is configured with FlexiCapture Document Definitions and processing parameters. The processor gets images as input, and outputs documents.

Documents created by the processor are not bound to any batch or storage location (as is the case when working with a FlexiCapture project), but exist as isolated objects in memory. The user can either immediately export a document to a destination format without saving it or organize its storage using the available means for reading and writing documents onto a disk or into a stream.

The processor allows you to set up an image source and a mechanism for accessing Document Definitions in order to support integration with any storage mechanism used by the user.

The basic steps you need to perform in order to recognize documents and export the results are as follows:

·Step 1: Load FlexiCapture Engine

·Step 2: Create FlexiCapture Processor

·Step 3: Add Document Definitions

·Step 4: Add Images

·Step 5: Recognize Documents

·Step 6: Export Results

·Step 7: Unload FlexiCapture Engine


Step 1: Load FlexiCapture Engine

Guided Tour > Tutorial > Processing with a Customizable Processor Object >

Step 1: Load FlexiCapture Engine

To start your work with ABBYY FlexiCapture Engine you need to create the Engine object. The Engine object is the top object in the hierarchy of the ABBYY FlexiCapture Engine objects and is the only ABBYY FlexiCapture Engine externally creatable object.

To load the Engine object do the following.

1.Create the EngineLoader object using the GetEngineLoader exported function. The EngineLoader object provides access to the settings required during the Engine object initialization.

2.Set up all the necessary parameters using the EngineLoader object properties. The CustomerProjectID is a required property. You can set the path to the cloud licensing file, the corresponding password and a path to the folder, in which ABBYY FlexiCapture Engine should store user-specific data if needed.

3.Call the GetEngine method of the EngineLoader object and receive the reference to the Engine object.

cicon2 C++ (COM) code

// HANDLE to FCEngine.dll
static HMODULE s_libraryHandle = 0;

BOOL loadEngine()
{
// First step: load FCEngine.dll
if( s_libraryHandle == 0 ) {
s_libraryHandle = LoadLibraryEx( ::GetDllPath(), 0, LOAD_WITH_ALTERED_SEARCH_PATH );
if( s_libraryHandle == 0 ) {
return FALSE;
}
}

// Second step: obtain Engine Loader
typedef HRESULT ( STDAPICALLTYPE* EngineLoaderFunc )( FCEngine::IEngineLoader** );
EngineLoaderFunc pEngineLoader =
(EngineLoaderFunc)GetProcAddress( s_libraryHandle, "GetEngineLoader" );

if( pEngineLoader == 0 ) {
return FALSE;
}

HRESULT hResult = pEngineLoader( &engineLoader );
if( FAILED( hResult ) ) {
IErrorInfo* errorInfo;
::GetErrorInfo( 0, &errorInfo );
_com_raise_error( hResult, errorInfo );
}

// Third step: set required parameters and load the Engine
engineLoader->put_CustomerProjectId( ::GetCustomerProjectId() );
engineLoader->put_LicensePath( ::GetLicensePath() );
engineLoader->put_LicensePassword( ::GetLicensePassword() );
engine = engineLoader->GetEngine();

return TRUE;
}

This procedure is used in the ABBYY FlexiCapture Engine samples which can be found in the Samples folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder).

Received in such a way Engine object is a singleton, so only one object of this type may be created in a single instance of the application that uses ABBYY FlexiCapture Engine. Repeated attempts to create the Engine object will return the same object. It is important to notice that the process of creation of the Engine object takes rather long time because it requires loading not only the FCEngine.dll, but a whole set of other DLLs.

note Note: .NET developers must make sure to specify [STAThread] (single-threaded apartment model) оr [MTAThread] (multi-threaded apartment model) as an attribute on the application main function, otherwise an error may occur:

[STAThread]
public static void Main()
{
...
}

It is recommended to use the [STAThread] because it is now more accepted.

If your license has expired, the Engine object will be created but only the StartLogging, StopLogging of the Engine object will be available. Other methods of the Engine object will return CLASS_E_NOTLICENSED error code.

It is prohibited to initialize ABBYY FlexiCapture Engine at the entry points of other DLLs, and also in constructors and destructors of static and global objects implemented in DLLs, because they are called at the DLL entry points. This restriction is due to the fact that the Win32 LoadLibrary function is not re-entrant. A user should initialize ABBYY FlexiCapture Engine elsewhere, for example, in WinMain function of an EXE module.

During initialization ABBYY FlexiCapture Engine will reset the LC_CTYPE setting of msvcrt.dll to operating system defaults. This fact should be taken into account if your application depends upon the msvcrt.dll locale-dependent services.

After creating the Engine object you can use ABBYY FlexiCapture Engine objects in your application. As the next step create the FlexiCapture processor.

Additionally

ABBYY FlexiCapture Engine provides two other ways to load the Engine object, which allow you to access to completely thread-safe objects.

Supplementary information on loading ABBYY FlexiCapture Engine in applications written in different programming languages:

·in scripting languages

·in Delphi

·in Java

·general recommendations for all languages

See also
Step 2: Create FlexiCapture Processor


Step 2: Create FlexiCapture Processor

Guided Tour > Tutorial > Processing with a Customizable Processor Object >

Step 2: Create FlexiCapture Processor

When you start working with ABBYY FlexiCapture Engine, you first create the Engine object. After this you can use ABBYY FlexiCapture Engine objects in your application.

warning Important! You will need to initialize the COM library by the call to the CoInitialize/CoInitializeEx function before starting to work with FlexiCapture Processor. See the details about COM initialization functions on http://msdn.microsoft.com.

To process a document, you need to create a special FlexiCaptureProcessor object. FlexiCaptureProcessor is a processor object which converts input images into FlexiCapture documents. The processor stores internally all the settings required for processing: Document Definitions and processing parameters.

To create the FlexiCaptureProcessor object, use the CreateFlexiCaptureProcessor method of the Engine object.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create Engine object
...
// Create FlexiCapture processor
FCEngine::IFlexiCaptureProcessorPtr processor = Engine->CreateFlexiCaptureProcessor();
...

This procedure is used in ABBYY FlexiCapture Engine samples which can be found in the Samples folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder).

After creating the processor, you need to add Document Definitions and images and then recognize documents.

Additionally

You can set a reference manager, which will resolve references to files passed to the processor. By default, string references to Document Definitions, images, etc. are interpreted as references to files in the file system. If a custom reference manager is set, references are resolved by this manager. This approach may be used to organize work with a remote storage location accessed using any protocol.

See also

Step 3: Add Document Definitions

Step 1: Load FlexiCapture Engine


Step 3: Add Document Definitions

Guided Tour > Tutorial > Processing with a Customizable Processor Object >

Step 3: Add Document Definitions

After you have created the FlexiCapture processor, you need to add Document Definitions to configure the processor for working with documents. A Document Definition describes the location of document elements and indicates the fields to be used in data extraction.

In ABBYY FlexiCapture Engine, a Document Definition is represented by the DocumentDefinition object.

To add a Document Definition to be used for processing, you can use the AddDocumentDefinitionFile method of the FlexiCaptureProcessor object. This method adds a Document Definition from an *.fcdot file. This file can be created in ABBYY FlexiCapture 12. You can also create a Document Definition in ABBYY FlexiCapture Engine.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create Engine object
...
// Create FlexiCapture processor
FCEngine::IFlexiCaptureProcessorPtr processor = Engine->CreateFlexiCaptureProcessor();
...
// Add Document Definition
processor->AddDocumentDefinitionFile( L"C:\\MyTemplates\\Invoice.fcdot" );
...

This procedure is used in the ABBYY FlexiCapture Engine samples which can be found in the Samples folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder).

After the Document Definitions are added, you can add images and then recognize documents.

Additionally

You can make additional settings for the FlexiCapture processor:

·set the parameters of image preprocessing

·set the rule for assembling image pages into documents

·specify whether blank pages should be deleted during processing

·specify whether Document Definitions should be applied forcibly

·make the processor use the first matching Document Definition

·add classification tree, which may speed up the selection of a Document Definition for matching

See also

Step 4: Add Images

Step 2: Create FlexiCapture Processor


Step 4: Add Images

Guided Tour > Tutorial > Processing with a Customizable Processor Object >

Step 4: Add Images

When the FlexiCapture processor is configured, you can add new images for processing. By default, images added for processing are stored in the internal processing queue.

To add images for processing, use the AddImageFile method of the FlexiCaptureProcessor object.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create Engine object
...
// Create and configure FlexiCapture processor
FCEngine::IFlexiCaptureProcessorPtr processor = Engine->CreateFlexiCaptureProcessor();
...
// Add images
processor->AddImageFile( L"C:\\MyImages\\001.tif" );
processor->AddImageFile( L"C:\\MyImages\\002.tif" );
processor->AddImageFile( L"C:\\MyImages\\003.tif" );
...

This procedure is used in the ABBYY FlexiCapture Engine samples which can be found in the Samples folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder).

After the images are added, you can recognize documents.

Additionally

You can set a custom image source. By default, prior to processing, source images are added into the internal processing queue as references to the corresponding files (push model). If required, you can implement your own external image queue, which will either return references to files on demand (pull model) or, instead of references to files, provide the source images as a stream in memory (working with memory).

See also

Step 5: Recognize Documents

Step 3: Add Document Definitions


Step 5: Recognize Documents

Guided Tour > Tutorial > Processing with a Customizable Processor Object >

Step 5: Recognize Documents

During document processing, the program selects the Document Definition appropriate for the document pages, applies it, and performs data recognition in the regions found in the document with the help of the selected Document Definition.

ABBYY FlexiCapture Engine allows you to perform all these processing steps by using one method. To recognize documents, you can use the RecognizeNextDocument method of the FlexiCaptureProcessor object. This method returns the Document object, which corresponds to the recognized document.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create Engine object
...
// Create and configure FlexiCapture processor
FCEngine::IFlexiCaptureProcessorPtr processor = Engine->CreateFlexiCaptureProcessor();
...
// Add images
...
//Recognize next document
FCEngine::IDocumentPtr document = processor->RecognizeNextDocument();
...

This procedure is used in the ABBYY FlexiCapture Engine samples which can be found in the Samples folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder).

After the documents are recognized, you can export results.

Additionally

You can check if an error occurred during this processing step.

After an error is handled, you can try repeating the last processing step or resuming the processing from the next step. You can always reset the processing, preserving all the settings.

See also

Step 6: Export Results

Step 4: Add Images


Step 6: Export Results

Guided Tour > Tutorial > Processing with a Customizable Processor Object >

Step 6: Export Results

After the document has been recognized, you can immediately export the document to a destination format. ABBYY FlexiCapture Engine allows you to save recognized data to a file in XLS, DBF, TXT, CSV, or XML format, and save an electronic copy of your document, e.g. in PDF or PDF/A format.

You can use the ExportDocument or ExportDocumentEx method of the FlexiCaptureProcessor object to export recognized data. The first one uses the export settings defined in the corresponding Document Definition, while the second one allows you to specify your own export settings.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
FCEngine::IFlexiCaptureProcessorPtr processor;
FCEngine::IDocumentPtr document;
...
// Export results
processor->ExportDocument(document, L"D:\\ExportResults");

This procedure is used in the FlexiCapture Engine Code Snippets sample which can be found in the Samples folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder).

Additionally

You can tune the export procedure using the export parameters.

You can organize a storage of recognized documents using the available means for reading and writing documents onto a disk or into a stream.

You can implement your own export procedure. For example, you can traverse all the fields of a document and export their values. Sample code is provided in the FlexiCapture Engine Code Snippets sample.

See also

Final Step: Unload FlexiCapture Engine

Step 5: Recognize Documents


Final Step: Unload FlexiCapture Engine

Guided Tour > Tutorial > Processing with a Customizable Processor Object >

Final Step: Unload FlexiCapture Engine

After finishing your work with ABBYY FlexiCapture Engine, unload the Engine object. Use the DeinitializeEngine exported function.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// HANDLE to FCEngine.dll
static HMODULE s_libraryHandle = 0;
BOOL UnloadFCEngine()
{
if( s_libraryHandle == 0 ) {
return TRUE;
}
// Release Engine object
if( Engine != 0 ) {
Engine.Release();
}
// Check if FCEngine.dll can be unloaded
typedef HRESULT (STDAPICALLTYPE* DeinitializeEngineFunc)();
DeinitializeEngineFunc pDeinitializeEngine =
(DeinitializeEngineFunc)GetProcAddress( s_libraryHandle, "DeinitializeEngine" );
if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
return FALSE;
}
// Now we can free library safely
FreeLibrary( s_libraryHandle );
s_libraryHandle = 0;
return TRUE;
}

This procedure is used in the ABBYY FlexiCapture Engine samples which can be found in the Samples folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder).

It is prohibited to deinitialize ABBYY FlexiCapture Engine at the entry points of other DLLs, and also in constructors and destructors of static and global objects implemented in DLLs, because they are called at the DLL entry points. This restriction is due to the fact that the Win32 FreeLibrary function is not re-entrant. A user should deinitialize ABBYY FlexiCapture Engine elsewhere, for example, in WinMain function of an EXE module.

note Note: The "Engine deinitialization failed" exception can be thrown during the deinitialization of the Engine object if not all of the objects which were created and used by the application have been deleted before the Engine object deinitialization. If you work with programming languages which do not have garbage collections (for example, C++), you must either use smart pointer classes (see the samples in C++ (COM)) or release objects that were created by creation methods when they are no longer needed. If all the objects have been deleted, the exception may be caused by the garbage collector operation. If the application is developed in Visual Basic .NET, all objects with the Nothing value are not deleted, they are only marked for deletion. The exact moment when the garbage collector deletes the object is not known. Therefore, you should call the following methods before the deinitialization of the Engine object so that the garbage collector deletes the object:

GC.Collect()
GC.WaitForPendingFinalizers()

You can use the StartLogging method of the Engine object to get the list of objects that have not been deleted.

Additionally

ABBYY FlexiCapture Engine provides two other ways to load and unload the Engine object. These ways provide access to completely thread-safe objects.

Supplementary information on unloading ABBYY FlexiCapture Engine in applications written in different programming languages:

·in scripting languages

·in Delphi

·in Java

·general recommendations for all languages

See also

Step 1: Load FlexiCapture Engine


Creating Document Definitions by Training

Guided Tour > Tutorial >

Creating Document Definitions by Training

This section describes how you can create Document Definitions without using special tools like ABBYY FlexiLayout Studio or ABBYY FormDesigner.

ABBYY FlexiCapture Engine 12 allows you to create Document Definitions using methods of API. The Document Definition Training API uses the same principles of creating Document Definitions as ABBYY FlexiLayout Studio. However this API is not intended for designing comprehensive Document Definitions, in this case you'd better use proper ABBYY tool mentioned above.

Let's see how it works:

1.Selecting template images

You have a group of images, from which you need to extract some data fields. These can be a set of similar images, which contain the same fields, or a set of images of several document types. Select several examples of such images (from 3 to 5 images for each document type). Give preference to the ones which have the best image quality.

2.Training Document Definitions

Selected images are used to train Document Definitions for each of the document types:

1.An empty Document Definition is created.

2.Preliminary recognition of the first template image is performed: FlexiCapture Engine finds available text elements on the image.

3.You select data fields and reference elements on the first image from the elements detected during preliminary recognition or from any other elements on the image. Data fields contain data you want to extract. Reference elements help FlexiCapture Engine to find data fields. It may be some words (like "Total" for a total sum on a receipt), lines, barcodes. Reference elements are similar on all documents of the same type.

4.After the data fields and reference elements are selected on the first page, FlexiCapture Engine tries to find the same elements on the second page.

You should check fields and elements found on the page and correct them, if necessary. If the second page has another document type (i.e. you need to extract another fields from this document, or the document has another positions of reference elements or data fields), you create another empty Document Definition for this type of documents and specify data fields and reference elements for this Document Definition. Then the same is done for all template pages.

3.Saving Document Definitions

After all pages have been used for training, you can save each Document Definition in a ABBYY FlexiLayout file (*.afl). You can load the created *.afl file using one of the available API methods and use it for recognition

4.Testing Document Definitions

After that you can test the created Document Definitions on some more images. If the data fields are detected correctly, then the created Document Definitions are ready for use. If data fields are detected incorrectly on some pages, add these pages to template images and perform additionally training of Document Definitions. When Document Definitions have been tested successfully, they are ready for use.

You can find the detailed implementation advice below. The implementation procedures are slightly different in the situations when you train one Document Definition and when several Document Definitions are trained.

Creating Document Definitions

cicon2 Step 1. Loading ABBYY FlexiCapture Engine

To start working with ABBYY FlexiCapture Engine, you need to create the Engine object. You can create the Engine object using the InprocLoader object, which implements the IEngineLoader interface. See other possible ways in Different Ways to Load the Engine Object.
cicon2 Step 2. Adding template images to a training batch

The main object which provides access to the Document Definition training functionality is the TrainingBatch object. This training batch contains all template images and training Document Definitions. To create and configure the batch, do the following:

1.Create a training batch using the CreateTrainingBatch method of the Engine object. The method takes as input parameters the path to the folder, where the batch should be stored, and the recognition language of your documents.

2.After creation the training batch contains an empty collection of Document Definitions. Add a new Document Definition to the collection and specify its name. To do it, use the AddNew method of the TrainingDefinitions subobject of the TrainingBatch object with the name of the Document Definition as a parameter.

3.Add template images to the batch: use the AddImageFile method of the TrainingBatch object.
cicon2 Step 3. Training Document Definitions

After you have added all template images and create an empty Document Definition in the training batch, you can start training Document Definitions on a set of template images. Do the following:

1.Run preliminary recognition of a page in the batch using the PrepareNextPageNotSubmittedForTraining method of the TrainingBatch object. The method returns a TrainingPage object.

2.The Document Definition contains a collection of training fields (TrainingFields object). Add new data fields and reference elements to the collection using the AddNew method of the TrainingFields object.

3.Set regions of the training fields using the SetFieldBlock method of the TrainingPage object. You can view text elements and their regions found on the image during preliminary recognition via the TrainingImageObjects collection of the TrainingPage object and use this information to set blocks of the fields.

4.Submit the page to the batch as ready for training: use the SubmitPageForTraining method of the TrainingBatch object. In this case, the page will be used for training a Document Definition.

5.Obtain the next page using the PrepareNextPageNotSubmittedForTraining method of the TrainingBatch object.

6.Do one of the following:

oIf the page has the same type as the previous ones and an already created Document Definition can be used for this page, simply specify the correct Document Definition of the page using the SetPageDefinition method of the TrainingBatch object and correct the predicted layout, if necessary.

oIf the next page has another document type:

1.Create a new Document Definition for this type of documents using the AddNew method of the TrainingDefinitions subobject of the TrainingBatch object. A new Document Definition can be added to the training batch at any moment during training.

2.Assign the correct Document Definition of the training page using the SetPageDefinition method of the TrainingBatch object.

3.Specify the training fields and their regions as described in the steps 5-6 of the procedure of creating single Document Definition.

7.Submit the page to the batch using the SubmitPageForTraining method.

8.Repeat the steps 5-7 of this procedure for each page. Do this until all pages are used for training and all their layouts are verified — in this case, PrepareNextPageNotSubmittedForTraining method returns NULL. Any modification in a Document Definition resets the ITrainingPage::IsLayoutVerified property for all pages and makes FlexiCapture Engine verify this Document Definition automatically again on all pages (no matter whether you have verified the page previously or not).
cicon2 Step 4. Saving Document Definitions

When all template images are used for training, save created Document Definitions:

1.Save each created Document Definition to an ABBYY FlexiLayout file using the ExportToAFL method of the TrainingDefinition object.

2.Close the training batch using the Close method of the TrainingBatch object.

3.Use the created ABBYY FlexiLayout files for recognition. For example, you can create a Document Definition from an AFL file using the CreateDocumentDefinitionFromAFL method of the Engine object. See details in Creating Document Definitions.
cicon2 Step 5. Testing Document Definitions

After Document Definitions have been saved, you can test them on more images. For the test you can use the procedure of processing with FlexiCapture processor:

1.Create the FlexiCaptureProcessor object: use the CreateFlexiCaptureProcessor method of the Engine object.

2.Create a Document Definition from an *.afl file using the CreateDocumentDefinitionFromAFL method of the Engine object. See details in Creating Document Definitions.

3.Add the created Document Definition to FlexiCapture processor: you can use the AddDocumentDefinition method of the FlexiCaptureProcessor object.

4.Add testing images using the AddImageFile method of the FlexiCaptureProcessor object.

5.Recognize testing images using the RecognizeNextDocument method of the FlexiCaptureProcessor object.

6.Check that the testing images are and recognized correctly. If there are errors on some images, you can add such images to the training batch and perform additional training.
cicon2 Step 6. Additional training

If you want to train the Document Definition on more template images, open it using the OpenTrainingBatch method of the Engine object. You should pass the path to the folder, which was used during Document Definitions creation, as a parameter of the method. Add new images to the batch and check, whether the Document Definitions are applied correctly.

When all training and testing are finished, use the created files for processing.
cicon2 Step 7. Unloading ABBYY FlexiCapture Engine

After finishing your work with ABBYY FlexiCapture Engine, unload the Engine object. Use the proper deinitialization method. See details in Different Ways to Load the Engine Object.

Samples

FlexiCapture Engine code samples include sample tool Creating Document Definitions by Training, which allows you to create Document Definitions by training. You can find also useful examples in FlexiCapture Engine Code Snippets.

See also

Document Definition Training API


Advanced Techniques

Guided Tour >

Advanced Techniques

This section provides advanced information about working with ABBYY FlexiCapture Engine API. For basic steps of using FlexiCapture Engine see Tutorial section.

The main programming aspects are presented in the following sections:

·Programming Aspects

oDifferent Ways to Load the Engine Object

oUsing ABBYY FlexiCapture Engine in multi-threaded server applications

oError Handling

oWorking with Properties

oWorking with Collections

oWorking with Connectable Objects

oUsing ABBYY FlexiCapture Engine in Delphi

oUsing ABBYY FlexiCapture Engine in Java

In this section you can find how to:

·Create Document Definitions

·Set up recognition languages

·Set up a custom image source

·Implement custom resolution of references

·Create filters for special image preprocessing

·Work with recognized data

·Verify recognized data

·Work with recognition variants

·Classify a set of images by category

·Tune export parameters

·Scanning with FlexiCapture Engine

·Perform integration with ABBYY FineReader Engine


Programming Aspects

Guided Tour > Advanced Techniques >

Programming Aspects

The ABBYY FlexiCapture Engine application programming interface conforms to the COM standard and can be easily used in C/C++, Visual Basic, .NET, Java, Delphi, or any other development tools supporting COM components. The Engine can be adapted for use in scripting languages like VBS, JS, Perl.

This section describes the main aspects of using ABBYY FlexiCapture Engine in applications written in different programming languages and provides references to articles which discuss related topics.

Loading, initialization, and deinitialization

It is prohibited to initialize and deinitialize ABBYY FlexiCapture Engine at the entry points of other DLLs, and also in constructors and destructors of static and global objects implemented in DLLs, because they are called at the DLL entry points. This restriction is due to the fact that the Win32 LoadLibrary and FreeLibrary functions are not re-entrant. A user should initialize and deinitialize ABBYY FlexiCapture Engine elsewhere, for example, in WinMain function of an EXE module.

note Note: We highly recommend initializing the COM library by the call to the CoInitialize/CoInitializeEx function before starting to work with ABBYY FlexiCapture Engine library. If your application uses FlexiCapture Processor, initializing COM is required. See the details about COM initialization functions on http://msdn.microsoft.com.

During initialization, ABBYY FlexiCapture Engine will reset the LC_CTYPE setting of msvcrt.dll to the operating system defaults. This fact should be taken into account if your application depends upon the msvcrt.dll locale-dependent services.

The "Engine deinitialization failed" exception can be thrown during the deinitialization of the Engine object if not all of the objects which were created and used by the application have been deleted before the Engine object deinitialization. If you work with programming languages which do not have garbage collections (for example, C++), you must either use smart pointer classes (see the samples in C++ (COM)) or release objects that were created by creation methods when they are no longer needed. If all the objects have been deleted, the exception may be caused by the garbage collector operation. If the application is developed in Visual Basic .NET, all objects with the Nothing value are not deleted, they are only marked for deletion. The exact moment when the garbage collector deletes the object is not known. Therefore, you should call the following methods before the deinitialization of the Engine object so that the garbage collector deletes the object:

GC.Collect()
GC.WaitForPendingFinalizers()

You can use the StartLogging method of the Engine object to get the list of objects that have not been deleted.

Objects and their properties

warning Important! A pointer to the child object's interface is valid until its parent object exists. An attempt to access a child object after its parent object is destroyed may result in an error.

Certain ABBYY FlexiCapture Engine objects have read-only object properties. Such properties cannot be changed directly in raw C++. If you want to change such a property, you need to pass a reference to the property object to a new variable, and then use this variable to change it.

Please see Working with Properties for details.

Also in this section

·Different Ways to Load the Engine Object

The detailed description of loading and unloading ABBYY FlexiCapture Engine.

·Using ABBYY FlexiCapture Engine in multi-threaded server applications

Peculiarities of using in server applications.

·Error Handling

Information about error handling.

·Working with Properties

The interfaces of ABBYY FlexiCapture Engine objects have various properties and methods. The way the properties are handled in different languages is discussed in this article.

·Working with Collections

There are two different types of collection objects in ABBYY FlexiCapture Engine. Here you can find the distinctions of these types and an advice on how to work with them.

·Working with Connectable Objects

Some of the objects in ABBYY FlexiCapture Engine are so-called "connectable objects." Here you can find useful recommendations on working with such objects.

·Working with COM Interfaces from a Scripting Language

The detailed description of how to use ABBYY FlexiCapture Engine in a scripting language.

·Using ABBYY FlexiCapture Engine in Delphi

The description of the initialization and deinitialization procedure in Delphi.

note Note: The sample is deprecated because of low frequency of Delphi usage. The sample will be removed in future versions.

·Using ABBYY FlexiCapture Engine in Java

The description of how to use FlexiCapture Engine in Java.


Different Ways to Load Engine Object

Different Ways to Load the Engine Object

Guided Tour > Advanced Techniques > Programming Aspects >

Different Ways to Load the Engine Object

There are three ways to load the Engine object in ABBYY FlexiCapture Engine 12. Each of the loading methods has its own specifics affecting the use of the object in different circumstances. The first two methods are most suitable for use in interactive applications which are not intended for simultaneous processing of multiple requests. The third method is most suitable for server solutions.

Loading FCEngine.dll manually and working with “naked” interfaces

This is the standard method to load the Engine object, which was also used in older versions of ABBYY FlexiCapture Engine. To get a reference to the Engine object, you should do the following:

·call the GetEngineLoader exported function to create the EngineLoader object

·set up all the necessary parameters using the EngineLoader object properties

·call the GetEngine method of the EngineLoader object and receive the reference to the Engine object.

This object loading method is described in detail in the Tutorial, Step 1: Load FlexiCapture Engine.

Advantages

Limitations

·Results in maximum performance.

·Easy access to any licensing type.

·Does not require registration of FCEngine.dll.

·Imposes restriction on working with multi-threaded applications (see Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications).

·When working with high-level languages (for instance, .NET), low-level means must be used to load dynamic libraries and to call functions published in them.

Loading the Engine object by means of COM into the current process

The Engine is loaded as an in-process server into the same process where the application is running. The Engine object is loaded using the InprocLoader object, which implements the IEngineLoader interface.

Please note that you must keep the reference to the loader object until you finish working with the Engine. You can then call the Unload method of the loader object to deinitialize the Engine, and then destroy the loader object.

Advantages

Limitations

·All ABBYY FlexiCapture Engine objects are completely thread-safe and can be created and used in different threads.

·When working from the Мain STA apartment, performance is the same as when working with the naked interfaces. When accessing from different threads, some marshalling losses may occur, which are negligible in most scenarios.

·Registration of FCEngine.dll is required when installing the final application on an end user's computer.
cicon2 C# code

IEngineLoader engineLoader = new FCEngine.InprocLoader();
IEngine engine = engineLoader.Load(…);
try {
…
} finally {
engineLoader.Unload();
}

note Note:

To register FCEngine.dll when installing your application on an end-user computer, use the following command line:

regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FCEngine.dll>"

Loading the Engine object by means of COM into a separate process

The Engine is loaded as an out-of-process server into a separate process. The Engine object is loaded by means of the OutprocLoader object, which implements a IEngineLoader interface.

Please note that you must keep the reference to the loader object until you finish working with the Engine. You can then call the Unload method of the loader object to deinitialize the Engine, and then destroy the loader object.

Advantages | Limitations
·All ABBYY FlexiCapture Engine objects are completely thread-safe. Each instance of the Engine runs in a separate process parallel to the others. ·A pool of processors can be organized to make full use of the computer's CPU power. | ·There are some small marshalling losses. ·Registration of FCEngine.dll is required when installing the final application on an end user's computer. ·When working under accounts with limited permissions, the necessary permissions must be granted. ·It is impossible to access a page image as HBITMAP without marshalling. ·Cannot be used with Visual Components, as they do not work with multiple processes.
cicon2 C# code

IEngineLoader engineLoader = new FCEngine.OutprocLoader();
IEngine engine = engineLoader.Load(…);
try {
…
} finally {
engineLoader.Unload();
}

note Notes:

·Account permissions can be set up using the DCOM Config utility (either type DCOMCNFG in the command line, or select Control Panel > Administrative Tools > Component Services). In the console tree, locate the Component Services > Computers > My Computer > DCOM Config folder, right-click ABBYY FlexiCapture Engine 12 Loader (Local Server), and click Properties. A dialog box will open. Click the Security tab. Under Launch Permissions, click Customize, and then click Edit to specify the accounts that can launch the application.

Note that on a 64-bit operating system the registered DCOM-application is available in the 32-bit MMC console, which can be run using the following command line:

"mmc comexp.msc /32"

·To register FCEngine.dll when installing your application on an end-user computer, use the following command line:

regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FCEngine.dll>"

·We recommend that you use a Network License both for debugging your server application and for running it.

Additionally you can manage the priority of work processes and control whether their parent process is alive and terminate if it is not. Use the IWorkProcessControl interface.

Comparison table

The table below sums up the characteristics of the three loading methods:

Characteristics | Naked interfaces | In-process server | Out-of-process server
Works without proxy (no marshalling losses) | Yes | There are limitations | No
Works in multi-threaded applications | There are limitations | Yes | Yes
Parallel running processes are possible (for server solutions) | No | No | Yes
No registration of FCEngine.dll required | Yes | No | No
No running permissions must be set up | Yes | Yes | No
Objects can be created using the new operator. Works from scripts. | No | Yes | Yes
Ability to access a page image as HBITMAP | Yes | Yes | No
Works in a separate process (fail-proof, recycling) | No | No | Yes
Can be used with Visual Components | Yes | Yes | No

Using from a 64-bit process

If you are going to use ABBYY FlexiCapture Engine from a 64-bit process (e.g. ASP.NET on 64-bit servers), we recommend that you use the way of loading FlexiCapture Engine into a work process.

See also

Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications


Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications

Guided Tour > Advanced Techniques > Programming Aspects >

Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications

Using ABBYY FlexiCapture Engine in server applications has certain specifics:

·multiple independent requests must be handled simultaneously in multiple threads within one process

·the Engine runs under a server operating system on a high-performance multi-CPU computer

·using with special accounts (Network Service, Local Service, ASPNET).

When developing ABBYY FlexiCapture Engine 12, the above specifics were taken into consideration and tools were included into the API which enable you to get thread-safe ABBYY FlexiCapture Engine objects as part of a server process or in separate processes. Using ABBYY FlexiCapture Engine in multiple processes allows you to create a pool of objects that work simultaneously and use the full CPU power of the server computer. This is the optimal approach in most server scenarios.

Loading the Engine object into a server application

The most optimal method of loading the Engine into a server application is to load it by means of COM into a separate process as an out-of-process server. This method automatically eliminates all difficulties related to multi-threading: all operations with the ABBYY FlexiCapture Engine objects are serialized by means of COM, which allows you to create several Engine instances in several processes and work with them simultaneously from within the server process. At the same time this method is easy to use. The Engine object is loaded by using the OutprocLoader object, which implements an IEngineLoader interface.

cicon2 C# code

IEngineLoader engineLoader = new FCEngine.OutprocLoader();
IEngine engine = engineLoader.Load(…); // We got Engine in a separate process
try {
…
} finally {
engineLoader.Unload(); // We can unload it when it is no longer needed
}

This method has one important drawback, however. When using it with special accounts, permissions may be required to run OutprocLoader for such accounts. However, this, and the need to register FCEngine.dll, is not very crucial in server products, as server applications are usually installed by experienced administrators on a small number of computers.

note Notes:

·Account permissions can be set up using the DCOM Config utility (either type DCOMCNFG in the command line, or select Control Panel > Administrative Tools > Component Services). In the console tree, locate the Component Services > Computers > My Computer > DCOM Config folder, right-click ABBYY FlexiCapture Engine 12 Loader (Local Server), and click Properties. A dialog box will open. Click the Security tab. Under Launch Permissions, click Customize, and then click Edit to specify the accounts that can launch the application.

Note that on a 64-bit operating system the registered DCOM-application is available in the 32-bit MMC console, which can be run using the following command line:

"mmc comexp.msc /32"

·To register FCEngine.dll when installing your application on an end-user computer, use the following command line:

regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FCEngine.dll>"

·We recommend that you use a Network License both for debugging your server application and for running it.

Additionally you can manage the priority of work processes and control whether their parent process is alive and terminate if it is not. Use the IWorkProcessControl interface.

Other methods of loading ABBYY FlexiCapture Engine are also available. However, they have certain specifics which considerably limit their use in server applications.

·ABBYY FlexiCapture Engine can be loaded by means of COM as an in-process server within the current process. This method also automatically eliminates all difficulties related to multi-threading (all operations with the ABBYY FlexiCapture Engine objects are serialized by means of COM) and is easy to use. However, this method does not allow you to organize simultaneous processing using several instances of the Engine object, which in many ways limits the performance of the server. Another drawback of this method is that it requires registration of FCEngine.dll when installing the application on an end user's computer.

·FCEngine.dll can be loaded manually. This is the standard method that was used in older versions of ABBYY FlexiCapture Engine. This method requires that all operations with the Engine object be performed within the same thread where the Engine object was initialized. In addition, it does not allow you to initialize more than one Engine object per process. This considerably limits the performance of the server. For this reason we do not recommend using this method. One advantage of this method is that it does not require registration of FCEngine.dll when installing the application on end user's computer.

For detailed descriptions of the three loading methods available in ABBYY FlexiCapture Engine, see Different Ways to Load the Engine Object.

ABBYY FlexiCapture Engine includes a sample called FlexiCapture Web Service (C#), which provides a model for a server application. You can access this sample by selecting Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder > FlexiCapture Web Service (C#).

Increasing the performance of your server application

The performance of your server application can be increased by creating a pool of initialized processors (FlexiCaptureProcessor objects) running in parallel processes. ABBYY FlexiCapture Engine includes a sample called FlexiCapture Processors Pool which shows how a pool of processors can be created and used. The sample provides a ready-made solution which has been tried in real life projects. This solution has the following characteristics:

·thread-safety

·background initialization at the start of the server application ensures a speedy start of the server process; after initialization the processors are ready for use – the templates are loaded and the processors have been "warmed up"

·easy access to the processors in the pool; access is done via Semaphore synchronization primitive: the number of simultaneously working processors cannot exceed a certain predefined number, while the other processors are in stand-by

·processes can be recycled manually or automatically; this ensures reliable operation of the server over long time periods and automatically restores its operation in event of serious errors; recycling is done in background mode

See also

Different Ways to Load Engine Object


Error Handling

Guided Tour > Advanced Techniques > Programming Aspects >

Error Handling

All ABBYY FlexiCapture Engine interface methods and properties return a value of the HRESULT type. The HRESULT (for result handle) is a way of returning success, warning, and error values. HRESULTs are really not handles to anything; they are only 32-bit values with several fields encoded in the value. A zero result indicates success and a nonzero result indicates failure.

If a method or property call was not successful, this method or property returns an HRESULT code that indicates the failure. Besides, it initializes the IErrorInfo object with a more detailed description of the error. Visual Basic users may access the HRESULT code through the Number property of the Err object. Other attributes of the Err object are initialized with the information from the IErrorInfo. Please refer to the documentation on COM for detailed description of error handling. The most general tips for it are the following:

·Visual Basic. Error handling here is performed with the use of the On Error statement. If you do not use the On Error Resume Next statement anywhere in your code, any run-time error that occurs can cause an error message from the IErrorInfo object to be displayed and code execution stopped.

·Raw C++. ABBYY FlexiCapture Engine interface methods and properties cannot throw exceptions but return HRESULTs. The most important means for handling these return codes are the SUCCEEDED and FAILED macros. They test the HRESULT value and deduce from it what was the result of the operation – success or failure. To get a pointer to the IErrorInfo object interface, use the GetErrorInfo API function.

·C++ with the Native COM support. The Native COM support technology translates the HRESULT codes of interface functions into exceptions of the special type - _com_error, and automatically uses information from the IErrorInfo object. Thus, a sequence of ABBYY FlexiCapture Engine methods may be enclosed by the statements:

try {
...
} catch (_com_error e) {
...
}

If any method or property that was called from inside the try-catch block returns an error code, this leads to throwing the exception, and the code after erroneous statement is not executed, and control is transferred to the code after the catch statement. Generally, error handling with the Native COM support may be performed in a way standard for any C++ code using functions that may throw exceptions.

·C#. Automatically generated wrappers for COM interfaces detect errors and translate them to standard exceptions:

try {
…
} catch( Exception e ) {
...
}

See also

Standard Return Codes


Working with Properties

Guided Tour > Advanced Techniques > Programming Aspects >

Working with Properties

The interfaces of ABBYY FlexiCapture Engine objects have various properties and methods. As Visual Basic users are familiar with the notion of property, we will discuss the way the properties are handled in C++.

For a C++ user, a property is a couple of methods (get and put for read-write properties) or a single get method (for read-only properties). However, the "Native COM support" featured by Microsoft Visual C++ makes the way the properties are handled more like the one used in Visual Basic. This is the way implied by the sense on the noun "property."

The ABBYY FlexiCapture Engine properties may be of the following types:

IDL | Visual Basic type | C++ type | C#
VARIANT_BOOL (VARIANT_TRUE or VARIANT_FALSE) | Boolean (with two values, True and False) | VARIANT_BOOL (with two values VARIANT_TRUE and VARIANT_FALSE) | bool (true or false)
int | Int | int | int
double | Double | double | int
BSTR, a pointer to Unicode string. Zero value specifies an empty string. | String | BSTR, a pointer to Unicode string. Zero value specifies an empty string. | string
__int64 | Int64 | __int64 | Int64
HANDLE* |  |  |
IUnknown-derived interface | Object | IUnknown-derived interface | object
enum | Enumeration | Enumeration | enum

See the details of working with different types of properties below:

cicon2 Working with simple properties

We will use the Boolean property to describe how simple properties are used. This property is described in the type library as follows:

interface IMyObject : IUnknown {
...
[propget]
HRESULT MyProperty([out, retval]VARIANT_BOOL* pVal);
[propput]
HRESULT MyProperty([in]VARIANT_BOOL newVal);
...
};

A Visual Basic user handles this property as follows:

If MyObject.MyProperty <> True Then
MyObject.MyProperty = True
End If

A C++ user, on the other hand, uses two methods to work with this property. These methods have get_ and put_ prefixes. The respective C++ code should look as follows:

IMyObject* pMyObject;
...
VARIANT_BOOL res;
pMyObject->get_MyProperty(&res);
if( res != VARIANT_TRUE )
pMyObject->put_MyProperty(VARIANT_TRUE);

However, the Native COM support makes the procedure simpler, and the respective code should look like this:

IMyObjectPtr pMyObject;
...
if(pMyObject->MyProperty != VARIANT_TRUE)
pMyObject->MyProperty = VARIANT_TRUE

If the type library only defines the "get" method for a property, this property is called read-only. Its value cannot be changed by the user, it may only be accessed for "reading."
cicon2 Working with string properties

Working with string properties is very similar to working with simple properties, but has its own specifics. A C++ user working with string properties must free the strings that are passed to set-methods, and also those that are returned by get-methods. However, this is done automatically in Visual Basic and in C++ with the Native COM support. Suppose MyObject also supports a string property called Name. This property is described in the type library as follows:

interface IMyObject : IUnknown {
...
[propget]
HRESULT Name([out, retval]BSTR* pVal);
[propput]
HRESULT Name([in]BSTR newVal);
...
};

A C++ user works with this property like this:

IMyObject* pMyObject;
...
// "get" method
BSTR res;
pMyObject->get_Name(&res);
...
// Now free the string allocated in ABBYY FlexiCapture Engine
::SysFreeString(res);
// "put" method
BSTR str = ::SysAllocString(L"New Name");
pMyObject->put_Name(str);
// Now free the string that we allocated
::SysFreeString(str);

For Visual Basic this may be rewritten:

Dim obj As MyObject
Dim res As String
res = obj.Name
Dim str As String
str = "New Name"
obj.Name = str
cicon2 Working with object properties

A C++ user will say that the parameters of "get" methods of "Object" properties are pointers to an object's interface pointer. As the interfaces of the objects are derived from IUnknown, they may be passed as IUnknown pointers to the properties or methods, which use objects of several types as input or output parameters (you may, however, get the interface you need by calling the QueryInterface method).

There are two different types of "put" methods for object properties — clear put, described by the propput keyword in the type library (the object is copied in this case); and put by reference, described by the propputref keyword in the type library (only a pointer to an existing object's interface is stored in the property in this case). A property may support only one of these put methods; most of ABBYY FlexiCapture Engine object properties clear put. In Visual Basic put by reference is performed using the Set statement, while clear put is performed without this keyword.

Suppose again the MyObject object supports MyObjectProperty property that refers to an object of MyChildObject type.

interface IMyObject : IUnknown {
...
[propget]
HRESULT MyObjectProperty([out, retval]IMyChildObject** pVal);
[propputref]
HRESULT MyObjectProperty([in]IMyChildObject* newVal);
...
};

The same property is accessed as follows in Visual Basic:

Dim ChildObj As MyChildObject
Set ChildObj=MyObject.MyObjectProperty
' Do something with the object
...
' Clear put (If it were put by reference, we would write
' Set MyObject.MyObjectProperty=ChildObj)
MyObject.MyObjectProperty=ChildObj

A C++ user will write this code as follows:

IMyObject* pMyObject;
...
IMyChildObject* pChildObj=0;
// get_ method may return 0 in certain cases
pMyObject->get_MyObjectProperty(&pChildObj);
// Do something with the object
...
pMyObject->put_MyObjectProperty(pChildObj);
...
pChildObj->Release();

Note that in C++ you should call the Release method for an object got via a property. The Native COM support calls AddRef and Release methods automatically using auto pointers.

warning Important! If an object property refers to a child object of the object that exposes this property, a pointer to the child object's interface is valid until its parent object exists. An attempt to access a child object after its parent object is destroyed may result in an error.

Working with read-only object properties

Certain ABBYY FlexiCapture Engine objects have read-only object properties. This does not mean that such properties cannot be changed, this only means that they cannot be changed directly. In raw C++, if you want to change such a property, you need to pass a reference to the property object to a new variable, and then use this variable to change it. Below you can see a C++ sample for the IFileExportParams::XMLParams property which is represented by a read-only collection:

IFileExportParams* pFileExportParams;
...
IXMLExportParams* pXmlExportParams;
pFileExportParams->get_XMLParams( &pXmlExportParams );
// Specifies if the field types are to be written in XML files
pXmlExportParams->put_ExportFieldPosition( VARIANT_TRUE );
...

See also

Types of ABBYY FlexiCapture Engine Properties


Working with Collections

Guided Tour > Advanced Techniques > Programming Aspects >

Working with Collections

There are two different types of collections in ABBYY FlexiCapture Engine.

The first one represents a collection of references to existing objects. Usually such collections are used to pass various sets of parameters into methods that require them. You create this collection, add elements to it (elements are added as references to existing objects), pass to the required method, and then destroy the collection, while the objects that were added to it remain. Such collections have Collection postfix in their names (e.g. StringsCollection, IntsCollection, SectionDefinitionsCollection).

Another type represents a collection of child objects of some parent object. These collections exist while their parent object exists. Via such collections you can add or remove child objects of the parent object. When you add an element into the collection, a new object is created internally and then added to the collection. Examples of such collections: SectionDefinitions – a collection of section definitions, Pages – a collection of document pages.

Each ABBYY FlexiCapture Engine collection has the Count and Element properties and the Item method. The first one gets the number of elements actually contained in the collection, the second and third ones get the element at the specified index. The Element property allows you to access an element of the collection using the [] operator in C#. The other properties and methods are specific for the collection.

warning Important! The indexing of ABBYY FlexiCapture Engine collections starts with 0.

Below is an example of using the StringsCollection and IntsCollection objects in C++:

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object
FCEngine::IEnginePtr Engine;
...
// Create the collection and add strings
FCEngine::IStringsCollectionPtr fileList = Engine->CreateStringsCollection();
fileList->Add( L"D:\\SampleImages\\0001.tif" );
fileList->Add( L"D:\\SampleImages\\0002.tif" );
fileList->Add( L"D:\\SampleImages\\0003.tif" );
...
// Use the collection as the input parameter of some method.
// Suppose we already have the pointer to the Batch object.
FCEngine::IStringsCollectionPtr passwordProtected;
FCEngine::IIntsCollectionPtr docIdList = batch->AddImages( fileList, -1, 0, 0, &passwordProtected );
if( passwordProtected != 0 && passwordProtected->Count != 0 ) {
// Report error opening password-protected PDFs
} else {
// Recognize documents and export results
}

The following collection objects are available:

Collections of child objects

Collections of references to objects

·AssemblingErrors – collection of AssemblingError objects

·Batches – collection of Batch objects

·BatchTypes – collection of BatchType objects

·BlockDefinitions – collection of BlockDefinition objects

·Blocks – collection of Block objects

·CheckmarkGroupBlock – collection of CheckmarkBlock objects

·DocumentDefinitions – collection of DocumentDefinition objects

·Documents – collection of Document objects

·FieldDefinitions – collection of FieldDefinition objects

·FieldInstances – collection of Field objects

·Fields – collection of Field objects

·GroupLanguage – collection of Language objects

·HotFolderProfiles – collection of HotFolderProfile objects

·PageDefinitions – collection of PageDefinition objects

·Pages – collection of Page objects

·PredefinedLanguages – collection of Language objects

·RuleErrors – collection of RuleError objects

·ScanningProfiles – collection of ScanningProfile objects

·SectionDefinitions – collection of SectionDefinition objects

·TableColumns – collection of TableColumn objects

·TextRegions – collection of TextRegion objects

·TrainingBlocks – collection of TrainingBlock objects

·TrainingDefinitions – collection of TrainingDefinition objects

·TrainingFields – collection of TrainingField objects

·TrainingImageObjects – collection of TrainingImageObject objects

·TrainingPages – collection of TrainingPage objects

·VerificationGroup – collection of VerificationObject objects

·BlocksCollection – collection of blocks

·DocumentsCollection – collection of documents

·FieldValuesCollection – collection of field values

·IntsCollection – collection of Int type variables

·LicenseCollection – collection of licenses

·SectionDefinitionsCollection – collection of section definitions

·StringsCollection – collection of strings

Some of the collections are connectable objects. This means that they provide connection points of two types – one that uses a dispatch interface, and one that uses interface derived from IUnknown – and therefore support communication between ABBYY FlexiCapture Engine and its clients. See Working with Connectable Objects for details.

Working with collections in .NET

All collection interfaces are derived from IEnumerable interface. This means that you can use the foreach statement in C# (for each in Visual Basic) to manipulate collections. Note that working with collections using foreach has some specifics, e.g. enumerators cannot be used to modify the collection, but only to read the data in it. See remarks on msdn.microsoft.com.

cicon2 C# code

// We presume that the document contains some pages
...
foreach( var page in document.Pages ) {
// do something with the page
}

See also

ICollectionEvents


Working with Connectable Objects

Guided Tour > Advanced Techniques > Programming Aspects >

Working with Connectable Objects

Some of the objects in ABBYY FlexiCapture Engine are so-called "connectable objects". This means that they implement the IConnectionPointContainer interface. Connectable objects support communication between ABBYY FlexiCapture Engine and its clients.

Each of the ABBYY FlexiCapture Engine connectable objects provides connection points of two types – one that uses a dispatch interface, and one that uses interface derived from IUnknown. The dispatch interface is designed for automatic use in Visual Basic and similar environments, while the vtbl-based interface is suitable for use in C++.

In the table below you can find the list of connectable objects in ABBYY FlexiCapture Engine and corresponding callback interfaces (dispinterfaces):

Object | Callback Interface (Dispinterface)
Project (deprecated) Batch (deprecated) | IBatchEvents (DIBatchEvents)
AssemblingErrors Batches BatchTypes Blocks Documents FieldInstances Fields Pages RuleErrors TableColumns | ICollectionEvents (DICollectionEvents)
ScanManager | IScanManagerEvents (DIScanManagerEvents)

ABBYY FlexiCapture Engine client application that wants to receive notifications of certain events in ABBYY FlexiCapture Engine, should implement interfaces of specific type, and "advise" objects implementing these interfaces to the corresponding connectable objects. See details for your development tool below.

cicon2 Visual Basic .NET

For the Batch object the procedure will be the following:

1.Declare the event source object of the IBatchEvents_Event type WithEvents:

Public WithEvents eventsSource As FCEngine.IBatchEvents_Event

2.Implement the necessary methods of the IBatchEvents interface in the Sub similar to one of the following.

If you want to start and stop event handling at any time during program execution (using AddHandler and RemoveHandler statements):

Private Sub eventsSource_OnBatchProgress(ByVal Batch As FCEngine.IBatch, _
ByVal ProcessedItemsCount As Integer, _
ByVal RemainingItemsCount As Integer)
...
End Sub

or simply specify that this procedure handles a particular event (use the Handles keyword when defining):

Private Sub eventsSource_OnBatchProgress(ByVal Batch As FCEngine.IBatch, _
ByVal ProcessedItemsCount As Integer, _
ByVal RemainingItemsCount As Integer) Handles eventsSource.OnBatchProgress
...
End Sub

3.Initialize the event source with the Batch object:

Dim project As FCEngine.IProject
project = Engine.OpenProject("D:\Sample.fcproj")
Dim batch As FCEngine.IBatch
batch = project.Batches.AddNew("TestBatch")
eventsSource = batch

4.Connect the implemented event handler to the event source, use the Batch object for processing, then disconnect the handler:

AddHandler eventsSource.OnBatchProgress, AddressOf Me.eventsSource_OnBatchProgress
batch.Recognize(Nothing, FCEngine.RecognitionModeEnum.RM_ReRecognizeMinimal, Nothing)
RemoveHandler eventsSource.OnBatchProgress, AddressOf Me.eventsSource_OnBatchProgress

or simply use the Batch object for processing if you define the event handling methods with Handles keyword:

batch.Recognize(Nothing, FCEngine.RecognitionModeEnum.RM_ReRecognizeMinimal, Nothing)
cicon2 C++ (COM)

In C++ you need to implement necessary interface, obtain a connection point, and "advise" object implementing the interface to the corresponding connectable objects. We will use the Batch object as an example.

1.Implement the IBatchEvents interface. As it is derived from the IUnknown interface, the client object should also implement the IUnknown methods:

class CProjectEventsListener : public IBatchEvents {
public:
...
// Provide IUnknown methods simple implementation. They may also be
// implemented by inheritance from some standard class with COM support
ULONG AddRef();
ULONG Release();
HRESULT QueryInterface(REFIID riid, void** ppvObject)
{
if( ppvObject == 0 )
return E_INVALIDARG;
if( riid == __uuidof(IBatchEvents) ) {
*ppvObject = static_cast<IBatchEvents*>( this );
} else if( riid == IID_IUnknown ) {
*ppvObject = static_cast<IUnknown*>( this );
} else {
*ppvObject = 0;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
// Provide IBatchEvents methods implementation
HRESULT OnBatchProgress(IBatch*, int, int);
HRESULT OnPageProgress(IPage*, int);
HRESULT OnPageRectProcessed(IPage*, int, int, int, int, int);
HRESULT OnProcessMessages(IBatch*, VARIANT_BOOL*);
HRESULT OnRecognizerTip(IPage*, int);
HRESULT OnError(IPage*, BSTR, VARIANT_BOOL*);
HRESULT OnWarning(IPage*, BSTR, BSTR, int, int*);
};

2.Then the CProjectEventsListener class may be used to receive notifications from the Batch object. Advise this object to the notifications source (error handling is omitted):

// Suppose that we have already received the Batch object
IBatch* batch;
// Query for IConnectionPointContainer on the Batch object
IConnectionPointContainer* pContainer=0;
batch->QueryInterface(IID_IConnectionPointContainer, (void**)&pContainer);
// Obtain a pointer to the IConnectionPoint interface on a connection point within the connectable object
IConnectionPoint* pPoint=0;
pContainer->FindConnectionPoint(__uuidof(IBatchEvents),
&pPoint);
// Establish a connection between the CProjectEventsListener class and the connection point
CProjectEventsListener listener;
IUnknown* listenerUnknown=0;
listener.QueryInterface(IID_IUnknown, (void**)&listenerUnknown);
// Advise listener to the notifications source
DWORD cookie; // A variable to store the cookie returned from the IConnectionPoint::Advise method
pPoint->Advise(listenerUnknown, &cookie);
// Process the batch
...
// After notification, the listener is no longer needed and should be unadvised
pPoint->Unadvise(cookie);
cicon2 C#

C# procedure is similar to that of Visual Basic. Net. You need to implement necessary methods of the callback interface, initialize the event source with the required object, and connect the implemented event handlers to the event source. We will use the Batch object as an example.

1.Implement the necessary methods of the IBatchEvents interface:

private void eventSource_OnBatchProgress(FCEngine.IBatch Batch, int ProcessedItemsCount, int RemainingItemsCount)
{
...
}

2.Initialize the event source with the Batch object:

FCEngine.IProject project = Engine.OpenProject( "D:\\Sample.fcproj" );
FCEngine.IBatch batch = project.Batches.AddNew( "TestBatch" );
FCEngine.IBatchEvents_Event eventSource = batch as FCEngine.IBatchEvents_Event;

3.Connect the event handler to the event source, use the Batch object for processing, then disconnect the handler:

FCEngine.IBatchEvents_OnBatchProgressEventHandler batchOnProgressHandler =
new FCEngine.IBatchEvents_OnBatchProgressEventHandler( eventSource_OnBatchProgress );
eventSource.OnBatchProgress += batchOnProgressHandler;
...
eventSource.OnBatchProgress -= batchOnProgressHandler;

Refer to documentation on COM for a more detailed description of connectable objects.

See also

IBatchEvents

ICollectionEvents

IScanManagerEvents


Working with COM Interfaces from a Scripting Language

Guided Tour > Advanced Techniques > Programming Aspects >

Working with COM Interfaces from a Scripting Language

ABBYY FlexiCapture Engine 12 supports dynamic binding in COM interfaces: almost all ABBYY FlexiCapture Engine 12 interfaces are derived from IDispatch (the exceptions are some of the callback interfaces implemented on the client side).

Scripting languages (for example, VBScript and JScript) support only dynamic binding. Therefore, due to inheriting such interfaces from IDispatch the use of ABBYY FlexiCapture Engine API from these languages does not require additional efforts.

You may load the Engine object by using the FCEngine.InprocLoader or FCEngine.OutprocLoader objects. These objects support the IEngineLoader interface, which allows you to load and unload the Engine object. In the first case FlexiCapture Engine will be loaded as an in-process server in the current process, in the latter case it will be an out-of-process server in a work process.

For example, you can create the Engine object by using the JavaScript ActiveXObject function.

// create the loader object
var loader = new ActiveXObject( "FCEngine.InprocLoader" );
...
// get the Engine object
loader.CustomerProjectId = customerProjectId;
loader.LicensePath = licensePath;
loader.LicensePassword = licensePassword;
loader.AppDataPath = "";
var engine = loader.GetEngine();

In VBScript, use the CreateObject method:

' create loader object
Dim loader
Set loader = CreateObject( "FCEngine.InprocLoader" )
...
' get the Engine object
Dim engine
Set engine = loader.GetEngine

In Perl, use the CreateObject method:

# create the loader object
$loader = $WScript->CreateObject( 'FCEngine.InprocLoader' );
...
# get the Engine object
my $Engine = $loader->Load( );

After the Engine object is created, the other objects created by the methods of the Engine object named "Create..." or "Load..." can now be created and used directly from the scripting language.

An examples illustrating the use of ABBYY FlexiCapture Engine in scripting languages can be found in Samples\Hello (JScript, VBScript, Perl) (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder > Hello (JScript, VBScript, Perl)).

See also

Description of ABBYY FlexiCapture Engine Samples


Using ABBYY FlexiCapture Engine in Delphi

Guided Tour > Advanced Techniques > Programming Aspects >

Using ABBYY FlexiCapture Engine in Delphi

note Note: The sample is deprecated because of low frequency of Delphi usage. The sample will be removed in future versions.

This section deals with certain peculiarities of using ABBYY FlexiCapture Engine in Delphi.

Creating the Object Pascal Wrapper Unit

In order to use ABBYY FlexiCapture Engine 12 in Delphi, it is necessary to create the Object Pascal wrapper unit for the type library (the FCEngine_TLB.pas file). To generate the wrapper:

1.Run command prompt (cmd.exe) and go to the folder where the ABBYY FlexiCapture Engine 12 type library (FCEngine.tlb) is located.

2.Run the tlibimp utility with the following parameters:

tlibimp -O- -Cd- -C- -P+ -Pt+ FCEngine.tlb

This will generate the FCEngine_TLB.pas file.

3.Add FCEngine_TLB.pas to your project.

You need to regenerate FCEngine_TLB.pas each time you receive an updated version of ABBYY FlexiCapture Engine 12.

Using Engine loaders in Delphi 7

There is also an alternative way of using ABBYY FlexiCapture Engine in Delphi 7, for which you will not need to create the wrapper manually as described above. But this method is only suitable if you load the Engine object in your application using the Engine loaders.

1.Open your project and choose Project > Import Type Library.

2.In the dialog that opens choose ABBYY FlexiCapture Engine 12 Type Library in the list. Make sure that Generate Component Wrapper flag is turned on. Click Install.

note Note: An error at this stage may indicate that the system environment variable Path does not contain the necessary paths. Modify it to include the path to the mscoree.tlb file (generally it is C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727).

3.New components appear on the ActiveX tab of the Components palette — InprocLoader and OutprocLoader. You can add one of these components directly onto your form and use it to load the Engine object.

For example, you add the InprocLoader component onto your form. The following code will be added automatically:

uses FCEngine_TLB;
type
TForm1 = class(TForm)
InprocLoader1: TInprocLoader;
...
private
{ Private declarations }
public
{ Public declarations }
end;

In your implementation use the Load method of the InprocLoader object to load Engine:

engineLoader.Set_CustomerProjectId(GetCustomerProjectId);
engineLoader.Set_LicensePath(GetLicensePath);
engineLoader.Set_LicensePassword(GetLicensePassword);
engine := engineLoader.GetEngine();

When you no longer need FlexiCapture Engine functionality, unload the Engine using the Unload method of the loader object.

InprocLoader1.Unload;

Deinitialization of the Engine Object

If not all the objects which were created and used by the application have been deleted before the Engine object deinitialization, the "Engine deinitialization failed" exception is thrown. If all the objects have been deleted, the exception may be caused by the scavenger operation. In Delphi all objects with the nil value are deleted only after the exit from the procedure in which the objects were declared. Therefore, the entire ABBYY FlexiCapture Engine code must be inserted into a separate procedure, and this procedure must be called before the Engine object deinitialization.

note Note: You can use the StartLogging method of the Engine object to get the list of objects that have not been deleted.

ABBYY FlexiCapture Engine includes a simple Hello sample in Delphi. You can access this sample by selecting Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder > Hello (Delphi).

See also

Different Ways to Load the Engine Object


Using ABBYY FlexiCapture Engine in Java

Guided Tour > Advanced Techniques > Programming Aspects >

Using ABBYY FlexiCapture Engine in Java

Because Java is platform-independent, it has no special tools for integration with platform-dependent technologies such as COM. Instead, it provides a truly platform-independent but very low-level interface for integration with any native platform – Java Native Interface (JNI). Creating wrappers using JNI is not an easy task: you should write huge amount of code to implement wrappers for all necessary interfaces and methods. But there is no need to do it for FlexiCapture Engine. FlexiCapture Engine provides ready-to-use Java classes for the Engine library. These Java classes can be used directly from Java applications.

Adding FlexiCapture Engine library to a Java project

ABBYY FlexiCapture Engine includes the com.abbyy.FCEngine.jar file, which contains the Java class library for FlexiCapture Engine. You can find it in the Inc\Java folder. The path to this file can be specified in classpath parameter in the command line and in projects settings in different Java development environments. For example:

%JDK%\bin\Javac -classpath <path>/com.abbyy.FCEngine.jar Hello.java

%JDK% is the path to Java Development Kit.

Loading and unloading FlexiCapture Engine

To load the Engine object, you can use the static Engine class:

1.Use its Load method to load FlexiCapture Engine, and Unload method – to unload it. This way is identical to the standard way of loading and unloading the Engine object by means of InitializeEngine and DeinitializeEngine functions.

2.Use its CreateEngineInprocLoader or CreateEngineOutprocLoader methods to load Engine by means of COM. See the description of the IEngineLoader interface for details. If you use the CreateEngineOutprocLoader method for loading, you do not need to call IWorkProcessControl::SetParentProcessId method, because it is done automatically.

The following code sample illustrates the use of FlexiCapture Engine in Java.

import com.abbyy.FCEngine.*;
public class Hello {
public static void main( String[] args )
{
try {
// Load the Engine
IEngineLoader engineLoader = Engine.GetEngineLoader( SamplesConfig.GetDllPath() );
engineLoader.setCustomerProjectId( SamplesConfig.GetCustomerProjectId() );
engineLoader.setLicensePath( SamplesConfig.GetLicensePath() );
engineLoader.setLicensePassword( SamplesConfig.GetLicensePassword() );
IEngine engine = engineLoader.GetEngine();
try{
// Create and configure FlexiCaptureProcessor
IFlexiCaptureProcessor processor = engine.CreateFlexiCaptureProcessor();
processor.AddDocumentDefinitionFile( "...\\Invoice_eng.fcdot" );
...
} finally {
Engine.Unload();
}
} catch( Exception ex ) {
trace( ex.getMessage() );
}
}
...
}

For working with the Engine object created via an engine loader, the Engine class provides the methods which call the corresponding COM functions to marshal the interface pointer across threads:

Method

Signature

Comment

MarshalInterface

long MarshalInterface();

Calls the CoMarshalInterface COM function to marshal the IEngine interface. This method should be called on the thread where the engine was created, to ensure that the data needed for creating a proxy object on another thread will be available.

Returns the handle to the marshaling data.

UnmarshalInterface

IEngine UnmarshalInterface( long handle );

Calls the CoUnmarshalInterface COM function to unmarshal the IEngine interface, i.e. create a proxy object with which the client process will be able to interact in the same way as with the engine itself.

Takes the handle to the marshaling data (returned by the MarshalInterface method) as the input parameter and returns a pointer to the IEngine interface.

ABBYY FlexiCapture Engine includes a simple Hello sample in Java. You can access this sample by selecting Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Code Samples Folder > Hello (Java).

Calling methods with out-parameters

There are several methods in ABBYY FlexiCapture Engine API which have out-parameters that receive a new value after the method call and must be passed by reference. These parameters are marked in the type library and in descriptions of methods in this Developer's Help as [out] or [in, out].

When working with ABBYY FlexiCapture Engine in Java, you have to use a special Ref class to pass a parameter by reference. See examples below.

Example in which the out-parameters are passed by reference to the IReadStream::Read method:

cicon2 Sample code for out-parameters

public int Read( Ref _data, int count ) {
...
byte[] data = new byte[...];
_data.set( data );
}


Creating Document Definitions

Guided Tour > Advanced Techniques >

Creating Document Definitions

A Document Definition describes the location of document elements and indicates the fields to be used in data extraction.

Document Definitions can be obtained in one of two ways:

·A Document Definition may be part of an ABBYY FlexiCapture 12 project. When creating a Document Definition in ABBYY FlexiCapture, field properties are specified along with their range of values. Data export settings are also configured.

·A Document Definition may be created using methods provided by ABBYY FlexiCapture Engine.

Below are detailed instructions for creating Document Definitions using ABBYY FlexiCapture Engine.

A Document Definition can comprise any number of sections. The section of a Document Definition is a set of pages (or a single page) and fields on these pages which corresponds to a logically complete part of a document. Using ABBYY FlexiCapture Engine, you can create a simple Document Definition, which consists of a single section, or a compound Document Definition with several sections. The first two topics describe the creation of a simple Document Definition, while the third describes the creation of a compound Document Definition.

Creating a Document Definition from a FlexiLayout

A FlexiLayout is a formalized description of a semi-structured document which allows the program to detect image areas which correspond to data fields. FlexiLayouts are created with ABBYY FlexiLayout Studio and saved in *.afl files. FlexiLayouts can also be created via FlexiCapture Engine API. See details in Creating Document Definitions by Training.

To create a Document Definition from an *.afl file, use the CreateDocumentDefinitionFromAFL method of the Engine object. The created Document Definition will have one flexible section.

note Note: A FlexiLayout contains information on how to find data fields but does not specify the language of the data. However, recognition language is the required parameter for a Document Definition. Therefore you should pass the correct recognition language as a parameter of the creation method.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create a Document Definition from an *.afl file
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinitionFromAFL(L"C:\\Invoice_eng.afl", L"English");
// You can save the new Document Definition to a file or use it from memory

Creating a Document Definition from an XML Form Definition

An XML Form Definition (*.xfd) is a form in a special file format designed with ABBYY FormDesigner. It contains information about the location of data fields.

To create a Document Definition from an *.xfd file, use the CreateDocumentDefinitionFromXFD method of the Engine object. The created Document Definition will have one fixed section.

note Note: XML Form Definition does not specify the language of the data (which is a required parameter for a Document Definition). Therefore you should pass the correct recognition language as a parameter of the creation method.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create a Document Definition from an *.xfd file
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinitionFromXFD(L"C:\\Invoice_eng.xfd", L"English");
// You can save the new Document Definition to a file or use it from memory

Creating a compound Document Definition

1.Create an empty Document Definition using the CreateDocumentDefinition method of the Engine object.

2.Set the language to be used with this Document Definition during recognition. Use the DefaultLanguage property of the created DocumentDefinition object.

3.Create a new fixed section from an XFD file:

1.Set the default text type using the DefaultTextType property of the DocumentDefinition object.

2.Add the new section into the Document Definition with the help of the AddNew method of the SectionDefinitions subobject of the DocumentDefinition object.

3.Load the XML Form Definition into this new section using the LoadXFDDescription method of the new SectionDefinition object.

4.Create a new flexible section from an AFL file:

1.Set the default text type using the DefaultTextType property of the DocumentDefinition object.

2.Add the new section into the Document Definition with the help of the AddNew method of the SectionDefinitions subobject of the DocumentDefinition object.

3.Load ABBYY Flexible Layout into this new section using the LoadFlexibleDescription method of the new SectionDefinition object.

5.Repeat steps 3 and/or 4 if necessary.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinition();
// Set the default language
FCEngine::ILanguagePtr language = Engine->PredefinedLanguages->FindLanguage(L"English");
documentDefinition->DefaultLanguage = language;
// Create a new fixed section from an *.xfd file
documentDefinition->DefaultTextType = FCEngine::TT_Handprinted;
FCEngine::ISectionDefinitionPtr sectionDefinition1 = documentDefinition->Sections->AddNew(L"Banking");
sectionDefinition1->LoadXFDDescription(L"C:\\Banking_eng.xfd");
// Create a new flexible section from an *.afl file
documentDefinition->DefaultTextType = FCEngine::TT_Normal;
FCEngine::ISectionDefinitionPtr sectionDefinition2 = documentDefinition->Sections->AddNew(L"Invoice");
sectionDefinition2->LoadFlexibleDescription(L"C:\\Invoice_eng.afl");

Setting additional properties

To improve the quality of recognition, you may configure the types of field values:

1.For a section of the created Document Definition, get a set of its field definitions. Use the Fields property of the SectionDefinition object.

2.Find the necessary field definition. Note that fields may be simple (without an internal structure) or composite, such as a table field where each cell can be viewed as a separate subordinate field of the table. Therefore, to iterate through all field definitions of the section definition, it is not enough to iterate through all the elements of the ISectionDefinition::Fields collection, you should also check if the field is composite and access its child fields (see the IFieldDefinition::Children property).

3.Set the type of the field value using the ValueType property of the FieldDefinition object.

Sometimes it is not convenient to specify any particular type of field value as this restricts field values. E.g. if a user enters incorrect data into such a field, this will produce an error. To avoid specifying some special type of field value, you may create a special language for the field and set its parameters for recognition of a specific text. For details see Setting up Recognition Languages.

You may also set other recognition parameters using the IFieldDefinition::RecognitionParams property.

Checking Document Definitions

Check the created Document Definition after you have set all the properties. Use the Check methods of the DocumentDefinition object and SectionDefinition subobjects. These methods check a Document Definition for errors. If there are errors, the lists of errors are available in the Errors properties of the DocumentDefinition object and SectionDefinition subobjects.

Loading and saving Document Definitions

The DocumentDefinition object supports the ICustomStorage interface. This means that the DocumentDefinition object allows saving its status to a custom storage location. You may load a Document Definition from a file or from a stream in memory, change it, and then save it in a file or in memory.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinition();
// Load a Document Definition from a file
FCEngine::ICustomStoragePtr customStorage = documentDefinition;
customStorage->LoadFromFile(L"C:\\Invoice_eng.fcdot");
// Modify if required and check the modified version
documentDefinition->Check();
// Save the modified Document Definition
customStorage->SaveToFile(L"C:\\Invoice_eng_COPY.fcdot");

See also

DocumentDefinition

Creating Document Definitions by Training

See sample: FlexiCapture Engine Code Snippets


Working with Regular Expressions

Guided Tour > Advanced Techniques >

Working with Regular Expressions

Regular expressions are used for simple languages to define what words are allowed in a language and what are not.

The ABBYY FlexiCapture Engine regular expression alphabet is described in the following table:

Item name | Conventional regular expression sign | Usage examples and explanations
Any character | * | "c"*"t" — allows such words as cat, cot, etc.
Character from a character range (also can be used as ) | [] | [b-d]"ell" — denotes words like “bell”, “cell”, “dell” [ty]"ell" — denotes words “tell” and “yell”
Character out of a character range | [^] | [^y]"ell" — denotes words like “dell”, “cell”, “tell”, but forbids “yell” [^n-s]"ell" — denotes words like “bell”, “cell”, but forbids “nell”, “oell”, “pell”, “qell”, “rell”, and “sell"
Letter or digit | X | X — allows any standalone number or letter
Letter | C | C"ot" — allows such words as Rot, pot, cot, Dot, mot, etc
Capital letter | A | A"ot" — allows such words as Rot, Cot, Mot, Dot, etc
Small letter | a | a"ot" — allows such words as rot, cot, mot, dot, etc.
Digit | N | N"th" — allows such words as 5th, 4th, 6th, etc.
Any number of repetitions (applies to the expression or subexpression on the left) | {-} | [AB74]{-} — allows any combinations of characters A, B, 7, 4 of any length.
Number of repetitions n | {n} | N{2}"th" — allows such words as 25th, 84th, 11th, etc..
From n to m repetitions | {n-m} | N{1-3}"th" — allows such words as 5th, 84th, 111th, etc.
From 0 to n repetitions | {-n} | N{-2}"th" — allows such words as 84th, 5th, etc.
From n repetitions and more | {n-} | N{2-}"th" — allows such words as 25th, 834th, 311th, 34576th, etc.
Subexpression | () |
OR | | | "c"(a|u)"t" — denotes words “cat” and “cut"
Space | [\s] |
Hyphen symbol | [\-] |
Slash symbol | [\\] |
Word from dictionary | @(Dictionary) | The Dictionary parameter sets the path to the user dictionary from which words must be taken. Backslahes in the path must be doubled. For example: @(D:\\MyFolder\\MyDictionary.amd).

Examples of regular expressions:

1. Postal code: [0-9]{6}. A sample value: "142172"

2. Zip code (USA): [0-9]{5}("-"[0-9]{4}){-1}.

Sample values: "55416", "33701-4313"

3. Income: N{4-8}[,]N{2}. Sample values: "15000,00", "4499,00"

4. Month in the numerical form: ((|"0")[1-9])|("10")|("11")|("12"). Sample values: "4", "05", "12"

5. Fraction: ("-"|)([0-9]{1-})(|(("."|",")([0-9]{1-}))). Sample values: "1234,567", "0.99", "100,0", "-345.6788903"

6. E-mail: [A-Za-z0-9_]{1-}(("."|"-")[A-Za-z0-9_]{1-}){-3}"@"[A-Za-z0-9_]{1-}(("."|"-")[A-Za-z0-9_]{1-}){-4}"."([A-Za-z]{2-4}|"asia"|"museum"|"travel"|"example"|"localhost") ". Sample values: "support@abbyy.com", "my-name@company.org.ru", "info@gallery.museum"

See also

ISimpleLanguage::RegularExpression


Setting Up Recognition Languages

Guided Tour > Advanced Techniques >

Setting Up Recognition Languages

One of the main recognition parameters is the language to be used for recognition. The recognition languages can be specified for the entire document and for individual data fields.

Recognition language for the entire document

The recognition language for the entire document is specified in the Document Definition. To specify the recognition language for a document, use the IDocumentDefinition::DefaultLanguage property.

note Note: Only the Document Definitions which do not belong to any project can be modified. A Document Definition of a project cannot be changed, and therefore you cannot change the recognition language of such a Document Definition.

The recognition language which is used for the entire document is usually one of the predefined languages, or a group of such languages. Predefined languages are the languages supported in ABBYY FlexiCapture Engine by default. The collection of available predefined languages represented by the PredefinedLanguages object is accessible via the PredefinedLanguages property of the Engine object. It is a collection of Language objects.

To change the language used for recognition of a document, do the following:

1.Find the necessary predefined language in the collection of available languages. Use the FindLanguage method of the PredefinedLanguages subobject of the Engine object. The predefined languages are identified by their internal names. For the list of the internal names of the predefined languages see Predefined Languages in ABBYY FlexiCapture Engine.

2.Assign the received Language object to the IDocumentDefinition::DefaultLanguage property.

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinition();
// Set default language
FCEngine::ILanguagePtr language = Engine->PredefinedLanguages->FindLanguage(L"English");
documentDefinition->DefaultLanguage = language;

Languages may be simple (e.g. English, Russian), or compound (composed of several simple languages). See the Type property of the Language object. The Language object exposes methods which cast it to a type-specific interface and thereby provide access to the extended attributes of a language of specific type.

Changing the recognition language for individual fields

The recognition language can be changed for an individual field by setting the recognition parameters of this field. The IFieldDefinition::RecognitionParams property provides access to the parameters of field recognition. The recognition language can be set for text fields only (IFieldDefinition::Type = FT_TextField).

To tune the recognition parameters of a text field, receive the RecognitionParams object as a TextRecognitionParams object. (Use the AsTextParams method of the RecognitionParams object.)

cicon2 To use a group of languages for recognition...

1.Create a group language with the CreateEmbeddedLanguage method of the TextRecognitionParams object. Pass an LT_Group constant as the first parameter of this method.

2.Obtain the created object as a GroupLanguage object using the AsGroupLanguage method of the Language object.

3.Add languages to this group language. Use the Add method of the GroupLanguage object.

4.Assign the created language to the Language property of the TextRecognitionParams object.

C++ (COM)

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinitionFromAFL(L"C:\\Invoice_eng.afl", L"English");
// Find the necessary field definition
FCEngine::IFieldDefinitionPtr fieldDefinition;
...
// Create a group language
FCEngine::ITextRecognitionParamsPtr textParams = fieldDefinition->RecognitionParams->AsTextParams();
FCEngine::ILanguagePtr language = textParams->CreateEmbeddedLanguage(FCEngine::LT_Group, 0);
// Add languages to the group language
language->AsGroupLanguage()->Add (Engine->PredefinedLanguages->FindLanguage(L"English"));
language->AsGroupLanguage()->Add (Engine->PredefinedLanguages->FindLanguage(L"Russian"));
// Use the created language for recognition
textParams->Language = language;
cicon2 To use regular expressions for recognition...

1.Create a simple language with the CreateEmbeddedLanguage method of the TextRecognitionParams object. Pass an LT_Simple constant as the first parameter of this method.

2.Obtain the created object as a SimpleLanguage object using the AsSimpleLanguage method of the Language object.

3.The created simple language is empty. You must specify its alphabet. Pass the set of alphabet letters to the LetterSet property of the SimpleLanguage object with an LLS_Alphabet constant as a parameter.

4.Set the regular expression via the RegularExpression property of the SimpleLanguage object. The semantics of ABBYY FlexiCapture regular expressions is described in Working with Regular Expressions.

5.Assign the created language to the Language property of the TextRecognitionParams object.

C++ (COM)

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinitionFromAFL(L"C:\\Invoice_eng.afl", L"English");
// Find the necessary field definition
FCEngine::IFieldDefinitionPtr fieldDefinition;
...
// Create a simple language
FCEngine::ITextRecognitionParamsPtr textParams = fieldDefinition->RecognitionParams->AsTextParams();
FCEngine::ILanguagePtr language = textParams->CreateEmbeddedLanguage(FCEngine::LT_Simple, 0);
// Set the alphabet and regular expression
language->AsSimpleLanguage()->put_LetterSet(FCEngine::LLS_Alphabet,L"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
language->AsSimpleLanguage()->put_RegularExpression(L"[A-Z]{1-}");
// Use the created language for recognition
textParams->Language = language;
cicon2 To use user dictionaries for recognition...

1.Create a simple language with the CreateEmbeddedLanguage method of the TextRecognitionParams object. Pass an LT_Simple constant as the first parameter of this method. You may create this language on the basis of a predefined language. If you do not use any predefined language as a prototype, you must then set the alphabet of the language.

2.Obtain the created object as a SimpleLanguage object using the AsSimpleLanguage method of the Language object.

3.Set the UseUserDefinedDictionary property of the SimpleLanguage object to TRUE. You may use both a user dictionary and a predefined dictionary for recognition. If you want to use only a user dictionary, set the UsePredefinedDictionary property to FALSE.

4.Receive the user dictionary via the UserDefinedDictionary property of the SimpleLanguage object. The user dictionary is represented by the Dictionary object. With the help of methods and properties of this object you may add words to the dictionary, delete words from it, and load an existing dictionary via the provided user interface.

5.Assign the created language to the Language property of the TextRecognitionParams object.

C++ (COM)

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinitionFromAFL(L"C:\\Invoice_eng.afl", L"English");
// Find the necessary field definition
FCEngine::IFieldDefinitionPtr fieldDefinition;
...
// Create a simple language
FCEngine::ITextRecognitionParamsPtr textParams = fieldDefinition->RecognitionParams->AsTextParams();
FCEngine::ILanguagePtr language = textParams->CreateEmbeddedLanguage(FCEngine::LT_Simple, Engine->PredefinedLanguages->FindLanguage (L"English"));
// Allow the user dictionary and edit it
language->AsSimpleLanguage()->UseUserDefinedDictionary = VARIANT_TRUE;
FCEngine::IDictionaryPtr dictionary = language->AsSimpleLanguage()->UserDefinedDictionary;
dictionary->AddWord(L"one",100);
dictionary->AddWord(L"two",100);
dictionary->AddWord(L"three",100);
// Use the created language for recognition
textParams->Language = language;
cicon2 To use a special recognition language for a data type...

It is not always convenient to specify the type of field value (IFieldDefinition::ValueType) as this restricts field values. E.g. if a user enters incorrect data into such field, this will produce an error. To avoid specifying some special type of field value, you may:

1.Create a simple language with the CreateEmbeddedLanguageByDataType method of the TextRecognitionParams object. Pass a FieldValueTypeEnum constant as the parameter of this method.

2.Set the necessary parameters of the created language.

3.Assign the created language to the Language property of the TextRecognitionParams object.

C++ (COM)

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinitionFromAFL(L"C:\\Invoice_eng.afl", L"English");
// Find the necessary field definition
FCEngine::IFieldDefinitionPtr fieldDefinition;
...
// Create a language for the data type and configure this language
FCEngine::ITextRecognitionParamsPtr textParams = fieldDefinition->RecognitionParams->AsTextParams();
FCEngine::ILanguagePtr language = textParams->CreateEmbeddedLanguageByDataType(FCEngine::FVT_DateTime);
...
// Use the created language for recognition
textParams->Language = language;

See also

Language

PredefinedLanguages


Setting Up a Custom Image Source

Guided Tour > Advanced Techniques >

Setting Up a Custom Image Source

You can specify a custom image source when processing documents with the FlexiCapture processor.

By default, prior to processing, source images are added into the internal processing queue as references to the corresponding files (push model). However, if required, you can easily implement your own external image queue, which will either return references to files on demand (pull model) or, instead of references to files, provide the source images as a stream in memory (working with memory).

To specify a custom image source, use the SetCustomImageSource method of the FlexiCaptureProcessor object. This method takes as the input parameter a reference to the IImageSource interface which implements a custom image source.

cicon2 C# code

// Procedure which sets a custom image source
// Create an instance of the FlexiCapture processor
...
// Specify the custom image source
processor.SetCustomImageSource( new MyImageSource() );
// Run the processing loop
...
// Sample implementation of a custom image source
class MyImageSource : IImageSource
{
...
// IImageSource ///////////////////
public string GetName() { return "Sample Image Source"; }
public IImage GetNextImage() { return null; }
public IFileAdapter GetNextImageFile()
{
if( hasMoreImages() ) {
return new FileAdapter( … );
}
return null;
}
class FileAdapter : IFileAdapter
{
// IFileAdapter ////////////////////
public FileMarshallingTypeEnum GetMarshallingType()
{
if( marshalByValue ) {
return FileMarshallingTypeEnum.FMT_MarshalByValue;
}
return FileMarshallingTypeEnum.FMT_MarshalByReference;
}
public string GetFileReference()
{
if( marshalByValue ) {
// Here we could use any string which is stored as the origin of
// the image file and not otherwise interpreted. An empty string would
// also be valid. In this sample, we return a reference to some source file
return fileReference;
} else {
// In this sample, we use the path in the file system, but we could
// use any kind of reference (for example, http://myimagesource/001.tif)
return fileReference;
}
}
public IReadStream GetFileStream()
{
if( marshalByValue ) {
return new ReadStream( … );
} else {
// This method is called only if marshaled by value
assert( false );
return null;
}
}
class ReadStream : IReadStream
{
public uint Read( IntPtr data, uint count )
{
// Read requested bytes count if marshaling by value
...
return readBytes;
}
}
};
};

Image preprocessing

Images in an external queue can be preprocessed before they are passed to the FlexiCapture processor for recognition . This can be done in several different ways, for example:

·In memory, using ABBYY FlexiCapture Engine tools and user algorithms

Images can be loaded to memory and preprocessed using methods of the ImageProcessingTools object and user algorithms.

In this case you should implement the GetNextImage method of the IImageSource interface. Using the ImageProcessingTools object, you can open an image as the ImageFile object and obtain its separate pages as the Image objects. These image pages can be preprocessed using a method of the ImageProcessingTools object or using your own algorithm. The preprocessed image pages are then passed to the FlexiCapture processor for recognition.

cicon2 C# code

// Sample implementation of a custom image source
class CustomPreprocessingImageSource : IImageSource
{
public CustomPreprocessingImageSource( IEngine engine )
{
fileNames = new Queue();
imageTools = engine.CreateImageProcessingTools();
}
public void AddImageFile( string filePath )
{
fileNames.Enqueue( filePath );
}
// IImageSource ///////////////////
public string GetName() { return "Custom Preprocessing Image Source"; }
public IFileAdapter GetNextImageFile() { return null; } // This sample source does not use this feature
public IImage GetNextImage()
{
while( true ) {
if( imageFile == null ) {
if( fileNames.Count > 0 ) {
imageFile = imageTools.OpenImageFile( (string)fileNames.Dequeue() );
nextPageIndex = 0;
} else {
return null;
}
}
assert( imageFile != null );
if( nextPageIndex < imageFile.PagesCount ) {
IImage nextPage = imageFile.OpenImagePage( nextPageIndex++ );
// Here you can apply any required preprocessing
// ...
return nextPage;
} else {
imageFile = null;
continue;
}
}
}
IImageProcessingTools imageTools;
Queue fileNames;
IImageFile imageFile;
int nextPageIndex;
};

·Using a third-party utility to preprocess image files

You can use a utility which performs some processing on image files, and then pass the preprocessed files to the FlexiCapture processor for recognition.

In this case you should implement the GetNextImageFile method of the IImageSource interface as follows. The method should take a source image file, use the third-party utility to perform the image preprocessing, and return the preprocessed image file. The preprocessed file is then passed to the FlexiCapture processor for recognition.

·Using selective preprocessing

This approach can be used, for example, if you need to preprocess only some of the images from the queue. In this case you can implement both the GetNextImage and GetNextImageFile method. You can return the preprocessed images via the GetNextImage method, and all other images via the GetNextImageFile method. The FlexiCapture processor calls the GetNextImage method before the GetNextImageFile method.

See also

Processing with a Customizable Processor Object

FlexiCaptureProcessor


Custom Resolution of References

Guided Tour > Advanced Techniques >

Custom Resolution of References

Custom resolution of references can be used when processing documents with the FlexiCapture processor.

By default, string references to Document Definitions, images, etc. are interpreted as references to files in the file system. However, if required, the user may define his own object (Reference Manager) which will resolve references either as a path to a file in the local file system or as the binary representation of the requested object in the form of a stream in memory. This approach may be used to organize work with a remote storage location accessed using any protocol.

To set custom reference manager, use the SetReferenceManager method of the FlexiCaptureProcessor object. This method takes as the input parameter a reference to the IReferenceManager interface which implements a custom reference manager.

cicon2 C# code

// Procedure which sets a custom reference manager
// Create an instance of the FlexiCapture processor
...
// Set the custom reference manager
processor.SetReferenceManager( new MyReferenceManager() );
// Add Document Definitions
processor.AddDocumentDefinitionFile( "http://MyServer/Templates/Invoice.fcdot" );
...
// Add images to recognize (you can use a custom image source providing references to image files
// which will also be resolved by your reference manager)
processor.AddImageFile( "http://MyServer/Images/001.tif" );
// Run processing loop
...
// Sample implementation of a custom reference manager
class SampleReferenceManager : IReferenceManager
{
public IFileAdapter ResolveReference ( string fileReference )
{
// You can return a local path to the (downloaded) file or a stream in memory
// for the provided reference
return new FileAdapter( … );
}
class FileAdapter : IFileAdapter
{
// IFileAdapter ////////////////////
public FileMarshallingTypeEnum GetMarshallingType()
{
if( marshalByValue ) {
return FileMarshallingTypeEnum.FMT_MarshalByValue;
}
return FileMarshallingTypeEnum.FMT_MarshalByReference;
}
public string GetFileReference()
{
if( marshalByValue ) {
// Here we could use any string which is stored as the origin of
// the image file and not otherwise interpreted. An empty string would
// also be valid. In this sample, we return a reference to some source file
return fileReference;
} else {
// In this sample, we use the path in the file system, but we could
// use any kind of reference (for example, http://myimagesource/001.tif)
return fileReference;
}
}
public IReadStream GetFileStream()
{
if( marshalByValue ) {
return new ReadStream( … );
} else {
// This method is called only if marshaled by value
assert( false );
return null;
}
}
class ReadStream : IReadStream
{
public uint Read( IntPtr data, uint count )
{
// Read requested bytes count if marshaling by value
...
return readBytes;
}
}
};
}

See also

Processing Using a Customizable Processor Object

FlexiCaptureProcessor


Creating Filters for Special Image Preprocessing

Guided Tour > Advanced Techniques >

Creating Filters for Special Image Preprocessing

ABBYY FlexiCapture Engine provides a large variety of image preprocessing tools. You can access these tools using the methods of the ImageProcessingTools object.

This section describes the most scalable tool, which allows you to create different filters based on frequency domain transform. With this tool you can change an image in many different ways, for example, equalize brightness of the image, extract background layer, pull out characters of specified size. This is done via the ApplyFrequencyTransform method.

The method applies a frequency domain transform to an image. Let's see how frequency domain transform is performed:

1.An image is split on several layers of different level of detail. At the first level there are separate pixels. At each next level the size of details is doubled, so that the size of details on the Nth level is 2N pixels. The number of levels is specified in the NumberOfLevels property of the FrequencyTransformParams object, which is passed to the ApplyFrequencyTransform method as a parameter. You can select the number of levels depending on the size of your image and the size of details you want to capture. The number of levels cannot be more than 10.

2.For each level, either the operation of multiplication on some coefficient, or the operation of autocontrast is applied. If you want to smooth out details of some size, you should select operation of multiplication. If you want to pull out some details, select operation of autocontrast. Which operation should be applied is specified by the Type property of the FrequencyTransformParams object.

3.The coefficient of multiplication or of autocontrast is specified in the CoefficientAtLevel property of the FrequencyTransformParams object. It can be any value in range from 0.0 to 1.0. For autocontrast operation, the value 0.0 does not change the level, the value 1.0 means maximum contrast of the level. For multiplication operation, the value 0.0 removes all details of the level (maximum smoothness), the value 1.0 does not change the level.

4.Then the layers are put together again.

Below are some examples of how it can be used.

Equalizing brightness

You can equalize brightness of an image, for example, like on this image:

Do the following:

1.Create the FrequencyTransformParams object using the CreateFrequencyTransformParams method of the ImageProcessingTools object.

2.To smooth out details, select transformation by multiplication: set the Type property of the created object to FTT_MultiplyByCoefficient.

3.Set the number of levels of detail in the NumberOfLevels property.

4.Multiply by 0.0 the levels upper then the Nth level. The size of details on the Nth level should be a lot more than the size of useful details. For example, if the size of characters is 20 pixels, then the size of 27=128 pixels is enough big size of details and you can select N equal to 7.

5.Apply the created frequency domain transform: call the ApplyFrequencyTransform method with the created parameters.

cicon2 C# code

var transformParams = imageTools.CreateFrequencyTransformParams();
transformParams.Type = FrequencyTransformTypeEnum.FTT_MultiplyByCoefficient;
transformParams.NumberOfLevels = 10;
for( int i = 0; i < transformParams.NumberOfLevels; i++ ) {
transformParams.set_CoefficientAtLevel( i, 1.0 );
}
for( int i = 7; i < transformParams.NumberOfLevels; i++ ) {
transformParams.set_CoefficientAtLevel( i, 0.0 );
}
page = imageTools.ApplyFrequencyTransform( page, transformParams );

Pulling out characters of specified size

There is a way to improve quality of recognition of the characters of necessary size. You can pull out such characters, like on this image:

Do the following:

1.Create the FrequencyTransformParams object using the CreateFrequencyTransformParams method of the ImageProcessingTools object.

2.To pull out the characters, select autocontrast transformation: set the Type property of the created object to FTT_AutocontrastByCoefficient.

3.Set the number of levels of detail in the NumberOfLevels property.

4.Select the value of autocontrast coefficient equal to 0.0 for each level except those of necessary detail size. For example, if the size of characters is 12 pixels, set coefficients to 0.0 for each level except 3rd and 4th.

5.Apply the created frequency domain transform: call the ApplyFrequencyTransform method with the created parameters.

cicon2 C# code

var transformParams = imageTools.CreateFrequencyTransformParams();
transformParams.Type = FrequencyTransformTypeEnum.FTT_AutocontrastByCoefficient;
transformParams.NumberOfLevels = 10;
for( int i = 0; i < transformParams.NumberOfLevels; i++ ) {
transformParams.set_CoefficientAtLevel( i, 0.0 );
}
transformParams.set_CoefficientAtLevel( 3, 1.0 );
transformParams.set_CoefficientAtLevel( 4, 1.0 );
page = imageTools.ApplyFrequencyTransform( page, transformParams );

Extracting background layer

You can extract background of the image, like on this picture:

Do the following:

1.Create the FrequencyTransformParams object using the CreateFrequencyTransformParams method of the ImageProcessingTools object.

2.To smooth out all details, select transformation by multiplication: set the Type property of the created object to FTT_MultiplyByCoefficient.

3.Set the number of levels of detail in the NumberOfLevels property.

4.Select the value of multiplication coefficient equal to 0.0 for each level. In this case, details of all sizes will be removed from the image.

5.Apply the created frequency domain transform: call the ApplyFrequencyTransform method with the created parameters.

cicon2 C# code

var transformParams = imageTools.CreateFrequencyTransformParams();
transformParams.Type = FrequencyTransformTypeEnum.FTT_MultiplyByCoefficient;
transformParams.NumberOfLevels = 10;
for( int i = 0; i < transformParams.NumberOfLevels; i++ ) {
transformParams.set_CoefficientAtLevel( i, 0.0 );
}
page = imageTools.ApplyFrequencyTransform( page, transformParams );

You can find more examples in the Image Preprocessing sample code.

See also

ImageProcessingTools


Working with Recognized Data

Guided Tour > Advanced Techniques >

Working with Recognized Data

After recognition, an ABBYY FlexiCapture Engine document (the Document object) contains a set of pages with recognized blocks on them and a set of fields. The blocks contain the data received after recognition, while the fields contain the recognized data, to which the rules defined in the Document Definition were applied. For this reason, the content of the blocks may differ from the values of the corresponding fields.

How to find a field

A collection of document sections (IDocument::Sections) usually contains one or several Field objects. However, these are not all of the fields of the document. The fields in this collection are sections of the document. These sections have child fields. Each child field can be either a group of fields (and have its own child fields) or a simple field (without child fields). The document itself can be considered as the topmost-level field which contains all the data fields of the document. To access the child fields of a complex field, use the IField::Children property.

A field may have several instances. Field instances are fields that occur several times in the form and describe several variants of the same object, e.g. several telephone numbers or addresses of one person, several table rows of one consignment note, etc. To receive a collection of instance fields, use the IField::Instances property. This collection will contain a set of fields of the same type as the container field.

When working with the recognized data of a document, you must take into account the fact that the document may have a complex tree-like structure, i.e. it may consist of sections, the sections may contain fields and groups of fields, and any of these may re-occur multiple times. Below is a sample of how to go through the entire document tree, visiting every field and every instance of the repeating items. Notice that the collection of instances is checked first to determine if the item is repeating, after that the collection of children is checked to determine if the item is a container of fields:

cicon2 C++ (COM) code

// Receive a Document object as a Field object
FCEngine::IDocumentPtr document;
FCEngine::IFieldPtr docAsField = document;
// Traverse the tree of document fields
recursiveProcessWithChildren (docAsField);
void recursiveProcessWithChildren (FCEngine::IFieldPtr& node)
{
recursiveProcessInstancesAndChildren( node );
}
void recursiveProcessWithChildren( FCEngine::IFieldPtr& node, int index )
{
recursiveProcessInstancesAndChildren( node );
}
void recursiveProcessInstancesAndChildren (FCEngine::IFieldPtr& node)
{
if (node->Instances != 0)
{
FCEngine::IFieldInstancesPtr instances = node->Instances;
for( int i = 0; i < instances->Count; i++ ) {
recursiveProcessWithChildren( instances->Item(i), i );
}
} else if( node->Children != 0 ) {
FCEngine::IFieldsPtr children = node->Children;
for( int i = 0; i < children->Count; i++ ) {
recursiveProcessWithChildren( children->Item(i) );
}
}
}

How to retrieve data from a field

Access to the recognized data of a field is provided by the IField::Value property. This property returns a reference to the FieldValue object. For composite fields, the property may return NULL. The FieldValue object contains recognized data in various formats. The formats in which the data can be presented are defined by the type of these data (IFieldValue::Type property). For example, you can receive recognized date and time in DATE format, as a string, or as a Text object.

The table below lists the ways of working with the recognized data of a field depending on their type. We presume that the field does not have instance fields (except for the table field).

Field type

Children

Field value

How to work with the field

FT_TextField

NULL

Field value of type FVT_Text

You can receive the value of the field:

·as a Text object – use the IFieldValue::AsText property

·as a string – use the IFieldValue::AsString property

cicon2 C++ (COM) code

// field of type FT_TextField
FCEngine::IFieldPtr childField;
FCEngine::IFieldValuePtr value = childField->Value;
if (value->Type == FCEngine::FVT_Text){
FCEngine::ITextPtr textValue = value->AsText;
_bstr_t stringValue = value->AsString;
}

FT_DateTimeField

NULL

Field value of type FVT_DateTime

You can receive the value of the field:

·as a DATE – use the IFieldValue::AsDateTime property

·as a Text object – use the IFieldValue::AsText property

·as a string – use the IFieldValue::AsString property

cicon2 C++ (COM) code

// field of type FT_DateTimeField
FCEngine::IFieldPtr childField;
FCEngine::IFieldValuePtr value = childField->Value;
if (value->Type == FCEngine::FVT_DateTime){
DATE dateValue = value->AsDateTime;
_bstr_t stringValue = value->AsString;
FCEngine::ITextPtr textValue = value->AsText;
}

FT_NumberField

NULL

Field value of type FVT_Number

You can receive the value of the field:

·as Double – use the IFieldValue::AsDouble property

·as Integer – use the IFieldValue::AsInteger property

·as a Text object – use the IFieldValue::AsText property

·as a string – use the IFieldValue::AsString property

cicon2 C++ (COM) code

// field of type FT_NumberField
FCEngine::IFieldPtr childField;
FCEngine::IFieldValuePtr value = childField->Value;
if (value->Type == FCEngine::FVT_Number){
double doubleValue = value->AsDouble;
int intValue = value->AsInteger;
_bstr_t stringValue = value->AsString;
FCEngine::ITextPtr textValue = value->AsText;
}

FT_PictureField

NULL

Field value of type FVT_Picture

You can receive the value of the field as a FieldPictureValue object using the IFieldValue::AsPicture property.

cicon2 C++ (COM) code

// field of type FT_PictureField
FCEngine::IFieldPtr childField;
FCEngine::IFieldValuePtr value = childField->Value;
if (value->Type == FCEngine::FVT_Picture){
FCEngine::IFieldPictureValuePtr pictureValue = value->AsPicture;
}

FT_Checkmark

NULL

Field value of type FVT_Boolean

You can receive the value of the field:

·as Boolean – use the IFieldValue::AsBoolean property

·as a string – use the IFieldValue::AsString property. The returned string contains localized "Yes" or "No".

cicon2 C++ (COM) code

// field of type FT_Checkmark
FCEngine::IFieldPtr childField;
FCEngine::IFieldValuePtr value = childField->Value;
if (value->Type == FCEngine::FVT_Boolean){
bool boolValue = value->AsBoolean;
_bstr_t stringValue = value->AsString;
}

FT_CheckmarkGroup

Fields of the type FT_Checkmark

Field value of type FVT_Choice

You can receive the value of the field:

·as a FieldChoiceValue object – use the IFieldValue::AsChoice property. This object contains a collection of available choices and a collection of selected choices. These are collections of type FieldValuesCollection. The collections will contain fields of type FT_Checkmark. Work with each field as described above.

·as a string – use the IFieldValue::AsString property. The returned string contains the value of the selected choice.

You can also receive the values of checkmark fields in the group via the child objects of the checkmark group field. Use the IField::Children property to receive a collection of child fields of type FT_Checkmark. Work with each field as described above for this type of field.

cicon2 C++ (COM) code

// field of type FT_CheckmarkGroup
FCEngine::IFieldPtr childField;
FCEngine::IFieldValuePtr value = childField->Value;
if (value->Type == FCEngine::FVT_Choice){
FCEngine::IFieldChoiceValuePtr choiceValue = value->AsChoice;
// selected choices
FCEngine::IFieldValuesCollectionPtr selectedChoices = choiceValue->SelectedChoices;
for (int i = 0; i < selectedChoices->Count; i++) {
FCEngine::IFieldValuePtr selectedChoice = selectedChoices->Item(i);
}
// all available choices
FCEngine::IFieldValuesCollectionPtr choices = choiceValue->Choices;
for (int j = 0; j < choices->Count; j++) {
FCEngine::IFieldValuePtr choice = choices->Item(j);
}
_bstr_t stringValue = value->AsString;
}
// The values of the checkmarks in the group
FCEngine::IFieldsPtr checkmarks = childField->Children;
for (int i = 0; i < checkmarks->Count; i++) {
FCEngine::IFieldPtr checkmark = checkmarks->Item(i);
FCEngine::IFieldValuePtr checkmarkValue = checkmark->Value;
bool checkmarkValueAsBoolean = checkmarkValue->AsBoolean;
}

FT_Group

Fields

NULL

Receive the collection of child fields using the IField::Children property. Work with each child field depending on its type.

FT_PageGroup

Fields

NULL

Receive the collection of child fields using the IField::Children property. Work with each child field depending on its type.

FT_Table

NULL or Fields

NULL

A table field in ABBYY FlexiCapture Engine contains a collection of instances which correspond to the table rows. Each row field is of type FT_Table and contains a collection of child fields which correspond to the cells of this row. For each row, the set of field types will be the same. Therefore, you can receive the value of a cell as follows:

1.Receive the collection of instances of the table using the IField::Instances property.

2.For each field in the collection of instance fields, receive the collection of child fields – use the IField::Children property.

3.Work with each field depending on its type.

cicon2 C++ (COM) code

// field of type FT_Table
FCEngine::IFieldPtr childField;
if (childField->Instances != 0){
FCEngine::IFieldInstancesPtr instances = childField->Instances;
for( int i = 0; i < instances->Count; i++ ) {
FCEngine::IFieldPtr row = instances->Item(i);
FCEngine::IFieldsPtr cells = row->Children;
if( cells != 0){
for( int j = 0; j < cells->Count; j++){
FCEngine::IFieldPtr cell = cells->Item(j);
}
}
}
}

FT_Document

Fields

NULL

Receive the collection of child fields using the IField::Children property. Work with each child field depending on its type.

FT_CurrencyField

NULL

Field value of type FVT_Currency

You can receive the value of the field:

·as a Text object – use the IFieldValue::AsText property

·as a string – use the IFieldValue::AsString property

cicon2 C++ (COM) code

// field of type FT_CurrencyField
FCEngine::IFieldPtr childField;
FCEngine::IFieldValuePtr value = childField->Value;
if (value->Type == FCEngine::FVT_Currency){
FCEngine::ITextPtr textValue = value->AsText;
_bstr_t stringValue = value->AsString;
}

See also

Verifying Recognized Data


Verifying Recognized Data

Guided Tour > Advanced Techniques >

Verifying Recognized Data

Verification is a process of checking recognized data. It is performed by comparing recognition results with the image of any document part. When the program is not absolutely certain about the accuracy of recognition of a certain characters, it marks them as recognized "unreliably." The purpose of the verification process is to verify such characters and correct any errors if necessary.

Typically, verification is a two-stage process consisting of group and context verification. However, one of these stages can be skipped.

Group verification is a verification mode whereby identically recognized characters are submitted for verification in groups. Group verification involves grouping character images recognized as having identical values and displaying them in a verifier screen, enabling the operator to easily identify and correct characters that deviate from the group.

Context verification is a verification mode intended for effective correction of errors of "well-recognized" fields, i.e. fields whose range of values is known or can be easily identified. An example of such a field is a field containing a country or city name.

How to verify recognized data
After using FlexiCapture Processor for recognition, call the CreateVerificationSession method of the Engine object to run the verification process. Pass necessary documents as a parameter.
Calling these method provides access to the VerificationSession object which contains all the verification settings and allows you to receive the data to verify.

note Note: You cannot run two verification sessions in one process simultaneously.

1.Before starting the verification, you can set the verification options using the Options property of the VerificationSession object:

ospecify if context verification should be performed (the VerifyFields property)

ospecify which symbols should be verified during group verification (the VerifyBaseSymbols and VerifyExtraSymbols properties), or disable group verification (set both these properties to FALSE)

ospecify which symbols should be excluded from the verification process

note Note: Verification options can be set only before starting the verification (before the first IVerificationSession::NextWorkSet method call). After beginning the verification, all these settings become read-only.

2.When the verification parameters are set, call the NextWorkSet method of the VerificationSession object to receive a part of the data that need verification (a work set). Each verification session contains one or several work sets. Documents are combined into work sets depending on the available resources. Work sets enable several verifiers to process one big batch.

3.For each work set:

oA work set consists of several groups of objects to verify. To receive the next group, call the NextGroup method of the VerificationWorkSet object.

oFor each group:

1.A verification group consists of several verification objects. It can include objects which are to be verified in one group during group verification, or objects which have the same meaning (e.g. the "Name" fields from all the verified documents). Go through the verification group, using the Count property and Item method of the VerificationGroup object.

2.A verification object can be submitted for group or context verification. This is determined by the type of the object. For each object:

1.Check the type of the object using the Type property of the VerificationObject object.

2.If this is a context verification object, use the AsContextVerificationObject method to obtain the ContextVerificationObject object. The ContextVerificationObject object provides access to the field containing an error and the rules applied to this field.

3.If this is a group verification object, use the AsGroupVerificationObject method to obtain the GroupVerificationObject object. The GroupVerificationObject object provides access to the character submitted for group verification and its image.

oWhen you finish verification of the data in the current work set, you must call the Commit method of the VerificationWorkSet object to save the changes.

4.After you have finished verification, call the Close method of the VerificationSession object to close the verification session. An open verification session uses more resources than a closed one. So if you have finished verification and need to free some resources, call this method to close the verification session.

cicon2 C++ (COM) code

// A collection of recognized documents
FCEngine::IDocumentsCollectionPtr documents;
// Start a verification session
FCEngine::IVerificationSessionPtr session = engine->CreateVerificationSession(documents);
// Change verification options if required
FCEngine::IVerificationOptionsPtr options = session->Options;
options->VerifyExtraSymbols = VARIANT_TRUE;
// Open a set of documents (a work set) and collect the objects that need to be verified
FCEngine::IVerificationWorkSetPtr workset = session->NextWorkSet();
while (workset != 0) {
// For each group of objects, display the objects to the verification operator for confirmation
FCEngine::IVerificationGroupPtr group = workset->NextGroup();
while (group != 0) {
for (int i = 0; i < group->Count; i++) {
FCEngine::IVerificationObjectPtr object = group->Item(i);
if (object->Type == FCEngine::VOT_Group) {
object->State = FCEngine::VOS_Confirmed;
} else {
FCEngine::IContextVerificationObjectPtr contextObject = object->AsContextVerificationObject();
contextObject->Field->Value->SetVerified();
}
}
group = workset->NextGroup();
}
// Save the verification results
workset->Commit();
// Open the next set of documents
workset = session->NextWorkSet();
}
// Release the resources that were used for verification
session->Close();

See also

VerificationSession

Working with Recognized Data

See sample: FlexiCapture Engine Code Snippets


Working with Recognition Variants

Guided Tour > Advanced Techniques >

Working with Recognition Variants

ABBYY FlexiCapture Engine has a special API which provides access to different hypotheses of character or word recognition with corresponding confidence values. You can use this API to check recognition results using your own databases and algorithms, and to correct text. For example, if you process a field containing some code with a checksum, a field that can be looked up in a database, or a field that can be crosschecked with another field in the same document. You can also use a more advanced approach and build your own hypotheses from variants for individual characters. This approach can be very computationally intensive, so use it with care. You can limit the number of built hypotheses using word or character confidence.

note Note: The API working with recognition variants is not available for recognizing handprinted texts.

The RecognizedWordInfo object represents a single hypothesis for a word and contains the text of the hypothesis, type of model, etc. The GetRecognizedCharacter method of this object provides access to the parameters of a recognition variant of a character. Please note that a word is a fragment of text separated for the purposes of recognition and not necessarily a word in the linguistic sense.

The RecognizedCharacterInfo object represents a single hypothesis for a character and contains character confidence, probability that a character is written with a serif font, and information on whether the character is superscript or subscript, etc.

warning Important! If you are going to work with recognition variants, your license should have the Verification module enabled.

How to retrieve recognition variants for a word or character

If you wish to find out all recognition hypotheses for a word or character, do the following:

1.Call the EnableRecognitionVariants method of the Engine object with its parameter set to TRUE. This will instruct FlexiCapture Engine to save recognition variants in the recognition results. If you pass FALSE value to this method, only one recognition variant will be available, and the methods and properties which work with the recognition variants will not function properly.

2.Recognize your documents.

3.Create a RecognizedWordInfo object. Pass this object to the IText::GetRecognizedWord method to obtain hypotheses of a word recognition. The method also takes as input parameters the index of the word in the text and the index of the recognition variant you want to retrieve. You can pass -1 as the index of recognition variant to obtain the main variant (the one that is used in the resulting text).

4.Create a RecognizedCharacterInfo object. Pass this object to the IRecognizedWordInfo::GetRecognizedCharacter method to obtain hypotheses of a character recognition. The method also takes as input parameters the index of the character in the word and the index of the recognition variant you want to retrieve. You can pass -1 as the index of recognition variant to obtain the main variant (the one that is used in the resulting text).

cicon2 C# code

IEngine engine;
...
engine.EnableRecognitionVariants( true );
// Retrieving word recognition variants
IText text = field.Value.AsText;
IRecognizedWordInfo wordInfo = engine.CreateRecognizedWordInfo();
// Obtaining the main word recognition variant (the one which is used in the resulting text)
text.GetRecognizedWord( 0, -1, wordInfo );
// Iterating all word variants
for( int i = 0; i < wordInfo.RecognitionVariantsCount; i++ ) {
text.GetRecognizedWord( 0, i, wordInfo );
...
}
// Retrieving recognition variants for individual characters
IRecognizedWordInfo wordInfo = engine.CreateRecognizedWordInfo();
IRecognizedCharacterInfo charInfo = engine.CreateRecognizedCharacterInfo();
text.GetRecognizedWord( 0, -1, wordInfo );
for( int k = 0; k < wordInfo.RecognitionVariantsCount; k ++ ) {
text.GetRecognizedWord( 0, k, wordInfo );
for( int i = 0; i < wordInfo.Text.Length; i++ ) {
wordInfo.GetRecognizedCharacter( i, -1, charInfo );
string charVars = "";
for( int j = 0; j < charInfo.RecognitionVariantsCount; j++ ) {
wordInfo.GetRecognizedCharacter( i, j, charInfo );
charVars += charInfo.Character.PadRight( 4, ' ' );
}
...
}
}

What is the difference between the CharConfidence and the IsSuspicious properties

The CharConfidence property of the CharParams or the RecognizedCharacterInfo objects is the read-only int property which stores the value of recognition confidence of a character or a character variant.

Recognition confidence of a character variant is a numerical estimate of the probability that the image does in fact represent this character. However, confidence is not guaranteed to be a positive number, and the only reliable use of confidence is to compare several variants for one image.

When recognizing a character, the program provides several recognition variants which are ranked by their confidence values. For example, an image of the letter "e" may be recognized

·as the letter "e" with a confidence of 95,

·as the letter "c" with a confidence of 85,

·as the letter "o" with a confidence of 65, etc.

The hypothesis with the highest confidence rating is selected as the recognition result. But the choice also depends on the context (i.e. the word to which the character belongs) and the results of a differential comparison. For example, if the word with the "e" hypothesis is not a dictionary word while the word with the "c" hypothesis is a dictionary word, the latter will be selected as the recognition result, even though its confidence rating will still be 85. The rest of the recognition variants can be obtained as hypotheses.

The IsSuspicious property of the CharParams object is the Boolean property. This property set to TRUE means that the character was recognized unreliably. This property is determined by an algorithm which takes into account a number of parameters, such as recognition confidence of a character, nearby characters and their recognition confidence, hypotheses and their recognition confidence, the geometric parameters of a character, and context (i.e. the word to which a character belongs).

The suspicious characters, for which this property is TRUE, are then highlighted in the ABBYY FlexiCapture document window. You can set the preferred level of uncertainty at which the character is highlighted as suspicious through the ErrorHighlightLevel property of the TextRecognitionParams object.

See also

RecognizedWordInfo

RecognizedCharacterInfo

CharParams


Classifying Images Using FlexiCapture Processor

Guided Tour > Advanced Techniques >

Classifying Images Using FlexiCapture Processor

note Note: This functionality is available only for rules-based classification.
This section describes the use of FlexiCapture Processor for classifying a set of images by category.

The categories into which you wish to divide the images will be represented by Document Definitions.

There are basically two ways to perform the classification task with the help of FlexiCapture Processor. You can either run the full recognition of each image and classify the images according to the matched Document Definition or use only the classifier tree and assign to each image the category suggested by the classifier as the most probable. The first scenario is more accurate, but the second one takes less time.

warning Important! When any Document Definitions are loaded for the processor, every node of the classifier tree which does not correspond to a Document Definition will be deleted automatically. So you need to use different instances of FlexiCapture Processor for each scenario described below.

Classifying by recognition

1.Create the FlexiCaptureProcessor object.

2.Load the Document Definitions. You can use AddDocumentDefinition or AddDocumentDefinitionFile methods of the FlexiCaptureProcessor object for this.

3.Load the classifier tree using the AddClassificationTreeFile method of the FlexiCaptureProcessor object.

4.Add images for processing. For example, you can add images to the internal image queue using the AddImageFile method of the FlexiCaptureProcessor object.

5.For each image in queue run RecognizeNextDocument method. The method returns a Document object. You need to retrieve the DocumentDefinition property of this object and access the Name property of the DocumentDefinition object. This is the name of the matching Document Definition and the category of your image.

6.Process the information about image category in the way you need.

cicon2 C# code

IEngine engine;
...
IFlexiCaptureProcessor processor = engine.CreateFlexiCaptureProcessor();
// Load the Document Definitions
processor.AddDocumentDefinitionFile( <path to definition1> );
processor.AddDocumentDefinitionFile( <path to definition2> );
...
// Load the classifier tree
processor.AddClassificationTreeFile( <path to classifier tree> + "\\classifier.cfl" );
// Add images to queue
processor.AddImageFile( imageFile );
// Run recognition and classification
IDocument document = processor.RecognizeNextDocument();
if( document != null ) {
IDocumentDefinition definition = document.DocumentDefinition;
if( definition != null ) {
var category = definition.Name;
// Use the obtained information
...
}
}

note Note: You can use this scenario without a classifier tree. It is used to speed up matching the Document Definition, but the task can be performed without it.

Classifying by means of the classifier tree

1.Create the FlexiCaptureProcessor object.

2.Load the classifier tree using the AddClassificationTreeFile method of the FlexiCaptureProcessor object.

3.Add images for processing. You can, for example, add images to the internal image queue using the AddImageFile method of the FlexiCaptureProcessor object.

4.For each image in queue run ClassifyNextPage method. It returns the ClassificationResult object, which contains information about the type of the page and possible categories for the page. When IClassificationResult::PageType is PT_MeetsDocumentDefinition, the list of possible categories makes sense and can be retrieved using the GetClassNames method of the ClassificationResult object. The first class name in the list is the most probable category for your image.

5.Process the information about image category in the way you need.

cicon2 C# code

IEngine engine;
...
IFlexiCaptureProcessor processor = engine.CreateFlexiCaptureProcessor();
// Load the classifier tree
processor.AddClassificationTreeFile( <path to classifier tree> + "\\classifier.cfl" );
// Add images to queue
processor.AddImageFile( imageFile );
// Run classification
var result = processor.ClassifyNextPage();
if( result != null && result.PageType == PageTypeEnum.PT_MeetsDocumentDefinition ) {
var names = result.GetClassNames();
var mostProbable = names.Item( 0 );
// Use the obtained information
...
}

See also

Creating Document Definitions by Training


Tuning Export Parameters

Guided Tour > Advanced Techniques >

Tuning Export Parameters

You can save recognized data to a file in XLS, DBF, TXT, CSV, or XML format, and save an electronic copy of your document, e.g. in PDF, PDF/A format.

The parameters of export to file can be specified via the FileExportParams object. As a separate object it is passed to the ExportDocumentEx method of the FlexiCaptureProcessor object, and thus affects the results of export.

For each supported data export format FileExportParams object provides corresponding export parameter subobject. These are:

·ExcelExportParams for XLS formats;

·DBFExportParams for DBF format;

·TextExportParams for TXT and CSV formats;

·XMLExportParams for XML format.

To save an electronic copy of your documents you can use the ImageExportParams subobject of the FileExportParams object.

Saving to XLS, DBF, TXT, CSV, and XML formats

1.Create a FileExportParams object using the CreateFileExportParams method of the Engine object, or receive it via the FileExportParams property of the ExportParams object.

2.Specify the required export format with the help of the IFileExportParams::FileFormat property.

3.Use the DBFParams, ExcelParams, TextParams, or XMLParams property of the FileExportParams object to set the parameters of export to the specified format.

4.Pass the FileExportParams object to one of the export methods.

cicon2 C++ (COM) code

// Receive a reference to the FileExportParams object
FCEngine::IFileExportParamsPtr fileExportParams;
...
// Specify the file format
fileExportParams->FileFormat = FCEngine::FEF_Text;
// Specify the parameters of export to the selected format
FCEngine::ITextExportParamsPtr textParams = fileExportParams->TextParams;
...
// Export recognized data
FCEngine::IFlexiCaptureProcessorPtr processor;
FCEngine::IDocumentPtr document;
processor->ExportDocumentEx(document, 0, 0, fileExportParams);

Saving to PDF (PDF/A) format

1.Create a FileExportParams object using the CreateFileExportParams method of the Engine object.

2.Set the ExportOriginalImages property of the FileExportParams object to TRUE.

3.Set the Format property of the ImageExportParams object to IFF_Pdf.

4.Set the CreateSearchablePDF or CreatePDFA properties of the ImageExportParams object.

5.Pass the FileExportParams object to one of the export methods.

cicon2 C++ (COM) code

// Receive a reference to the FileExportParams object
FCEngine::IFileExportParamsPtr fileExportParams;
...
// Specify the parameters
fileExportParams->ExportOriginalImages = VARIANT_TRUE;
fileExportParams->ImageExportParams->Format = FCEngine::IFF_Pdf;
fileExportParams->ImageExportParams->CreateSearchablePDF = VARIANT_TRUE;
...
// Save PDF
FCEngine::IFlexiCaptureProcessorPtr processor;
FCEngine::IDocumentPtr document;
processor->ExportDocumentEx(document, 0, 0, fileExportParams);

Using the parameters of export specified in a Document Definition

To save recognized data in the way it is specified in the corresponding Document Definition, use the ExportDocument method of the FlexiCaptureProcessor object with default parameters.

See also
Processing with a Customizable Processor Object. Step 6: Export Results


Scanning with ABBYY FlexiCapture Engine

Scanning

Guided Tour > Advanced Techniques >

Scanning

ABBYY FlexiCapture Engine offers a ScanManager object for managing the scanning sources. The ScanSourcesEx property of this object provides access to the list of all available scanners, while the FindScanSources method allows you to select the scanners by API type they provide and the user interface type you wish to use to set scanning options.

To scan and save the files to disk you can use either of these two methods of the ScanSource object: Scan method, which does not return until the scanning is complete, and BeginScan method, which starts the asynchronous scanning operation and returns immediately.

You can implement the IScanCallback interface and use it to get notifications about the progress of scanning.

The following parameters are accessible via the ABBYY FlexiCapture Engine 12 API: brightness, color, resolution, image compression type, image rotation angle, the size of the scanning area, duplex scanning mode, automatic feeder mode, a pause between pages and some more. The scanning parameters are set by using the ScanSettings property of the ScanSource object. This property is required to get access to the ScanSourceSettings object which, in its turn, provides access to the scanning settings of a source.

You can find some useful recommendations as to the preferable scanning options in the Tips for Document Scanning section.

To scan the images synchronously:

1.Create a ScanManager object using the CreateScanManager method of the Engine object.

2.Select the scanning source using the FindScanSources method of the ScanManager object, specifying the API and UI type that should be supported by the scanner.

3.If you choose to display no dialog box for the user to set scanning options him- or herself, tune the scanning options using the ScanSettings property of the chosen ScanSource. Select the appropriate values for brightness, resolution, and the other parameters in the corresponding properties of the ScanSourceSettings object. You can check which settings are available for this scanner using the Capabilities property of the ScanSource.

4.Create or choose an existing folder in which scanned pages will be stored. Put the folder name into a BSTR variable, for example, ScanFolder.

5.Call the Scan method of the ScanSource object, providing as the parameter the type of dialog box to be shown to the user (pass SOIT_None constant to display no box), and the ScanFolder path to the folder with the results.

6.The image file names will be returned by this method as a StringsCollection object. You can get the image file names from this StringsCollection object and then process the files as usual, for example, adding them to FlexiCaptureProcessor image queue.

To scan the images asynchronously:

1.Create an object implementing the IScanCallback interface. In case of asynchronous scanning operation, notifications from callback interface are very useful.

2.Create a ScanManager object using the CreateScanManager method.

3.Select the scanning source using the FindScanSources method of the ScanManager object, specifying the API and UI type that should be supported by the scanner.

4.If you choose to display no dialog box for the user to set scanning options him- or herself, tune the scanning options using the ScanSettings property of the chosen ScanSource. Select the appropriate values for brightness, resolution, and the other parameters in the corresponding properties of the ScanSourceSettings object. You can check which settings are available for this scanner using the Capabilities property of the ScanSource.

5.Create or choose an existing folder in which scanned pages will be stored. Put the folder name into a BSTR variable, for example, ScanFolder.

6.Call the BeginScan method of the ScanSource object, providing as the parameter the type of dialog box to be shown to the user (pass SOIT_None constant to display no box), and the ScanFolder path to the folder with the results. You also need to pass the pointer to the callback object you created.

7.The path to image file is returned with the OnImageScanned notification of the IScanCallback interface, and the completion of the operation is signalled by the OnScanComplete notification. As you are providing the implementation for these methods, you can choose what to do in each of these situations. For example, on receiving the path to an image file you can add it to FlexiCaptureProcessor image queue.

warning Important! Until the scanning is completed and the OnScanComplete notification received, you cannot run BeginScan or Scan again, even for some other scanner. The advantage of asynchronous scanning is not that you can perform several scanning operations at once, but that you can process the images you already received while the new images are being scanned.

See also

ScanManager

ScanSource


Integration with ABBYY FineReader Engine

Guided Tour > Advanced Techniques >

Integration with ABBYY FineReader Engine

ABBYY FlexiCapture Engine delivers the most comprehensive and flexible instruments for Data Capture, document classifying and indexing purposes. While ABBYY FineReader Engine is ideal for applications which produce documents for archives as a highly-compressed images or searchable PDF files, and documents with full page layout retention. Therefore you may want to use both features of ABBYY FineReader Engine and ABBYY FlexiCapture Engine in your application to receive the best results of document processing. For this purpose FlexiCapture Engine provides an easy way of integration with FineReader Engine. You can transfer the ImageDocument object of FlexiCapture Engine to FineReader Engine, and vice versa.

To use ABBYY FineReader Engine API, you should do the following:

1.Make sure that the FineReader Engine API is available in your ABBYY FlexiCapture Engine license.

2.ABBYY FlexiCapture Engine 12 and ABBYY FineReader Engine 12 are distributed in one package. All necessary files for FineReader Engine are installed automatically during Developer installation. During Runtime installation in automatic mode you should set the FRE option, or in manual mode copy the files marked in the Distribution Kit section as required for FineReader Engine.

3.Now you can transfer the ImageDocument object of FlexiCapture Engine to FineReader Engine, and vice versa. This can be done by saving the ImageDocument object to memory:

1.Use the IImageDocument::SaveToMemory method of either FlexiCapture Engine or FineReader Engine library to save the corresponding ImageDocument object to memory.

2.Load the ImageDocument object using the IEngine::LoadImageDocFromMemory method of either FineReader Engine or FlexiCapture Engine library.


Best Practices

Guided Tour >

Best Practices

This section provides general recommendations on improving processing quality, increasing processing speed and separating image flow into documents:

·Tips for Document Scanning

·Tips for Taking Photos

·Increasing Processing Speed


Tips for Document Scanning

Guided Tour > Best Practices >

Tips for Document Scanning

Recognition quality depends largely on the quality of the image, which greatly depends on the settings used during the document scanning process.

Font Is Too Small

For optimal recognition results, scan documents printed in very small fonts at higher resolutions.

You can specify the desired resolution in the Resolution property of the ScanSourceSettings object.

Source image | Recommended resolution
TutSmallFont300 | 300 dpi for typical texts (printed in fonts of size 10 pt or larger)
TutSmallFont600 | 400-600 dpi for texts printed in smaller fonts (9 pt or smaller)

Tuning Brightness

You may need to adjust the brightness setting when scanning in black-and-white mode. You can specify the desired brightness in the Brightness property of the ScanSourceSettings object. A medium value of around 50% should suffice in most cases.

If the resulting image contains too many "torn" or "stuck" together letters, troubleshoot using the table below.

Your image looks like this | Recommendations
GoodQuality | This image is suitable for recognition.
characters are "torn" or very light | ·Lower the brightness to make the image darker. ·Scan in grayscale. Brightness will be tuned automatically.
characters are distorted, stuck together, or filled out | ·Increase the brightness to make the image brighter. ·Scan in grayscale. Brightness will be tuned automatically.

Print Quality

Poor-quality documents with "noise" (i.e. random black dots or speckles), blurred and uneven letters, or skewed lines and shifted table borders may require specific scanning settings. For example, this fax and newspaper:

Poor-quality documents are best scanned in grayscale. When scanning in grayscale, the program will select the optimal brightness value automatically.

Grayscale mode retains more information about the letters in the scanned text to achieve better recognition results when recognizing documents of medium to poor quality.

See also

Scanning

Tips for Taking Photos


Tips for Taking Photos

Guided Tour > Best Practices >

Tips for Taking Photos

Taking photos of documents requires some skill and practice. The characteristics of your camera and shooting conditions are also important.

note Note: For detailed information about the settings of your camera, please refer to the documentation supplied with your camera.

Before taking a picture:

1.Make sure that the page fits entirely within the frame.

2.Make sure that lighting is evenly distributed across the page and that there are no dark areas or shadows.

3.Straighten out the page if required and position the camera parallel to the plane of the document so that the lens looks to the center of the text being photographed.

The topics below outline the required camera specifications and shooting modes.

Digital Camera Requirements

Minimum Requirements

·2-megapixel sensor

·Variable focus lens (fixed-focus cameras, common in cell phones and hand-held devices, will usually produce images unsuitable for OCR)

Recommended Requirements

·5-megapixel sensor

·Flash disable feature

·Manual aperture control or aperture priority mode

·Manual focusing

·An anti-shake system, otherwise the use of a tripod is recommended

·Optical zoom

Shooting Modes

Lighting

Make sure there is enough light (preferably daylight). In artificial lighting, use two light sources positioned so as to avoid shadows.

Positioning the Camera

If possible, use a tripod. Position the lens parallel to the plane of the document and point it toward the center of the text.

At full optical zoom, the distance between the camera and the document must be sufficient to fit the entire document into the frame. Usually this distance will be 50-60 cm.

Flash

Whenever possible, turn off the flash to avoid glare and sharp shadows on the page. In poor lighting conditions, try using the flash from a distance of about 50 cm, or, preferably, use additional lighting.

warning Important! Using the flash when photographing documents printed on glossy paper causes the worst glare.

White Balance

If your camera allows, use a white sheet of paper to set white balance. Otherwise, select the white balance mode which best suits the current lighting conditions.

What do I do if...

There is not enough light

Try the following:

·Select a greater aperture value

·Select a greater ISO value for sensitivity

·Use manual focusing if the camera cannot lock the focus automatically

The picture is too dark and low-contrast

Try using additional light sources. Otherwise, increase the aperture value.

The picture is not sharp enough

Auto focus may not work properly in poor lighting or when photographing at a close distance. In poor lighting conditions, try using an additional light source. When photographing a document up close, try using the Macro (or Close-Up) mode. Otherwise, if possible, focus the camera manually.

If only a part of the picture is blurred, try reducing the aperture value. Increase the distance between the document and the camera and use maximum zoom. Focus on a point anywhere in between the center and a border of the image.

In poor lighting conditions, when shooting in auto mode, the camera will use slower shutter speeds, which makes the resulting photo less sharp. In this case, try the following:

·Enable the anti-shake system, if available.

·Use auto release to prevent the shaking of the camera caused by pressing the shutter release button (even when using a tripod).

The flash causes glare in the center of the picture

Turn off the flash. Otherwise, try photographing from a greater distance.

See also

Tips for Document Scanning


Increasing Processing Speed

Guided Tour > Best Practices >

Increasing Processing Speed

The speed of processing depends on the quality of images (see recommendations for scanning and taking photos) and on the settings used during processing.

Common recommendations

The following recommendations are common for all types of documents. No matter which documents you process, we recommend that you:

·Load Engine object only once, process all images, and then unload Engine. Do not load and unload Engine object each time an image is processed.

·Specify the correct recognition language and text type for each field. Incorrect recognition language and a lot of text types for a field can significantly slow down processing.

·Use FlexiCaptureProcessor object for processing. Once initialize the object and use it with all images. See Processing with a Customizable Processor Object for details.

Additional settings

You may use or not use these settings depending on the type and quantity of processing documents and the result you want to receive:

·Use the AddClassificationTreeFile method of the FlexiCaptureProcessor object, if a lot of Document Definitions are matched simultaneously. This method allows you to speed up the selection of a Document Definition to be matched.

·Use the SetUseFirstMatchedDocumentDefinition method of the FlexiCaptureProcessor object, if there are a few Document Definitions, which strongly differ and are definitely matched. This method allows you to make the processor use the first matching Document Definition. Otherwise, the processor will attempt to apply each of the Document Definitions from an internal processing list and then select the best match.

·Create a pool of initialized processors (FlexiCaptureProcessor objects) running in parallel processes, if you process a lot of one-page documents on a high-performance multi-CPU computer. ABBYY FlexiCapture Engine includes a sample called FlexiCapture Processors Pool which shows how a pool of processors can be created and used.

·Fixed forms are matched faster than FlexiLayouts.

·Select Fast mode in Pre-recognition parameters for a FlexiLayout. This will speed up processing, but the quality may deteriorate.

·You can remove a template image from a FlexiLayout. This will speed up FlexiLayout loading, but the FlexiLayout modification will be a bit inconvenient.

·Check the integrity of document data in the code of your application using available API instead of specifying additional rules in Document Definitions.

See also

Tips for Document Scanning

Tips for Taking Photos


Description of the ABBYY FlexiCapture Engine Samples

Guided Tour >

Description of the ABBYY FlexiCapture Engine Samples

The ABBYY FlexiCapture Engine 12 Distribution pack contains a set of sample source code showing how to use Engine in different scenarios. This section contains a short description of these samples. The detailed description of the samples can be found in the Code Samples Library provided with this distribution pack (Start > Programs > ABBYY FlexiCapture Engine 12 > Code Samples Library).

The ABBYY FlexiCapture Engine samples are provided for C#, C++ with the Native COM Support, raw C++, Visual Basic .Net, Java, Delphi, and scripting languages.

All sample code can be found in the %ProgramData%\ABBYY\SDK\12\FlexiCapture Engine\Samples folder.

Sample Name | Description
Hello (C#) Hello (C++, COM) Hello (C++, Raw) Hello (VB.Net) | Performs document conversion with just a few lines of code. This sample will help you to start development using the ABBYY SDK.
Hello (Delphi) | Shows how to use ABBYY FlexiCapture Engine in Delphi. note Note: The sample is deprecated because of low frequency of Delphi usage. The sample will be removed in future versions.
Hello (Java) | Shows how to use ABBYY FlexiCapture Engine in Java.
Hello (JScript, VBScript, Perl) | Shows how to use ABBYY FlexiCapture Engine in script languages.
FlexiCapture Code Snippets (C#) | A collection of short code snippets showing typical usage scenarios and programming tasks.
FlexiCapture Project Viewer (C#) | A simple viewer for FlexiCapture projects. Shows how to create your own visual representations for FlexiCapture Engine objects. note Note: The sample is deprecated and will be removed in future versions.
FlexiCapture Processors Pool (C#) | This sample on the one hand provides a complete reusable solution for a pool of FlexiCapture processors in a multithreaded application, and on the other hand demonstrates the gain in speed when using multithreaded processing.
FlexiCapture Web Service (C#) | This sample represents a model of server application. It provides the web service of ISBN recognition.
Multi-Core Processing (C#) | Demonstrates the gain in speed when using a pool of FlexiCapture processors in a multithreaded application.
Mobile Data Capture (C#) | Demonstrates how ABBYY FlexiCapture Engine can process photos taken with mobile device cameras.
Color Stamps Removal (C#) | Shows how ABBYY FlexiCapture Engine can process images with overlaid stamps and ink inscriptions.
Redaction (C#) | Demonstrates the use of the ABBYY FlexiCapture Engine redaction feature. During image export, you can hide the images of specific fields thus redacting confidential information and other sensitive data.
Creating Document Definitions by Training (C#) | Shows how to create simple Document Definitions. Document Definitions are created based on several training images and then can be used for data extraction with ABBYY FlexiCapture or ABBYY FlexiCapture Engine.
Image Preprocessing (C#) | ABBYY FlexiCapture Engine provides a wide variety of image preprocessing tools, which can help to improve recognition quality.
Visual Components (C#) | A simple data capture application with a graphical user interface constructed from ABBYY FlexiCapture Engine visual controls. note Note: The sample is deprecated and will be removed in future versions.
Visual Components - Hello (C#) | Shows how to construct GUI of a data capture application using ABBYY FlexiCapture Engine visual controls. Uses FlexiCapture Processor for documents processing. note Note: The sample is deprecated and will be removed in future versions.
Visual Components - Hello with FlexiCapture Project (C#) | Shows how to construct GUI of a data capture application using ABBYY FlexiCapture Engine visual controls. Works with FlexiCapture projects. note Note: The sample is deprecated and will be removed in future versions.

note Notes:

·To run the C# samples the NET.Framework version 2​.0 is required.


FlexiCapture Engine API Reference

No topics above this level

FlexiCapture Engine API Reference

This section contains the description of ABBYY FlexiCapture Engine API:

·Functions

·Objects

·Enumerations

·Types of Properties

·Return Codes


Functions

API Reference >

Functions

This section describes ABBYY FlexiCapture Engine functions. These functions allow you to load and initialize FlexiCapture Engine, and deinitialize and unload it.

warning Important! Please notice that the InitializeEngine and InitializeEngineEx functions are deprecated and will be removed in future versions.

·GetEngineLoader

·InitializeEngine

·InitializeEngineEx

·DeinitializeEngine


GetEngineLoader Function

API Reference > Functions >

GetEngineLoader Function

This function gets a pointer to the IEngineLoader interface.

Syntax

Visual Basic .NET

Private Declare Function GetEngineLoader Lib "FCEngine.dll" ( Engine As FCEngine.IEngineLoader) As Int

C++

HRESULT __stdcall GetEngineLoader( IEngineLoader** Engine );

Parameters

Engine

[out, retval] A pointer to the IEngineLoader* pointer variable that receives the interface pointer to the EngineLoader object.

Return values

The function may return standard return values of ABBYY FlexiCapture Engine functions.

See also

Tutorial. Step 1 : Load FlexiCapture Engine

Engine

EngineLoader


InitializeEngine Function

API Reference > Functions >

InitializeEngine Function

warning Important! This function is deprecated. To load the Engine object use the GetEngine method of the EngineLoader object. This object provides settings of the unified Engine loading procedure for all license types including the Cloud License. This object loading method is described in detail in the Tutorial, Step 1: Load FlexiCapture Engine.

This function gets a pointer to the IEngine interface. It takes as an input parameter the Customer Project ID number, which is an alphanumeric string common to all the Developer and Runtime licenses your project uses. You may pass the Customer Project ID number to this function, or specify it later with the help of the IEngine::SetCurrentLicense method.

Syntax

Visual Basic .NET

Private Declare Function InitializeEngine Lib "FCEngine.dll" ( _
ByVal CustomerProjectId As String, _
Engine As FCEngine.IEngine) As Int

C++

HRESULT __stdcall InitializeEngine(
BSTR CustomerProjectId,
IEngine** Engine
);

Parameters

CustomerProjectId

[in] A string containing Customer Project ID number that matches the necessary license. This parameter may be 0 or an empty string. In this case, you will have to specify the correct Customer Project ID later, but before the call to any of the processing methods, using the IEngine::SetCurrentLicense method.

Engine

[out, retval] A pointer to the IEngine* pointer variable that receives the interface pointer to the resulting Engine object.

Return values

The function may return standard return values of ABBYY FlexiCapture Engine functions.

See also

Tutorial. Step 1: Load FlexiCapture Engine

Engine

DeinitializeEngine

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, FlexiCapture Web Service, Mobile Data Capture, Classification, Color Stamps Removal, Redaction


InitializeEngineEx Function

API Reference > Functions >

InitializeEngineEx Function

warning Important! This function is deprecated. To load the Engine object use the GetEngine method of the EngineLoader object. This object provides settings of the unified Engine loading procedure for all license types including the Cloud License. This object loading method is described in detail in the Tutorial, Step 1: Load FlexiCapture Engine.

This function gets a pointer to the IEngine interface. It takes as an input parameter the Customer Project ID number, which is an alphanumeric string common to all the Developer and Runtime licenses your project uses. You may pass the Customer Project ID number to this function, or specify it later with the help of the IEngine::SetCurrentLicense method.

The only difference from the InitializeEngine function is that InitializeEngineEx function takes as input parameters the path to the folder with user-specific data. This function is useful in the situations when default folder with user data is inaccessible.

Syntax

Visual Basic .NET

Private Declare Function InitializeEngineEx Lib "FCEngine.dll" ( _
ByVal CustomerProjectId As String, _
ByVal Reserved1 As String, _
ByVal Reserved2 As String, _
ByVal AppDataPath As String, _
Engine As FCEngine.IEngine _
) As Int

C++

HRESULT __stdcall InitializeEngineEx(
BSTR CustomerProjectId,
BSTR Reserved1,
BSTR Reserved2,
BSTR AppDataPath,
IEngine** Engine);

Parameters

CustomerProjectId

[in] A string containing Customer Project ID number that matches the necessary license. This parameter may be 0 or an empty string. In this case, you will have to specify the correct Customer Project ID later, but before the call to any of the processing methods, using the IEngine::SetCurrentLicense method.

Reserved1

[in] Reserved for future use. The empty string "" or Null pointer must be passed.

Reserved2

[in] Reserved for future use. The empty string "" or Null pointer must be passed.

AppDataPath

[in] The path to the folder where the application data is stored. FlexiCapture Engine stores some user-specific data in this folder, therefore this folder should be accessible for reading and writing. For example, you can specify the path to the FlexiCapture Engine data folder as this parameter. If you pass an empty string "" for this parameter, temporary data will be stored in the %TEMP% folder, and all other data will be stored in the FlexiCapture Engine data folder.

Engine

[out, retval] A pointer to the IEngine* pointer variable that receives the interface pointer to the resulting Engine object.

Return values

The function may return standard return values of ABBYY FlexiCapture Engine functions.

See also

Tutorial. Step 1: Load FlexiCapture Engine

Engine

InitializeEngine

DeinitializeEngine


DeinitializeEngine Function

API Reference > Functions >

DeinitializeEngine Function

This function deinitializes ABBYY FlexiCapture Engine 12. It unloads FlexiCapture Engine and frees resources. Call this function after you have released all ABBYY FlexiCapture Engine objects.

Syntax

Visual Basic .NET

Private Declare Function DeinitializeEngine Lib "FCEngine.dll" () As Int

C++

HRESULT __stdcall DeinitializeEngine();

Return values

The function may return standard return values of ABBYY FlexiCapture Engine functions.

Remarks

If there are unreleased objects when you deinitialize ABBYY FlexiCapture Engine, deinitialization completes correctly and all unreleased objects become invalid. The only thing you can do with such objects — release them. You can get the list of not released objects, if you call the IEngine::StartLogging method before deinitialization.

See also

Tutorial. Final Step: Unload FlexiCapture Engine

Engine

GetEngineLoader

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, FlexiCapture Web Service, Mobile Data Capture, Classification, Color Stamps Removal, Redaction


Objects

API Reference >

Objects

This section contains the complete reference of the ABBYY FlexiCapture Engine objects:

·Engine object — the top object of ABBYY FlexiCapture Engine objects hierarchy

·Engine loaders

·FlexiCapture processor object and related interfaces

·Project structure objects (deprecated)

·Document structure objects

·Document Definition structure objects

·Document Definition training objects

·Language-related objects

·Text-related objects

·Image-related objects

·Errors objects

·Import parameters objects

·Export parameters objects

·Scanning-related objects

·Verification-related objects

·License-related objects

·Supplementary objects

Also you can find here the alphabetical list of the ABBYY FlexiCapture Engine 12 objects and object diagram.


ABBYY FlexiCapture Engine 12 Object Diagram

API Reference > Objects >

ABBYY FlexiCapture Engine 12 Object Diagram


Engine Object (IEngine Interface)

API Reference > Objects >

Engine Object (IEngine Interface)

This object is the top object of ABBYY FlexiCapture Engine objects hierarchy. It exposes a set of creation methods. The Engine object properties reflect global settings for ABBYY FlexiCapture Engine.

The Engine object is the only externally creatable object among FlexiCapture Engine objects. To create this object, use the EngineLoader object created by the GetEngineLoader function. You can also use other ways to load the Engine object.

After you have received the reference to the Engine object, you can:

·Proceed your work with creating the FlexiCapture processor. The CreateFlexiCaptureProcessor method allows you to create the processor, which then can be used for converting input images to recognized documents.

·Proceed your work with opening a project. The OpenProject method allows you to open one of the existing projects. You have to create the project with the help of ABBYY FlexiCapture 12, and then use it in ABBYY FlexiCapture Engine 12.

warning Important! Working with projects in ABBYY FlexiCapture Engine 12 is deprecated and will be removed in future versions. It is strongly recommended that you use FlexiCapture Processor and its functionality in your scenarios.

·Create some additional ABBYY FlexiCapture Engine objects with the help of creation methods.

·Start logging of errors, warnings and method calls.

Properties

Name | Type | Description
ApplicationTitle | String | Assign the name of your application to this parameter. It will be used as the title for message boxes. By default the value of this property is "ABBYY FlexiCapture Engine 12".
CurrentLicense | License, read-only | Returns the current license.
Licenses | LicenseCollection, read-only | Returns a collection of available (activated) licenses.
MessagesLanguage | MessagesLanguageEnum | Defines the language of interaction between ABBYY FlexiCapture Engine and the user. All message boxes, error messages, and recognizer tips will be in this language. This parameter stays on between sessions. By default this property is initialized with the current system language, if this language is available in ABBYY FlexiCapture Engine; otherwise it is set to the language with the lowest code available. note Note: The locale for the selected messages language must be installed on the computer.
MultiProcessingParams | MultiProcessingParams, read-only | Provides access to the parameters of multiple CPU cores usage.
PredefinedLanguages | PredefinedLanguages, read-only | Provides access to the collection of predefined languages of ABBYY FlexiCapture Engine.
ParentWindow | __int64 | Stores HWND handle of the main window of an application which uses ABBYY FlexiCapture Engine. This parameter is used to correctly process dialogs and message boxes. You may change this parameter at any time or not to set it at all. ABBYY FlexiCapture Engine uses the standard MFC procedure for finding the main window. If the main window owns any popup windows, the last active popup will be used as the parent window rather than the window specified by this property. If you do not set a value for this property, the procedure of finding the main window may fail, and then ABBYY FlexiCapture Engine will perform incorrectly.
Version | String, read-only | Specifies the version of the FCEngine.dll file. For example, "12.0.5.127".

Methods

Name | Description
CreateBarcodeParams | Creates the BarcodeParams object.
CreateBlocksCollection | Creates the BlocksCollection object.
CreateCharParams | Creates the CharParams object.
CreateDocumentDefinition | Creates the DocumentDefinition object.
CreateDocumentDefinitionFromAFL | Creates the DocumentDefinition object from the specified ABBYY Flexible Layout file (*.afl).
CreateDocumentDefinitionFromImageFile | Creates the DocumentDefinition object from an image file, searching it for the blocks of specified type.
CreateDocumentDefinitionFromXFD | Creates the DocumentDefinition object from the specified XML Form Definition file (*.xfd).
CreateDocumentsCollection | Creates the DocumentsCollection object.
CreateExportParams | Creates the ExportParams object.
CreateFieldValuesCollection | Creates the FieldValuesCollection object.
CreateFileExportParams | Creates the FileExportParams object.
CreateFlexiCaptureProcessor | Creates the FlexiCaptureProcessor object.
CreateImageGroupingParams | Creates the ImageGroupingParams object. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
CreateImageLoadingParams | Creates the ImageLoadingParams object.
CreateImageModification | Creates the ImageModification object.
CreateImageProcessingParams | Creates the ImageProcessingParams object.
CreateImageProcessingTools | Creates the ImageProcessingTools object.
CreateJpegExtendedParams | Creates the JpegExtendedParams object.
CreateIntsCollection | Creates the IntsCollection object.
CreatePageAnalysisParams | Creates the PageAnalysisParams object.
CreateRecognizedCharacterInfo | Creates the RecognizedCharacterInfo object.
CreateRecognizedWordInfo | Creates the RecognizedWordInfo object.
CreateRectangle | Creates the Rectangle object.
CreateRegion | Creates the Region object.
CreateScanningProfiles | Creates the ScanningProfiles object. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
CreateScanManager | Creates the ScanManager object.
CreateSectionDefinitionsCollection | Creates the SectionDefinitionsCollection object. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
CreateStringsCollection | Creates the StringsCollection object.
CreateText | Creates the Text object from the specified string.
CreateTrainingBatch | Creates the TrainingBatch object.
CreateVerificationSession | Creates the VerificationSession object that can be used with documents returned by FlexiCapture Processor.
EnableRecognitionVariants | Enables or disables collecting information about recognition variants during recognition.
LoadImageDocFromFile | Restores the contents of the ImageDocument object from the file. The method can be used for transferring the ImageDocument object from ABBYY FineReader Engine to ABBYY FlexiCapture Engine, and vice versa.
LoadImageDocFromMemory | Restores the contents of the ImageDocument object from the global memory. The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa.
LoadImageDocument | Restores the contents of the ImageDocument object from a folder on disk. The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa.
LogUnreleasedObjects | Writes to the log file a list of objects that are not currently deleted.
OpenProject | Opens the specified project. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
OpenTrainingBatch | Opens an existing training batch.
SetCurrentLicense | Sets the current license.
StartLogging | Enables logging of errors, warnings and method calls.
StopLogging | Disables logging of errors, warnings and method calls.
WarmUp | Loads and initializes most delay-loaded resources.

Output parameter

This object is the output parameter of the following methods and functions:

·InitializeEngine, InitializeEngineEx function

·GetEngine, Load methods of the IEngineLoader interface

See also

Tutorial

Different Ways to Load Engine Object

Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications

Working with Properties

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing, Mobile Data Capture, Color Stamps Removal, Redaction


Creation Methods of the Engine Object

API Reference > Objects > Engine >

Creation Methods of the Engine Object

The Engine object contains a number of methods that create other objects of the ABBYY FlexiCapture Engine library. They all have similar semantics. All newly created objects have default values.

Syntax

Visual Basic .NET

Function Create<ObjectName>() As <ObjectName>

C++

HRESULT Create<ObjectName>(
I<ObjectName>** Result
);

Parameters

Result

[out, retval] A pointer to the I<ObjectName>* pointer variable that receives the interface pointer of the created object. Result must not be NULL. *Result is guaranteed to be non-NULL after successful method call.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following objects are created by use of these methods:

·BarcodeParams

·BlocksCollection

·CharParams

·ClassificationTree

·DocumentDefinition

·DocumentsCollection

·FieldValuesCollection

·FileExportParams

·FlexiCaptureProcessor

·ImageGroupingParams (deprecated)

·ImageLoadingParams

·ImageModification

·ImageProcessingParams

·ImageProcessingTools

·IntsCollection

·JpegExtendedParams

·PageAnalysisParams

·PngExtendedParams

·RecognizedCharacterInfo

·RecognizedWordInfo

·Region

·ScanningProfiles (deprecated)

·ScanManager

·SectionDefinitionsCollection (deprecated)

·StringsCollection

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Create CharParams object
FCEngine::ICharParamsPtr charParams = Engine->CreateCharParams();
...

See also

Engine

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing, Mobile Data Capture, Color Stamps Removal, Redaction


CreateDocumentDefinitionFromAFL Method of the Engine Object

API Reference > Objects > Engine >

CreateDocumentDefinitionFromAFL Method of the Engine Object

This method creates the DocumentDefinition object from the specified ABBYY Flexible Layout file (*.afl).

AFL file contains a flexible layout — a formalized description of a semi-structured document which allows the program to detect image areas which correspond to data fields. ABBYY Flexible Layout files are created with ABBYY FlexiLayout Studio.

The flexible layout contains information on how to find data fields, but does not specify the language of the data (which is the required parameter for Document Definition creation), therefore you should pass the correct recognition language as a parameter of this method.

Syntax

Visual Basic .NET

Function CreateDocumentDefinitionFromAFL( _
filePath As String, _
languageName As String _
) As DocumentDefinition

C++

HRESULT CreateDocumentDefinitionFromAFL(
BSTR filePath,
BSTR languageName,
IDocumentDefinition** result
);

Parameters

filePath

[in] This variable specifies the full path to the AFL file, e.g. "D:\sample.afl".

languageName

[in] This variable specifies the language to be used during recognition with the new Document Definition. It will be written to the DefaultLanguage property of the newly created DocumentDefinition object.

result

[out, retval] A pointer to the IDocumentDefinition* pointer variable that receives the interface pointer of the created DocumentDefinition object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

DocumentDefinition

Creating Document Definitions

See sample: FlexiCapture Engine Code Snippets


CreateDocumentDefinitionFromImageFile Method of the Engine Object

API Reference > Objects > Engine >

CreateDocumentDefinitionFromImageFile Method of the Engine Object

This method creates the DocumentDefinition object from an image file, searching it for the blocks of specified type. Please note that it does not guarantee that all the structure elements will be detected correctly.

Syntax

Visual Basic .NET

Function CreateDocumentDefinitionFromImageFile( _
FilePath As String, _
LanguageName As String, _
AutodetectBlockTypes As IntsCollection _
) As DocumentDefinition

C++

HRESULT CreateDocumentDefinitionFromImageFile(
BSTR FilePath,
BSTR LanguageName,
IIntsCollection* AutodetectBlockTypes,
IDocumentDefinition** Result
);

Parameters

FilePath

[in] This variable specifies the full path to the image file. See the list of supported image formats.

LanguageName

[in] This variable specifies the language to be used during recognition with the new Document Definition. It will be written to the DefaultLanguage property of the newly created DocumentDefinition object.

AutodetectBlockTypes

[in] This variable refers to a collection of block types that must be detected, represented by the constants of BlockTypeEnum cast to Int.

Result

[out, retval] A pointer to the IDocumentDefinition* pointer variable that receives the interface pointer of the created DocumentDefinition object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

DocumentDefinition

Creating Document Definitions


CreateDocumentDefinitionFromXFD Method of the Engine Object

API Reference > Objects > Engine >

CreateDocumentDefinitionFromXFD Method of the Engine Object

This method creates the DocumentDefinition object from the specified XML Form Definition file (*.xfd).

XML Form Definition — a special file format of a form designed with ABBYY FormDesigner. This Form Definition contains information about location of data fields, but does not specify the language of the data (which is the required parameter for Document Definition creation), therefore you should pass the correct recognition language as a parameter of this method.

Syntax

Visual Basic .NET

Function CreateDocumentDefinitionFromXFD( _
filePath As String, _
languageName As String _
) As DocumentDefinition

C++

HRESULT CreateDocumentDefinitionFromXFD(
BSTR filePath,
BSTR languageName,
IDocumentDefinition** result
);

Parameters

filePath

[in] This variable specifies the full path to the XFD file, e.g. "D:\sample.xfd".

languageName

[in] This variable specifies the language to be used during recognition with the new Document Definition. It will be written to the DefaultLanguage property of the newly created DocumentDefinition object.

result

[out, retval] A pointer to the IDocumentDefinition* pointer variable that receives the interface pointer of the created DocumentDefinition object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

DocumentDefinition

Creating Document Definitions

See sample: FlexiCapture Engine Code Snippets


CreateExportParams Method of the Engine Object

API Reference > Objects > Engine >

CreateExportParams Method of the Engine Object

This method creates the ExportParams object for the specified destination type.

Syntax

Visual Basic .NET

Function CreateExportParams(Type As ExportDestinationTypeEnum) As ExportParams

C++

HRESULT CreateExportParams(
ExportDestinationTypeEnum Type,
IExportParams** Result
);

Parameters

Type

[in] This variable of the ExportDestinationTypeEnum type specifies the destination of output files. Currently only the EDT_File constant can be used.

Result

[out, retval] A pointer to the IExportParams* pointer variable that receives the interface pointer of the ExportParams object. Must not be NULL.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

ExportParams


CreateRectangle Method of the Engine Object

API Reference > Objects > Engine >

CreateRectangle Method of the Engine Object

This method creates the Rectangle object.

Syntax

Visual Basic .NET

Function CreateRectangle( _
left As Int, _
top As Int, _
right As Int, _
bottom As Int _
) As Rectangle

C++

HRESULT CreateRectangle(
int left,
int top,
int right,
int bottom,
IRectangle** Result
);

Parameters

left

[in] This variable specifies the coordinate of the left border of the rectangle.

top

[in] This variable specifies the coordinate of the top border of the rectangle.

right

[in] This variable specifies the coordinate of the right border of the rectangle.

bottom

[in] This variable specifies the coordinate of the bottom border of the rectangle.

Result

[out, retval] A pointer to the IRectangle* pointer variable that receives the interface pointer of the Rectangle object. Must not be NULL.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

Rectangle


CreateText Method of the Engine Object

API Reference > Objects > Engine >

CreateText Method of the Engine Object

This method creates a Text object from the specified string.

Syntax

Visual Basic .NET

Function CreateText( _
str As String, _
charParams As CharParams _
) As Text

C++

HRESULT CreateText(
BSTR str,
ICharParams* charParams,
IText** result
);

Parameters

str

[in] This variable contains the string, which should be used for a new Text object creation.

charParams

[in] This variable refers to the CharParams object, which contains the character parameters that should be associated with the newly created text. This parameter may be 0, in which case the default character parameters will be used.

result

[out, retval] A pointer to the IText* pointer variable that receives the interface pointer of the newly created Text object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

Text


CreateTrainingBatch Method of the Engine Object

API Reference > Objects > Engine >

CreateTrainingBatch Method of the Engine Object

This method creates the TrainingBatch object.

Syntax

Visual Basic .NET

Function CreateTrainingBatch( _
path As String, _
language As String _
) As TrainingBatch

C++

HRESULT CreateTrainingBatch(
BSTR path,
BSTR language,
ITrainingBatch** result
);

Parameters

path

[in] This variable specifies the full path to the folder, where the batch should be stored.

language

[in] This variable specifies the language to be used during recognition.

result

[out, retval] A pointer to the ITrainingBatch* pointer variable that receives the interface pointer of the created TrainingBatch object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

TrainingBatch


CreateVerificationSession Method of the Engine Object

API Reference > Objects > Engine >

CreateVerificationSession Method of the Engine Object

This method creates the VerificationSession object that can be used with documents returned by FlexiCapture Processor.

Syntax

Visual Basic .NET

Function CreateVerificationSession(charParams As DocumentsCollection) As VerificationSession

C++

HRESULT CreateVerificationSession(
IDocumentsCollection* documents,
IVerificationSession** result
);

Parameters

documents

[in] This variable refers to the DocumentsCollection object, which contains a collection of documents to be verified.

result

[out, retval] Returns the newly created VerificationSession object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

VerificationSession

Verifying Recognized Data

See sample: FlexiCapture Engine Code Snippets


EnableRecognitionVariants Method of the Engine Object

API Reference > Objects > Engine >

EnableRecognitionVariants Method of the Engine Object

This method enables or disables collecting information about recognition variants during recognition.

note Note: The API working with recognition variants is not available for recognizing handprinted texts.

Syntax

Visual Basic .NET

Sub EnableRecognitionVariants(Value As Boolean)

C++

HRESULT EnableRecognitionVariants(
VARIANT_BOOL Value
);

Parameters

Value

[in] This variable of the Boolean type specifies whether collecting information about recognition variants is enabled. If you pass TRUE in this parameter, this will instruct FlexiCapture Engine to save recognition variants in the recognition results. If you pass FALSE, the only one recognition variant will be available.

warning Important! Setting the value to TRUE requires the Verification module to be available in your license.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

See sample: FlexiCapture Engine Code Snippets


LoadImageDocFromFile Method of the Engine Object

API Reference > Objects > Engine >

LoadImageDocFromFile Method of the Engine Object

This method restores the contents of the ImageDocument object from the file.

The method can be used for transferring the ImageDocument object from ABBYY FineReader Engine to ABBYY FlexiCapture Engine, and vice versa.

Syntax

Visual Basic .NET

Function LoadImageDocFromFile(fileName As String) As ImageDocument

C++

HRESULT LoadImageDocFromFile(
BSTR fileName,
IImageDocument** result
);

Parameters

fileName

[in] This parameter specifies the full path to the file with the contents of the ImageDocument object.

result

[out, retval] A pointer to IImageDocument* pointer variable that receives the interface pointer of the resulting ImageDocument object. Must not be NULL.

Return values

This method has no specific return values. It returns standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine ImageDocument::SaveToFile


LoadImageDocFromMemory Method of the Engine Object

API Reference > Objects > Engine >

LoadImageDocFromMemory Method of the Engine Object

This method restores the contents of the ImageDocument object from the global memory. The method takes as an input parameter an HGLOBAL handle of the memory block from where the object's contents should be loaded. This handle should be obtained from the HandleAsInt64 property of the Handle object returned by the IImageDocument::SaveToMemory method.

The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa. It also can be used for passing images between different processes.

Syntax

C++

HRESULT LoadImageDocFromMemory(
__int64 HGlobal,
IImageDocument** Result
);

C#

ImageDocument LoadImageDocFromMemory( Int64 HGlobal);

Visual Basic .NET

Function LoadImageDocFromMemory( HGlobal As Int64 ) As ImageDocument

Parameters

hGlobal

[in] This parameter specifies the HGLOBAL handle of the memory block from where the object's contents should be loaded. The handle is passed as __int64. This handle should be obtained from the IImageDocument::SaveToMemory method, and should be valid (not freed).

result

[out, retval] A pointer to IImageDocument* pointer variable that receives the interface pointer of the resulting ImageDocument object. Must not be NULL.

Return values

This method has no specific return values. It returns standard return values of ABBYY FlexiCapture Engine functions.

Remarks

·The size of the memory area that the object allocates can be obtained by calling the GlobalSize function.

·This method does not work if the Engine object is created using the OutprocLoader object.

See also

Engine

IImageDocument::SaveToMemory


LoadImageDocument Method of the Engine Object

API Reference > Objects > Engine >

LoadImageDocument Method of the Engine Object

This method restores the contents of the ImageDocument object from a folder on disk. The contents must be saved to disk with the help of the IImageDocument::SaveTo method of ABBYY FlexiCapture Engine library or IImageDocument::SaveTo method of ABBYY FineReader Engine library.

The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa.

Syntax

Visual Basic .NET

Function LoadImageDocument(path As String) As ImageDocument

C++

HRESULT LoadImageDocument(
BSTR path,
IImageDocument** result
);

Parameters

path

[in] This parameter specifies the full path to the folder with the contents of the ImageDocument object.

result

[out, retval] A pointer to IImageDocument* pointer variable that receives the interface pointer of the resulting ImageDocument object. Must not be NULL.

Return values

This method has no specific return values. It returns standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

IImageDocument::SaveTo


LogUnreleasedObjects Method of the Engine Object

API Reference > Objects > Engine >

LogUnreleasedObjects Method of the Engine Object

This method writes to the log file a list of objects that are not currently deleted. The method can be called any time when necessary.

note Note: This method is available only with programming languages which do not have garbage collection (for example, C++).

Syntax

Visual Basic .NET

Sub LogUnreleasedObjects()

C++

HRESULT LogUnreleasedObjects();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

IEngine::StartLogging

IEngine::StopLogging


OpenProject Method of the Engine Object

API Reference > Objects > Engine >

OpenProject Method of the Engine Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to open a project. The project must be created in ABBYY FlexiCapture 12. The project folder must contain the project file (.fcproj file) and a folder containing Document Definitions.

note Note: ABBYY FlexiCapture Engine 12 works with projects created in ABBYY FlexiCapture 12 Release 2 Update 7, Build 12.0.2.3042, or earlier. Projects saved in the current version of ABBYY FlexiCapture Engine 12 can be used in ABBYY FlexiCapture 12 Release 2 Update 7, Build 12.0.2.3042, or later. You can also pass projects to and from ABBYY FlexiCapture 12 shipped with the current ABBYY FlexiCapture Engine 12 distribution.

warning Important! You must keep the reference to the Project object when any references to the objects of the project are used. If the reference to the Project object is released and its subobjects are still in use, errors may occur.

Syntax

Visual Basic .NET

Function OpenProject(Path As String) As Project

C++

HRESULT OpenProject(
BSTR Path,
IProject** Result
);

Parameters

Path

[in] This variable contains the full path to the project file (.fcproj file). For example "D:\TestProject\TestProject.fcproj".

Result

[out, retval] A pointer to the IProject* pointer variable that receives the interface pointer to the resulting Project object. Must not be NULL.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
...

See also

Engine

Project

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


OpenTrainingBatch Method of the Engine Object

API Reference > Objects > Engine >

OpenTrainingBatch Method of the Engine Object

This method opens an existing training batch.

Syntax

Visual Basic .NET

Function OpenTrainingBatch( path As String ) As TrainingBatch

C++

HRESULT OpenTrainingBatch(
BSTR path,
ITrainingBatch** result
);

Parameters

path

[in] This variable specifies the full path to the folder, where the training batch is stored.

result

[out, retval] A pointer to the ITrainingBatch* pointer variable that receives the interface pointer of the created TrainingBatch object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

TrainingBatch


SetCurrentLicense Method of Engine Object

SetCurrentLicense Method of the Engine Object

API Reference > Objects > Engine >

SetCurrentLicense Method of the Engine Object

This method sets the current license.

warning Important! All the ABBYY FlexiCapture Engine objects which were in use before this method call become invalid (except the current Engine object and the License object, which was passed to this method). The only thing that you can do with these objects is to call Release method for them.

Syntax

Visual Basic .NET

Sub SetCurrentLicense( _
TargetLicense As License, _
CustomerProjectId As String _
)

C++

HRESULT SetCurrentLicense(
ILicense* TargetLicense,
BSTR CustomerProjectId
);

Parameters

TargetLicense

[in] This parameter refers to the License object representing the license. Any object from the IEngine::Licenses collection can be passed to this parameter.

CustomerProjectId

[in] This variable contains Customer Project ID number that matches the necessary license. Customer Project ID is an alphanumeric string shared by all the Developer and Runtime licenses in one project.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine


StartLogging Method of the Engine Object

API Reference > Objects > Engine >

StartLogging Method of the Engine Object

This method enables logging of errors, warnings and method calls.

Syntax

Visual Basic .NET

Sub StartLogging( _
LogFileName As String, _
WriteMethodCalls As Boolean _
)

C++

HRESULT StartLogging(
BSTR LogFileName,
VARIANT_BOOL WriteMethodCalls
);

Parameters

LogFileName

[in] This parameter contains the full path to the log file. If the file does not exist, it will be created.

WriteMethodCalls

[in] This parameter enables logging calls of ABBYY FlexiCapture Engine methods to the log file. The format is as follows:

<time of call>, <duration of execution (in ms)>, <Interface::Method (parameter1, … )>

For example, 12:40:31.254, 17 ms, ITextRecognitionParams::put_OneWordPerLine( VARIANT_TRUE )

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The log file can contain a list of objects that have not been deleted before the deinitialization of the Engine object. To do this, do not call the StopLogging method which disables logging, before the deinitialization.

See also

Engine

IEngine::StopLogging


StopLogging Method of the Engine Object

API Reference > Objects > Engine >

StopLogging Method of the Engine Object

This method disables logging of errors, warnings and method calls.

Syntax

Visual Basic .NET

Sub StopLogging()

C++

HRESULT StopLogging();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine

IEngine::StartLogging


WarmUp Method of the Engine Object

API Reference > Objects > Engine >

WarmUp Method of the Engine Object

This method loads and initializes most delay-loaded resources.

Syntax

Visual Basic .NET

Sub WarmUp()

C++

HRESULT WarmUp();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Engine


Engine Loaders

API Reference > Objects >

Engine Loaders

This section describes the interfaces and objects which can be used for loading and unloading the Engine object. ABBYY FlexiCapture Engine provides several ways to load the Engine object. The detailed description of these ways you can find in the Different Ways to Load the Engine Object section.

This section describes the following objects and interfaces:

·IEngineLoader

·InprocLoader

·OutprocLoader

·IWorkProcessControl


IEngineLoader Interface

API Reference > Objects > Engine Loaders >

IEngineLoader Interface

This interface is returned as a pointer by the GetEngineLoader function and is used to load and unload the Engine object. Its properties provide easy access to cloud licensing if needed and also allows you to specify some additional parameters of the Engine object. One of the properties is the Customer Project ID number, which is an alphanumeric string common to all the Developer and Runtime licenses your project uses.

note Note: During library initialization the list of all available licenses is searched for a Developer or Runtime License corresponding to this Customer Project ID. If no corresponding license is found, an error for the last checked license will occur. However, you may pass 0 for this parameter and select the license later, by calling the IEngine::SetCurrentLicense method before any other library methods.

The methods of the IEngineLoader interface expands the use of ABBYY FlexiCapture Engine in multi-threaded applications. For more information, please refer to the Different Ways to Load the Engine Object section.

This interface is available in the InprocLoader and OutprocLoader objects, which allow you to load ABBYY FlexiCapture Engine by means of COM either as an in-process server into the current process or as an out-of-process server into a separate process.

Please note that you must keep the reference to the loader object until you finish working with the Engine. You can then call the Unload method of the loader object to deinitialize the Engine, and then destroy the loader object.

Properties

Name | Type | Description
AppDataPath | String | Contains the path to the folder, in which ABBYY FlexiCapture Engine should store user-specific data. By default, it is the FlexiCapture Engine data folder (%ProgramData%\ABBYY\SDK\12\FlexiCapture Engine for automatic installation). You may need to change the default value, for example, if the interface language settings for your application must be different from other applications that use FlexiCapture Engine.
CustomerProjectId | String | A string containing the Customer Project ID.
LicensePassword | String | The cloud license password. If you do not use a cloud license, set this property to an empty string "" or Null.
LicensePath | String | The path to the cloud license file. If you do not use a cloud license, set this property to an empty string "" or Null.

Methods

Name | Description
GetEngine | Loads an instance of ABBYY FlexiCapture Engine.
Load | note Note: This method is deprecated and will be removed in future versions. To load an instance of the Engine object use the IEngineLoader::GetEngine method. Loads an instance of ABBYY FlexiCapture Engine.
Unload | Unloads ABBYY FlexiCapture Engine.

See also

InprocLoader

OutprocLoader

Different Ways to Load Engine Object

Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool


GetEngine Method

API Reference > Objects > Engine Loaders > IEngineLoader >

GetEngine Method

This method allows you to get a pointer to the IEngine interface.

Syntax

Visual Basic .NET

Function GetEngine() As Engine

C++

HRESULT GetEngine( IEngine** Result );

Parameters

Result

[out, retval] A pointer to IEngine* pointer variable that receives the interface pointer to the resulting Engine object.

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IEngineLoader

Different Ways to Load the Engine Object

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Web Service, Mobile Data Capture, Color Stamps Removal, Redaction


Load Method of the IEngineLoader Interface

API Reference > Objects > Engine Loaders > IEngineLoader >

Load Method of the IEngineLoader Interface

note Note: This method is deprecated and will be removed in future versions. To load an instance of the Engine object use the IEngineLoader::GetEngine method.

This method allows you to get a pointer to the IEngine interface. It requires as an input parameter the Customer Project ID number, which is an alphanumeric string common to all the Developer and Runtime licenses your project uses. You may pass the Customer Project ID number to this function, or specify it later with the help of the IEngine::SetCurrentLicense method.

As implemented in the InprocLoader object, the method loads ABBYY FlexiCapture Engine as an in-process server into the current process. As implemented in the OutprocLoader object, the method loads ABBYY FlexiCapture Engine as an out-of-process server into a separate process.

Syntax

Visual Basic .NET

Function Load( _
ByVal CustomerProjectId As String, _
ByVal AppDataPath As String, _
) As Engine

C++

HRESULT Load(
BSTR CustomerProjectId,
BSTR AppDataPath,
IEngine** Result
);

Parameters

CustomerProjectId

[in] A string containing Customer Project ID number that matches the necessary license. This parameter may be 0 or an empty string. In this case, you will have to specify the correct Customer Project ID later, but before the call to any of the processing methods, using the IEngine::SetCurrentLicense method.

AppDataPath

[in] The path to the folder where the application data is stored. FlexiCapture Engine stores some user-specific data in this folder, therefore this folder should be accessible for reading and writing. For example, you can specify the path to the FlexiCapture Engine data folder as this parameter. If you pass an empty string "" for this parameter, temporary data will be stored in the %TEMP% folder, and all other data will be stored in the FlexiCapture Engine data folder.

Result

[out, retval] A pointer to the IEngine* pointer variable that receives the interface pointer to the resulting Engine object.

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IEngineLoader

InitializeEngine

InitializeEngineEx

Different Ways to Load the Engine Object

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool


Unload Method of the IEngineLoader Interface

API Reference > Objects > Engine Loaders > IEngineLoader >

Unload Method of the IEngineLoader Interface

This method deinitializes ABBYY FlexiCapture Engine 12. It unloads FlexiCapture Engine and frees up resources.

Syntax

Visual Basic .NET

Sub Unload()

C++

HRESULT Unload();

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IEngineLoader

DeinitializeEngine

Different Ways to Load the Engine Object

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool


InprocLoader Object

API Reference > Objects > Engine Loaders >

InprocLoader Object

This object implements the IEngineLoader interface, which provides methods for loading and unloading the Engine object. This object allows you to load ABBYY FlexiCapture Engine as an in-process server into the current process.

Please note that you must keep the reference to the loader object until you finish working with the Engine. You can then call the Unload method of the loader object to deinitialize the Engine, and then destroy the loader object.

If this loading method is used, all ABBYY FlexiCapture Engine objects are completely thread-safe. They can be created and used in different threads. When working with objects from the Main STA apartment, the performance of the application remains the same as when working with naked interfaces (if standard loading by means of the InitializeEngine or InitializeEngineEx is used). When accessing from different threads, some marshalling losses may occur, which are small in most scenarios.

warning Important! This loading method requires registration of FCEngine.dll when installing the application on an end user's computer. To register FCEngine.dll, use the following command line:

regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FCEngine.dll>"

For more information, see Different Ways to Load the Engine Object.

Samples

cicon2 C# code

IEngineLoader engineLoader = new FCEngine.InprocLoader();
IEngine engine = engineLoader.Load(…);
try {
…
} finally {
engineLoader.Unload();
}

See also

IEngineLoader

Different Ways to Load the Engine Object

See sample: FlexiCapture Engine Code Snippets


OutprocLoader Object

API Reference > Objects > Engine Loaders >

OutprocLoader Object

This object implements the IEngineLoader which provides methods for loading and unloading the Engine object. This object allows you to load ABBYY FlexiCapture Engine as an out-of-process server into a separate process.

Please note that you must keep the reference to the loader object until you finish working with the Engine. You can then call the Unload method of the loader object to deinitialize the Engine, and then destroy the loader object.

If this loading method is used, all ABBYY FlexiCapture Engine are completely thread-safe. Each ABBYY FlexiCapture Engine instance runs in a separate process simultaneously with other instances. This allows you to create a pool of processors and make full use of the available CPU power. For this reason, using the OutprocLoader object is particularly suitable for server applications.

warning Important!

·This loading method requires registration of FCEngine.dll when installing the application on an end user's computer. To register FCEngine.dll when installing your application on an end-user computer, use the following command line:

regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FCEngine.dll>"

·Account permissions can be set up using the DCOM Config utility (either type DCOMCNFG in the command line, or select Control Panel > Administrative Tools > Component Services). In the console tree, locate the Component Services > Computers > My Computer > DCOM Config folder, right-click ABBYY FlexiCapture Engine 12 Loader (Local Server), and click Properties. A dialog box will open. Click the Security tab. Under Launch Permissions, click Customize, and then click Edit to specify the accounts that can launch the application.

Note that on a 64-bit operating system the registered DCOM-application is available in the 32-bit MMC console, which can be run using the following command line:

"mmc comexp.msc /32"

·We recommend that you use a Network License both for debugging your server application and for running it.

For more information, see Different Ways to Load the Engine Object.

This object supports the IWorkProcessControl interface. This means that the work process can control whether its parent process is alive and terminate if it is not.

Samples

cicon2 C# code

IEngineLoader engineLoader = new FCEngine.OutprocLoader();
IEngine engine = engineLoader.Load(…);
try {
…
} finally {
engineLoader.Unload();
}

See also

IEngineLoader

Different Ways to Load the Engine Object

Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications

See sample: FlexiCapture Engine Code Snippets


IWorkProcessControl Interface

API Reference > Objects > Engine Loaders >

IWorkProcessControl Interface

This interface is used by a work process to control whether its parent process is alive. This interface can be requested from the OutprocLoader object in order to:

·obtain the ID of the host process,

·manage the priority of the work process (by default it is Below Normal),

·set the identifier of the parent process.

When a process finishes normally, all COM objects are released and work processes hosting these objects also finish normally. If process terminates abnormally (hard exception or manually killed) the COM objects are not released and work process will remain loaded. To address this issue and make your server more robust you can make the work process watch if its parent process is still alive and terminate if not.

Methods

Name

Description

GetWorkProcessId

Returns the ID of the process which hosts FlexiCapture Engine. The program which uses FlexiCapture Engine can control whether the host process is alive and can terminate the process if necessary.

note Note: It is important to obtain the identifier of the process first, and only then start the work with FlexiCapture Engine. This is due to the fact that all FlexiCapture Engine method calls are performed sequentially, therefore, when FlexiCapture Engine is not responding, the call to this method will remain in the queue and will not finish too.

SetParentProcessId

Sets the id of the parent process for the work process. When the parent process terminates all its work processes will also terminate.

SetPriorityClass

Sets the priority class for the work process.

Samples

cicon2 C# code

IEngineLoader engineLoader = new FCEngine.OutprocLoader();
IWorkProcessControl workProcess = (IWorkProcessControl)engineLoader;
workProcess.SetParentProcessId( Process.GetCurrentProcess().Id );

See also

OutprocLoader

Different Ways to Load Engine Object

Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications

See sample: FlexiCapture Engine Code Snippets


GetWorkProcessId Method of the IWorkProcessControl Interface

API Reference > Objects > Engine Loaders > IWorkProcessControl >

GetWorkProcessId Method of the IWorkProcessControl Interface

Returns the ID of the process which hosts FlexiCapture Engine. The program which uses FlexiCapture Engine can control whether the host process is alive and can terminate the process if necessary.

note Note: It is important to obtain the identifier of the process first, and only then start the work with FlexiCapture Engine. This is due to the fact that all FlexiCapture Engine method calls are performed sequentially, therefore, when FlexiCapture Engine is not responding, the call to this method will remain in the queue and will not finish too.

Syntax

Visual Basic .NET

Function GetWorkProcessId() As Integer

C++

HRESULT GetWorkProcessId(
int* Result
);

Parameters

Result

[out, retval] This parameter contains the identifier of the host process.

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IWorkProcessControl

OutprocLoader

Different Ways to Load the Engine Object

See sample: FlexiCapture Engine Code Snippets


SetParentProcessId Method of the IWorkProcessControl Interface

API Reference > Objects > Engine Loaders > IWorkProcessControl >

SetParentProcessId Method of the IWorkProcessControl Interface

This method sets the identifier of the parent process for the work process. When the parent process terminates all its work processes will also terminate.

Syntax

Visual Basic .NET

Sub SetParentProcessId(ByVal Id As Int)

C++

HRESULT SetParentProcessId(
int Id
);

Parameters

Id

[in] This parameter contains the identifier of the parent process.

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IWorkProcessControl

OutprocLoader

Different Ways to Load the Engine Object

See sample: FlexiCapture Engine Code Snippets


SetPriorityClass Method of the IWorkProcessControl Interface

API Reference > Objects > Engine Loaders > IWorkProcessControl >

SetPriorityClass Method of the IWorkProcessControl Interface

This method sets the priority class for the work process. By default, the priority class is Below Normal.

Syntax

Visual Basic .NET

Sub SetPriorityClass(ByVal dwPriorityClass As Int)

C++

HRESULT SetPriorityClass(
int dwPriorityClass
);

Parameters

dwPriorityClass

[in] This parameter specifies the priority class for the work process. This parameter can have the same values as this parameter in the SetPriorityClass Function in the Windows API.

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IWorkProcessControl

OutprocLoader

Different Ways to Load the Engine Object


FlexiCaptureProcessor Object and Related Interfaces

API Reference > Objects >

FlexiCaptureProcessor Object and Related Interfaces

The FlexiCaptureProcessor object is a processor object which converts input images into the FlexiCapture documents (Document objects). This object provides you rich opportunities for customizing document processing. You may implement custom source of images, organize work with a remote storage.

This section describes the FlexiCaptureProcessor object and related interfaces:

·FlexiCaptureProcessor

·IImageSource

·IFileAdapter

·IProcessingError

·IReadStream

·IWriteStream

·IReferenceManager

·ICustomStorage

·ClassificationResult

·ClassConfidence

·ClassConfidences

·ClassificationTree

You can find additional information in the Processing with a Customizable Processor Object section of the Tutorial. And some advanced information in the Setting Up a Custom Image Source and Custom Resolution of References sections.


FlexiCaptureProcessor Object

FlexiCaptureProcessor Object (IFlexiCaptureProcessor Interface)

API Reference > Objects > FlexiCapture Processor >

FlexiCaptureProcessor Object (IFlexiCaptureProcessor Interface)

This is a processor object which converts input images into the FlexiCapture documents (Document objects).

The processor works as follows:

1.It gets images as input. By default, images added for processing are stored in the internal processing queue. However, if required, you can easily implement your own external image queue.

2.The processor is configured with FlexiCapture Document Definitions and processing parameters.

3.The processor outputs FlexiCapture documents. Documents created by the processor are not bound to any batch or storage location but exist as isolated objects in memory.

4.The user may either immediately export a document to a destination format without saving it or organize its storage using the means provided for reading and writing documents onto a disk or into a stream.

To receive the FlexiCaptureProcessor object, call the CreateFlexiCaptureProcessor method of the Engine object.

warning Important! You will need to initialize the COM library by the call to the CoInitialize/CoInitializeEx function before starting to work with FlexiCapture Processor. See the details about COM initialization functions on http://msdn.microsoft.com.

Methods

Name | Description
AddClassificationTree | Adds a classification tree represented by a ClassificationTree object to an internal processing list. The added classification tree can then be used for processing. Such trees may speed up the selection of a Document Definition to be matched. note Note: This functionality is available only for rules-based classification.
AddClassificationTreeFile | Adds a classification tree represented by *.cfl file to an internal processing list. The added classification tree can then be used for processing. Such trees may speed up the selection of a Document Definition to be matched. note Note: This functionality is available only for rules-based classification.
AddDocumentDefinition | Adds a Document Definition, represented by a DocumentDefinition object, to an internal processing list. The added Document Definition can then be used for processing.
AddDocumentDefinitionFile | Adds a Document Definition from an *.fcdot file to an internal processing list. The added Document Definition can then be used for processing.
AddImage | Adds an image to the internal processing queue.
AddImageDocument | Adds a preprocessed image to the internal processing queue.
AddImageFile | Adds a reference to an image file to the internal processing queue.
CreateDocument | Creates a document in memory which will which will use current reference manager.
ClassifyNextPage | Performs a single classification step on the processing queue. note Note: This functionality is available only for rules-based classification.
ExportDocument | Exports recognized document using export settings from the corresponding Document Definition.
ExportDocumentEx | Exports recognized document using specified export settings. If export settings is null, the document is exported in XML format with default settings.
ExportDocumentToMemory | Exports recognized document to memory using specified export settings. If export settings is null, the document is exported in XML format with default settings.
GetLastProcessingError | Provides the description of the error occurred during the last processing step.
PrepareProcessing | Prepares FlexiCapture processor for work by preloading all Document Definitions in memory and performing all required configuration steps.
RecognizeNextDocument | Performs a single recognition step on the processing queue. During one recognition step the processor tries to find in its internal storage a Document Definition that can be applied to one or several first images in the processing queue, then applies the appropriate Document Definition, recognizes data, and creates a document.
ResetProcessing | Resets processing, but keeps processor configuration. After this method call the processing queue is empty, information about the last error is deleted, but all the settings are preserved, including added document definitions and classification trees.
ResumeProcessing | Resumes processing after an error has been handled. You can specify whether the processor should try to repeat the last processing step. If you do not call this method after an error has been handled, processing will be resumed from the next image in the queue.
SetAssemblingMode | Sets the rule for assembling image pages into documents. By default, images are assembled into documents automatically using document definitions.
SetCustomImageSource | Sets a custom source of images. If a custom image source is not set, images are added to the internal processing queue. If custom source is set, the internal processing queue is ignored.
SetDeleteBlankPages | Specifies if blank pages should be deleted during processing.
SetForceApplyDocumentDefinition | Allows you to set whether the Document Definition should be applied forcibly. It can be used only when you have just one Document Definition loaded for processing. If you set this option, the processor will try to apply the definition even if some element of the Document Definition was not found on the images. By default, document definitions are not applied forcibly. This setting is intended for use with one-page documents only.
SetImageLoadingParams | Allows you to specify how input images should be prepared before processing. The images can be rotated, mirrored, cleaned up from noise, etc.
SetReferenceManager | Sets a custom reference manager. By default, string references to Document Definitions, images, etc. are interpreted as references to files in the file system. If a custom reference manager is set, references are resolved by this manager.
SetUseFirstMatchedDocumentDefinition | Allows you to make the processor use the first matching Document Definition. Otherwise, the processor will attempt to apply each of the Document Definitions and then select the best match.

Output parameter

This object is the output parameter of the CreateFlexiCaptureProcessor method of the Engine object.

Remarks

The internal processing queue works in the following way:

·When the image is added using the AddImageFile method, the path to the image file is added to the internal queue.

·During one processing step, the path to the next image is retrieved and removed from the queue, and the actual image is loaded into memory.

·The image is not kept in memory any longer than it is required for processing. However, the RecognizeNextDocument method returns the Document object which contains a copy of the image.

There is no way of deleting individual enqueued images from the internal queue. You can clear up the entire queue by calling the ResetProcessing method.

For details on implementing your own image source, please see the Setting Up a Custom Image Source section of the Guided Tour.

See also

Processing with a Customizable Processor Object

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing, Mobile Data Capture, Color Stamps Removal, Redaction


AddClassificationTree Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

AddClassificationTree Method of the FlexiCaptureProcessor Object

note Note: This functionality is available only for rules-based classification.
This method adds a classification tree represented by a ClassificationTree object to an internal processing list. The added classification tree can then be used for processing.

note Note: Loading the classification tree with the help of the LoadFromFile or LoadFromStream method is required before you start working with the classification tree in any way.

You can also add the classification tree directly from the *.cfl file using the AddClassificationTreeFile method.

Syntax

Visual Basic .NET

Sub AddClassificationTree(classificationTree As ClassificationTree)

C++

HRESULT AddClassificationTree(
IClassificationTree* classificationTree
);

Parameters

classificationTree

[in] This variable refers to the ClassificationTree object which represents the classifier tree to be added for processing.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

IFlexiCaptureProcessor::AddClassificationTreeFile

IFlexiCaptureProcessor::ClassifyNextPage


AddClassificationTreeFile Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

AddClassificationTreeFile Method of the FlexiCaptureProcessor Object

note Note: This functionality is available only for rules-based classification.

This method adds a classification tree from *.cfl file to an internal processing list. The added classification tree can then be used for processing.

A classifier tree is used for preliminary identification of individual pages and classifying them as belonging to a particular type. Classification tree can be created in ABBYY FlexiLayout Studio or using the TrainingClassifier object.

Classifier trees may be used for the following purposes:

·To speed up the selection of a Document Definition to be matched. The use of a classifier tree prevents going through all Document Definitions one by one in search for the best match. Instead, the program can select the matching Document Definition based on the classifying attributes. The order of the search is determined by the user, who selects the appropriate classifying attributes and builds a classifier tree. Speed gains are most noticeable when using large number of Document Definitions.

·To speed up processing Document Definitions in different languages. If a classifier tree is used, instead of using all the languages of all the Document Definitions, the program will pre-recognize the documents twice: first, when classifying them and then when matching them with the selected Document Definition.

·To classify images without recognizing them. If you need only to divide a set of images into groups corresponding to different types, you don't have to run the recognition process, which takes time. Instead, you can use classifier tree to determine which Document Definition is the most probable for this image, and return this as the result of classification.

Syntax

Visual Basic .NET

Sub AddClassificationTreeFile(filePath As String)

C++

HRESULT AddClassificationTreeFile(
BSTR filePath
);

Parameters

filePath

[in] This variable specifies the full path to the *.cfl file, which contains the classifier tree to be added.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

IFlexiCaptureProcessor::AddClassificationTree

IFlexiCaptureProcessor::ClassifyNextPage


AddDocumentDefinition Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

AddDocumentDefinition Method of the FlexiCaptureProcessor Object

This method adds a Document Definition, represented by a DocumentDefinition object, to an internal processing list. The added Document Definition can then be used for processing.

Syntax

Visual Basic .NET

Sub AddDocumentDefinition(documentDefinition As DocumentDefinition)

C++

HRESULT AddDocumentDefinition(
IDocumentDefinition* documentDefinition
);

Parameters

documentDefinition

[in] This variable refers to the DocumentDefinition object which is to be added.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

DocumentDefinition

Processing with a Customizable Processor Object


AddDocumentDefinitionFile Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

AddDocumentDefinitionFile Method of the FlexiCaptureProcessor Object

This method adds a Document Definition from an *.fcdot file to an internal processing list. The added Document Definition can then be used for processing.

Syntax

Visual Basic .NET

Sub AddDocumentDefinitionFile(filePath As String)

C++

HRESULT AddDocumentDefinitionFile(
BSTR filePath
);

Parameters

filePath

[in] This variable contains the full path to the *.fcdot file, which contains the Document Definition.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing, Mobile Data Capture, Color Stamps Removal


AddImage Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

AddImage Method of the FlexiCaptureProcessor Object

This method adds an image to the internal processing queue.

Syntax

Visual Basic .NET

Sub AddImage(image As Image)

C++

HRESULT AddImage(
IImage* image
);

Parameters

image

[in] Refers to the Image object, which contains an image to be added.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor


AddImageDocument Method

AddImageDocument Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

AddImageDocument Method of the FlexiCaptureProcessor Object

This method adds a preprocessed image to the internal processing queue.

Syntax

Visual Basic .NET

Sub AddImageDocument(image As ImageDocument)

C++

HRESULT AddImageDocument(
IImageDocument* image
);

Parameters

image

[in] Refers to the ImageDocument object, which contains a preprocessed image to be added.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor


AddImageFile Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

AddImageFile Method of the FlexiCaptureProcessor Object

This method adds a reference to an image file to the internal processing queue.

By default, source images are added into the internal processing queue of the processor as references to the corresponding files. However, if required, you can easily implement your own external image queue (see the description of the IFlexiCaptureProcessor::SetCustomImageSource method).

Syntax

Visual Basic .NET

Sub AddImageFile(filePath As String)

C++

HRESULT AddImageFile(
BSTR filePath
);

Parameters

filePath

[in] This variable contains the full path to an image file. See the list of supported image formats.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

Supported Image Formats

IFlexiCaptureProcessor::SetCustomImageSource

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Web Service, Mobile Data Capture, Redaction


ClassifyNextPage Method of FlexiCaptureProcessor Object

ClassifyNextPage Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

ClassifyNextPage Method of the FlexiCaptureProcessor Object

note Note: This functionality is available only for rules-based classification.

This method classifies the next image in queue according to the classification tree loaded for the processor. The result is available through the ClassificationResult object, which contains the type of page and possible class names for this page. This method allows you to classify images without recognizing them, speeding up the classification process.

Before you call this method, you need to configure image source and add a classification tree using the AddClassificationTree or AddClassificationTreeFile method of the FlexiCaptureProcessor object. You can create a classification tree in ABBYY FlexiLayout Studio or using the TrainingClassifier object.

note Note: You don't have to add Document Definitions, as this method does not recognize pages but only classifies them.

Syntax

Visual Basic .NET

Function ClassifyNextPage() As ClassificationResult

C++

HRESULT ClassifyNextPage(
IClassificationResult** result
);

Parameters

result

[out, retval] A pointer to the IClassificationResult* variable that receives the interface pointer for the ClassificationResult object containing results of the classifier's work.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

Creating Document Definitions by Training


CreateDocument Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

CreateDocument Method of the FlexiCaptureProcessor Object

note Note: This functionality is available only for rules-based classification.

This method creates a document in memory which will use current reference manager. This method can be used when loading a document from a custom storage.

Syntax

Visual Basic .NET

Function CreateDocument() As Document

C++

HRESULT CreateDocument(
IDocument** result
);

Parameters

result

[out, retval] A pointer to the IDocument* variable that provides access to the created document.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

See sample: FlexiCapture Engine Code Snippets


ExportDocument Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

ExportDocument Method of the FlexiCaptureProcessor Object

This method exports recognized document using export settings from the corresponding Document Definition.

Syntax

Visual Basic .NET

Sub ExportDocument( _
document As Document, _
exportRootFolder As String _
)

C++

HRESULT ExportDocument(
IDocument* document,
BSTR exportRootFolder
);

Parameters

document

[in] This variable refers to the Document object which is to be exported.

exportRootFolder

[in] This variable specifies the path to the folder to export document to. This parameter may be 0, in which case the root folder, specified in the export settings in the Document Definition, is used.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

Processing with a Customizable Processor Object

See sample: FlexiCapture Engine Code Snippets


ExportDocumentEx Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

ExportDocumentEx Method of the FlexiCaptureProcessor Object

This method exports recognized document using specified export settings. If export settings are not specified, the document is exported in XML format with default settings.

The chief difference between the result of this method call and that of the ExportDocument is that this method will only produce a single file. E.g. if you are exporting a database with related tables, you will only get the master table exported, its dependent tables will be missing.

note Note: You can also save unrecognized documents to an image format (including PDF) using this method.

Syntax

Visual Basic .NET

Sub ExportDocumentEx( _
document As Document, _
exportRootFolder As String, _
fileName As String, _
exportParams As FileExportParams _
)

C++

HRESULT ExportDocumentEx(
IDocument* document,
BSTR exportRootFolder,
BSTR fileName,
IFileExportParams* exportParams
);

Parameters

document

[in] This variable refers to the Document object which is to be exported.

exportRootFolder

[in] This variable specifies the full path to the folder to export document to. This parameter may be 0, in which case the root folder, specified in the exportParams, is used. (In this case the exportParams must be non-null).

fileName

[in] This variable specifies the name of the file to export document to. This parameter may be 0, in which case the file name, specified in the exportParams, is used. (In this case the exportParams must be non-null).

exportParams

[in] This variable refers to the FileExportParams object which specifies parameters of export. This parameter may be 0, in which case the document is exported in XML format with default settings.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

Processing with a Customizable Processor Object

See sample: Hello, FlexiCapture Engine Code Snippets, Redaction


ExportDocument Method of the FlexiCaptureProcessor Object

ExportDocumentToMemory Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

ExportDocumentToMemory Method of the FlexiCaptureProcessor Object

This method exports recognized document to memory using specified export settings. If export settings are not specified, the document is exported in XML format with default settings.

This method is similar to the ExportDocumentEx method in that in can only produce a single file. If, for example, you are exporting a database with related tables, you will only get the master table exported, its dependent tables will be missing. The difference from ExportDocumentEx is that the whole resulting file is saved as a string into memory.

warning Important! The document cannot be exported to memory in XLS format.

Syntax

Visual Basic .NET

String ExportDocumentToMemory( _
Document As Document, _
ExportParams As FileExportParams _
)

C++

HRESULT ExportDocumentToMemory(
IDocument* Document,
IFileExportParams* ExportParams,
BSTR* Result
);

Parameters

Document

[in] This variable refers to the Document object which is to be exported.

ExportParams

[in] This variable refers to the FileExportParams object which specifies parameters of export. This parameter may be 0, in which case the document is exported in XML format with default settings.

Result

[out, retval] This string variable contains the whole exported file.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

Processing with a Customizable Processor Object


GetLastProcessingError Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

GetLastProcessingError Method of the FlexiCaptureProcessor Object

This method provides the description of the error occurred during the last processing step. One processing step is performed by the IFlexiCaptureProcessor::RecognizeNextDocument method. We recommend that you call GetLastProcessingError method each time after you have called the RecognizeNextDocument method.

Syntax

Visual Basic .NET

Function GetLastProcessingError() As ProcessingError

C++

HRESULT GetLastProcessingError(
IProcessingError** error
);

Parameters

error

[out, retval] A pointer to the IProcessingError* variable that provides access to the description of the last processing error.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

After an error is handled, you may try to repeat the last processing step or resume processing from the next step (see the description of the ResumeProcessing method). Any time you may reset processing preserving all the settings (ResetProcessing method).

See also

FlexiCaptureProcessor

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing


PrepareProcessing Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

PrepareProcessing Method of the FlexiCaptureProcessor Object

This method prepares the FlexiCapture processor for work by preloading all Document Definitions in memory and performing all required configuration steps. This method is useful in server applications. It allows you to use background initialization when starting server application. After such initialization FlexiCapture processors are ready to work: the Document Definitions are loaded and the processors are warmed up.

Syntax

Visual Basic .NET

Sub PrepareProcessing()

C++

HRESULT PrepareProcessing();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

Using ABBYY FlexiCapture Engine in Multi-Threaded Server Applications

See sample: FlexiCapture Processors Pool


RecognizeNextDocument Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

RecognizeNextDocument Method of the FlexiCaptureProcessor Object

This method performs a single recognition step on the processing queue. During one recognition step the processor tries to find in its internal storage a Document Definition that can be applied to one or several first images in the processing queue, then applies the appropriate Document Definition, recognizes data, and creates a document.

note Note: Before you call this method, you must configure image source (add images into the internal queue or set custom image source), add necessary Document Definitions, and, if necessary, set processing options and add classification tree.

Syntax

Visual Basic .NET

Function RecognizeNextDocument() As Document

C++

HRESULT RecognizeNextDocument(
IDocument** result
);

Parameters

result

[out, retval] A pointer to the IDocument* variable that receives the interface pointer for the Document object corresponding to the output document.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To check if an error occurred during this processing step, call the IFlexiCaptureProcessor::GetLastProcessingError method. After an error is handled, you may try to repeat the last processing step or resume processing from the next step (see the description of the ResumeProcessing method). Any time you may reset processing preserving all the settings (ResetProcessing method).

See also

FlexiCaptureProcessor

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing, Mobile Data Capture, Color Stamps Removal, Redaction


ResetProcessing Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

ResetProcessing Method of the FlexiCaptureProcessor Object

This method resets processing, but keeps processor configuration. After this method call the processing queue is empty (and you may add new images to it), information about the last error is deleted, but all the settings are preserved, including added Document Definitions and classification trees.

Syntax

Visual Basic .NET

Sub ResetProcessing()

C++

HRESULT ResetProcessing();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

See sample: FlexiCapture Processors Pool, FlexiCapture Web Service, Mobile Data Capture, Color Stamps Removal, Redaction


ResumeProcessing Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

ResumeProcessing Method of the FlexiCaptureProcessor Object

This method resumes processing after an error has been handled. The parameter of this method specifies whether the processor should try to repeat the last processing step. If you do not call this method after an error has been handled, this method is called automatically with the FALSE parameter, and processing will be resumed from the next image in the queue.

Syntax

Visual Basic .NET

Sub ResumeProcessing(retry As Boolean)

C++

HRESULT ResumeProcessing(
VARIANT_BOOL retry
);

Parameters

retry

[in] This variable specifies whether the last processing step should be repeated.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

See sample: FlexiCapture Engine Code Snippets


SetAssemblingMode Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

SetAssemblingMode Method of the FlexiCaptureProcessor Object

This method defines the rule for assembling image pages into documents. By default, images are assembled into documents automatically using document definitions.

Syntax

Visual Basic .NET

Sub SetAssemblingMode(newValue As AssemblingModeEnum)

C++

HRESULT SetAssemblingMode(
AssemblingModeEnum newValue
);

Parameters

newValue

[in] This variable specifies the assembling mode. See the description of the AssemblingModeEnum constants.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

See sample: FlexiCapture Processors Pool, Multi-Core Processing


SetCustomImageSource Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

SetCustomImageSource Method of the FlexiCaptureProcessor Object

This method sets a custom source of images. If a custom image source is not set, images are added to the internal processing queue. If custom source is set, the internal processing queue is ignored.

When the internal processing queue is used, images are added to it by the user. Implementing custom source of images may be useful, if you intend the processing queue to request the next image and wait for its appearance, or if you want to use your own image storage and processing queue.

Syntax

Visual Basic .NET

Sub SetCustomImageSource(imageSource As ImageSource)

C++

HRESULT SetCustomImageSource(
IImageSource* imageSource
);

Parameters

imageSource

[in] This variable refers to the IImageSource interface which implements a custom image source.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing, Color Stamps Removal


SetDeleteBlankPages Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

SetDeleteBlankPages Method of the FlexiCaptureProcessor Object

This method specifies if blank pages should be deleted during processing.

Syntax

Visual Basic .NET

Sub SetDeleteBlankPages(newValue As Boolean)

C++

HRESULT SetDeleteBlankPages(
VARIANT_BOOL newValue
);

Parameters

newValue

[in] This variable specifies whether blank pages should be deleted during processing. Set this parameter to TRUE, if you wish blank pages to be deleted during processing.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor


SetForceApplyDocumentDefinition Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

SetForceApplyDocumentDefinition Method of the FlexiCaptureProcessor Object

This method allows you to set whether the Document Definition should be applied forcibly. It can be used only when you have just one Document Definition loaded for processing. If you set this option, the processor will try to apply this definition even if some element of the Document Definition was not found on the images. By default, a Document Definition is not applied forcibly.

This method is useful when a static element (e.g. separator) of the Document Definition was not found on the images, but the Document Definition still can be applied to the images (other fields and static elements were found).

warning Important! This method makes the processor apply the Document Definition to each page, and therefore this setting is only intended for use with one-page documents. If you process a multi-page document with this setting, it will probably be split into one-page documents.

Syntax

Visual Basic .NET

Sub SetForceApplyDocumentDefinition(forceApply As Boolean)

C++

HRESULT SetForceApplyDocumentDefinition(
VARIANT_BOOL forceApply
);

Parameters

forceApply

[in] This variable specifies whether the Document Definition should be applied forcibly.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor


SetImageLoadingParams Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

SetImageLoadingParams Method of the FlexiCaptureProcessor Object

This method allows you to specify how input images should be prepared before processing. The images can be rotated, mirrored, cleaned up from noise, etc.

Syntax

Visual Basic .NET

Sub SetImageLoadingParams(imageLoadingParams As ImageLoadingParams)

C++

HRESULT SetImageLoadingParams(
IImageLoadingParams* imageLoadingParams
);

Parameters

imageLoadingParams

[in] This variable refers to the ImageLoadingParams object which contains the parameters of image preprocessing.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

ImageLoadingParams

Processing with a Customizable Processor Object

See sample: FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing


SetReferenceManager Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

SetReferenceManager Method of the FlexiCaptureProcessor Object

This method sets a custom reference manager. By default, string references to Document Definitions, images, etc. are interpreted as references to files in the file system. If a custom reference manager is set, references are resolved by this manager either as a path to a file in the local file system or as the binary representation of the requested object in the form of a stream in memory. Custom reference manager may be used to organize work with a remote storage location accessed using any protocol.

Syntax

Visual Basic .NET

Sub SetReferenceManager(referenceManager As ReferenceManager)

C++

HRESULT SetReferenceManager(
IReferenceManager* referenceManager
);

Parameters

referenceManager

[in] This variable refers to the IReferenceManager interface which represents the custom reference manager.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor

IReferenceManager

Processing with a Customizable Processor Object

See sample: FlexiCapture Engine Code Snippets


SetUseFirstMatchedDocumentDefinition Method of the FlexiCaptureProcessor Object

API Reference > Objects > FlexiCapture Processor > FlexiCaptureProcessor >

SetUseFirstMatchedDocumentDefinition Method of the FlexiCaptureProcessor Object

This method allows you to make the processor use the first matching Document Definition. Otherwise, the processor will attempt to apply each of the Document Definitions from an internal processing list and then select the best match. You can make the processor use the first matching Document Definition, if you need to speed up Document Definition matching.

Syntax

Visual Basic .NET

Sub SetUseFirstMatchedDocumentDefinition(newValue As Boolean)

C++

HRESULT SetUseFirstMatchedDocumentDefinition(
VARIANT_BOOL newValue
);

Parameters

newValue

[in] This variable specifies whether the processor should use the first matching Document Definition. Set this parameter to TRUE, if you want to speed up Document Definition matching.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FlexiCaptureProcessor


IImageSource Interface

API Reference > Objects > FlexiCapture Processor >

IImageSource Interface

This is an interface for a custom image source. This interface and all its methods are implemented on the client side.

By default, the FlexiCapture processor works with images in the internal processing queue. Images are added into this queue as references to the corresponding files (push model). However, you can implement your own external image queue, which will either return references to files on demand (pull model) or, instead of references to files, provide the source images as a stream in memory (working with memory). Therefore, implementing your own image source is useful if you need the ability to request the next image and wait for it, or if you want to use your own image storage and processing queue.

This interface also allows you to perform some preprocessing on images before passing them to recognition. This can be done via the GetNextImage method. When processing images in an external queue, this method is called before the GetNextImageFile method. You can implement both these methods for selective preprocessing.

Methods

Name | Description
GetName | Returns the name of the source. This method can be used to track the origin of the input images.
GetNextImage | Returns the next preprocessed image from the external processing queue of the source. This method is useful if you need to perform some preprocessing on an image before passing it to recognition.
GetNextImageFile | Returns the next image file from the external processing queue of the source.

Input parameter

The SetCustomImageSource method of the FlexiCaptureProcessor object receives a pointer to this interface as an input parameter.

Samples

cicon2 C# code

// Procedure which sets a custom image source
// Create an instance of the FlexiCapture processor
...
// Set the custom image source
processor.SetCustomImageSource( new MyImageSource() );
// Run processing loop
...
// Sample implementation of a custom image source
class MyImageSource : IImageSource
{
...
// IImageSource ///////////////////
public string GetName() { return "Sample Image Source"; }
public IImage GetNextImage() { return null; }
public IFileAdapter GetNextImageFile()
{
if( hasMoreImages() ) {
return new FileAdapter( … );
}
return null;
}
class FileAdapter : IFileAdapter
{
// IFileAdapter ////////////////////
public FileMarshallingTypeEnum GetMarshallingType()
{
if( marshalByValue ) {
return FileMarshallingTypeEnum.FMT_MarshalByValue;
}
return FileMarshallingTypeEnum.FMT_MarshalByReference;
}
public string GetFileReference()
{
if( marshalByValue ) {
// Here we could use any string which is stored as the origin of
// the image file and not otherwise interpreted. An empty string would
// also be valid. In this sample, we return a reference to some source file
return fileReference;
} else {
// In this sample, we use the path in the file system, but we could
// use any kind of reference (for example, http://myimagesource/001.tif)
return fileReference;
}
}
public IReadStream GetFileStream()
{
if( marshalByValue ) {
return new ReadStream( … );
} else {
// This method is called only if marshaled by value
assert( false );
return null;
}
}
class ReadStream : IReadStream
{
public uint Read( IntPtr data, uint count )
{
// Read requested bytes count if marshaling by value
...
return readBytes;
}
}
};
};

See also

FlexiCaptureProcessor

Processing with a Customizable Processor Object

Setting Up a Custom Image Source

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing, Color Stamps Removal


GetName Method of IImageSource Interface

GetName Method of the IImageSource Interface

API Reference > Objects > FlexiCapture Processor > IImageSource >

GetName Method of the IImageSource Interface

This method is implemented on the client side. This method determines the name of the source. It can be used to track the origin of the input images.

Syntax

Visual Basic .NET

Function GetName() As String

C++

HRESULT GetName(
BSTR* result
);

Parameters

result

[out, retval] This parameter specifies the name of the source.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IImageSource


GetNextImage Method of IImageSource Interface

GetNextImage Method of the IImageSource Interface

API Reference > Objects > FlexiCapture Processor > IImageSource >

GetNextImage Method of the IImageSource Interface

This method is implemented on the client side. The method returns the next preprocessed image from the external processing queue of the source. This method is useful if you need to perform some preprocessing on an image before passing it to recognition. Implementation of this method can use methods of the ImageProcessingTools object or some user algorithms.

Syntax

Visual Basic .NET

Function GetNextImage() As Image

C++

HRESULT GetNextImage(
IImage** result
);

Parameters

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the next preprocessed image.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

Samples

cicon2 C# code

// Sample implementation of a custom image source
class CustomPreprocessingImageSource : IImageSource
{
public CustomPreprocessingImageSource( IEngine engine )
{
fileNames = new Queue();
imageTools = engine.CreateImageProcessingTools();
}
public void AddImageFile( string filePath )
{
fileNames.Enqueue( filePath );
}
// IImageSource ///////////////////
public string GetName() { return "Custom Preprocessing Image Source"; }
public IFileAdapter GetNextImageFile() { return null; } // This sample source does not use this feature
public IImage GetNextImage()
{
while( true ) {
if( imageFile == null ) {
if( fileNames.Count > 0 ) {
imageFile = imageTools.OpenImageFile( (string)fileNames.Dequeue() );
nextPageIndex = 0;
} else {
return null;
}
}
assert( imageFile != null );
if( nextPageIndex < imageFile.PagesCount ) {
IImage nextPage = imageFile.OpenImagePage( nextPageIndex++ );
// Here you can apply any preprocessing that is necessary
// ...
return nextPage;
} else {
imageFile = null;
continue;
}
}
}
IImageProcessingTools imageTools;
Queue fileNames;
IImageFile imageFile;
int nextPageIndex;
};

See also

IImageSource


GetNextImageFile Method of IImageSource Interface

GetNextImageFile Method of the IImageSource Interface

API Reference > Objects > FlexiCapture Processor > IImageSource >

GetNextImageFile Method of the IImageSource Interface

This method is implemented on the client side. The method returns the next image file from the external processing queue of the source.

Syntax

Visual Basic .NET

Function GetNextImageFile() As FileAdapter

C++

HRESULT GetNextImageFile(
IFileAdapter** result
);

Parameters

result

[out, retval] A pointer to the IFileAdapter* pointer variable that provides access to the next image file in the external queue.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

Samples

cicon2 C# code

// Sample implementation of a custom image source
class MyImageSource : IImageSource
{
...
// IImageSource ///////////////////
public string GetName() { return "Sample Image Source"; }
public IImage GetNextImage() { return null; }
public IFileAdapter GetNextImageFile()
{
if( hasMoreImages() ) {
return new FileAdapter( … );
}
return null;
}
class FileAdapter : IFileAdapter
{
// IFileAdapter ////////////////////
public FileMarshallingTypeEnum GetMarshallingType()
{
if( marshalByValue ) {
return FileMarshallingTypeEnum.FMT_MarshalByValue;
}
return FileMarshallingTypeEnum.FMT_MarshalByReference;
}
public string GetFileReference()
{
if( marshalByValue ) {
// Here we could use any string which is stored as the origin of
// the image file and not otherwise interpreted. An empty string would
// also be valid. In this sample, we return a reference to some source file
return fileReference;
} else {
// In this sample, we use the path in the file system, but we could
// use any kind of reference (for example, http://myimagesource/001.tif)
return fileReference;
}
}
public IReadStream GetFileStream()
{
if( marshalByValue ) {
return new ReadStream( … );
} else {
// This method is called only if marshaled by value
assert( false );
return null;
}
}
class ReadStream : IReadStream
{
public uint Read( IntPtr data, uint count )
{
// Read requested bytes count if marshaling by value
...
return readBytes;
}
}
};
};

See also

IImageSource

IFileAdapter


IFileAdapter Interface

API Reference > Objects > FlexiCapture Processor >

IFileAdapter Interface

This is the interface for a file adapter. This interface and all its methods are implemented on the client side.

The information provided by the adapter is handled as GetMarshallingType method defines. When marshalling by reference, the returned reference can be resolved by the specified reference manager, or by the file system. The file system is considered as the default reference manager if none is explicitly set. When marshalling by value, the associated stream of bytes is provided.

Methods

Name | Description
GetFileReference | Provides the reference to the file.
GetFileStream | Provides the stream of bytes associated with the file adapter. This method is called only if marshaled by value.
GetMarshallingType | Specifies how the information provided by the adapter is handled.

Output parameter

This interface pointer is returned by the following methods:

·GetNextImageFile method of the IImageSource interface.

·ResolveReference method of the IReferenceManager interface.

·ImageFile method of the IProcessingError interface.

See also

IImageSource

IReferenceManager

Processing with a Customizable Processor Object

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing


GetFileReference Method of IFileAdapter Interface

GetFileReference Method of the IFileAdapter Interface

API Reference > Objects > FlexiCapture Processor > IFileAdapter >

GetFileReference Method of the IFileAdapter Interface

This method is implemented on the client side. This method provides the reference to the file.

When marshalling by value, this method is allowed to return any string, including empty string. This string is considered to describe the origin of the file and may be used in error messages and as a part of the origin information in generated pages. These samples are also valid:

return "";
return "from: smith@mail.com";

When marshalling by reference (which is recommended), the returned value must be a reference, which can be resolved by the specified reference manager, or a path in the file system. The file system is considered as the default reference manager if none is explicitly set. These samples may be also valid if the reference manager, capable of resolving such references, is provided:

return @"http://storage/images?id=123";
return "1&Jh5K(D:";

Syntax

Visual Basic .NET

Function GetFileReference() As String

C++

HRESULT GetFileReference(
BSTR* result
);

Parameters

result

[out, retval] This parameter provides the reference to the file.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IFileAdapter

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing


GetFileStream Method of IFileAdapter Interface

GetFileStream Method of the IFileAdapter Interface

API Reference > Objects > FlexiCapture Processor > IFileAdapter >

GetFileStream Method of the IFileAdapter Interface

This method is implemented on the client side. The method provides the stream of bytes associated with the file adapter. This method is called only if the information, provided by the adapter is marshaled by value (see IFileAdapter::GetMarshallingType).

Syntax

Visual Basic .NET

Function GetFileStream() As ReadStream

C++

HRESULT GetFileStream(
IReadStream** result
);

Parameters

result

[out, retval] A pointer to the IReadStream* pointer variable that provides the stream of bytes associated with the file adapter.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IFileAdapter

IReadStream

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing


GetMarshallingType Method of IFileAdapter Interface

GetMarshallingType Method of the IFileAdapter Interface

API Reference > Objects > FlexiCapture Processor > IFileAdapter >

GetMarshallingType Method of the IFileAdapter Interface

This method is implemented on the client side. This method specifies how the information, provided by the adapter is handled.

Syntax

Visual Basic .NET

Function GetMarshallingType() As FileMarshallingTypeEnum

C++

HRESULT GetMarshallingType(
FileMarshallingTypeEnum* result
);

Parameters

result

[out, retval] This parameter specifies the marshaling type. See description of the FileMarshallingTypeEnum constants.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IFileAdapter

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing


IProcessingError Interface

API Reference > Objects > FlexiCapture Processor >

IProcessingError Interface

This is the interface for an error occurred during processing with FlexiCapture processor. It describes the error occurred when accessing an image. The errors occurred during Document Definition applying and recognition can be viewed in the output documents.

Methods

Name | Description
GetType | Provides the type of the error.
ImageFile | Specifies the image file associated with the error.
MessageText | Provides localized error message.

Output parameter

This interface pointer is returned by the GetLastProcessingError method of the FlexiCaptureProcessor object.

See also

FlexiCaptureProcessor

Processing with a Customizable Processor Object

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing


GetType Method of IProcessingError Interface

GetType Method of the IProcessingError Interface

API Reference > Objects > FlexiCapture Processor > IProcessingError >

GetType Method of the IProcessingError Interface

This method specifies the type of the error.

Syntax

Visual Basic .NET

Function GetType() As ProcessingErrorTypeEnum

C++

HRESULT GetType(
ProcessingErrorTypeEnum* result
);

Parameters

result

[out, retval] This parameter specifies the type of the error. See the description of the ProcessingErrorTypeEnum constants.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IProcessingError


ImageFile Method of IProcessingError Interface

ImageFile Method of the IProcessingError Interface

API Reference > Objects > FlexiCapture Processor > IProcessingError >

ImageFile Method of the IProcessingError Interface

This method specifies the image file associated with the error.

Syntax

Visual Basic .NET

Function ImageFile() As FileAdapter

C++

HRESULT ImageFile(
IFileAdapter** imageFile
);

Parameters

imageFile

[out, retval] A pointer to the IFileAdapter* pointer variable that provides access to the image file associated with the error.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IProcessingError

IFileAdapter


MessageText Method of IProcessingError Interface

MessageText Method of the IProcessingError Interface

API Reference > Objects > FlexiCapture Processor > IProcessingError >

MessageText Method of the IProcessingError Interface

This method provides localized error message.

Syntax

Visual Basic .NET

Function MessageText() As String

C++

HRESULT MessageText(
BSTR* result
);

Parameters

result

[out, retval] This parameter provides the string, which contains the error message.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IProcessingError


IReadStream Interface

API Reference > Objects > FlexiCapture Processor >

IReadStream Interface

This is the interface for a read stream. This interface and all its methods are implemented on the client side. A read stream may be implemented as reading from file.

Methods

Name | Description
Read | Reads the specified number of bytes from the stream.
Close | Finishes using the stream. All allocated resources can be released.

Output parameter

This interface pointer is returned by the GetFileStream method of the IFileAdapter interface.

Input parameter

The following methods receive a pointer to this interface as an input parameter:

·LoadFromStream method of the ICustomStorage interface

·OpenImageFileFromStream method of the ImageProcessingTools object

·LoadFlexibleDescriptionFromStream method of the SectionDefinition object

See also

IFileAdapter

ICustomStorage

Processing with a Customizable Processor Object

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing


Close Method of IReadStream Interface

Close Method of the IReadStream Interface

API Reference > Objects > FlexiCapture Processor > IReadStream >

Close Method of the IReadStream Interface

This method is implemented on the client side. This method finishes using the stream. All allocated resources can be released.

Syntax

Visual Basic .NET

Sub Close()

C++

HRESULT Close();

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IReadStream


Read Method of IReadStream Interface

Read Method of the IReadStream Interface

API Reference > Objects > FlexiCapture Processor > IReadStream >

Read Method of the IReadStream Interface

This method is implemented on the client side. This method reads the specified number of bytes from the stream.

Syntax

Visual Basic .NET

Function Read( _
ByRef data() As Byte, _
ByVal count As Int _
) As Int

C++

HRESULT Read(
SAFEARRAY(BYTE)* data,
int count,
int* countRead
);

Parameters

data

[out] This parameter refers to the data to be read.

count

[in] This parameter specifies the number of bytes to be read.

countRead

[out, retval] This parameter specifies the number of bytes transmitted.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IReadStream


IWriteStream Interface

API Reference > Objects > FlexiCapture Processor >

IWriteStream Interface

This is the interface for a write stream. This interface and all its methods are implemented on the client side.

Methods

Name | Description
Write | Writes the specified array of bytes to the stream.

Input parameter

This interface pointer is returned by the SaveToStream method of the ICustomStorage interface.

See also

IFileAdapter

Processing with a Customizable Processor Object

See sample: FlexiCapture Engine Code Snippets


Write Method of IWriteStream Interface

Write Method of the IWriteStream Interface

API Reference > Objects > FlexiCapture Processor > IWriteStream >

Write Method of the IWriteStream Interface

This method is implemented on the client side. This method writes the specified array of bytes to the stream.

Syntax

Visual Basic .NET

Sub Write(ByVal data() As Byte)

C++

HRESULT Write(
SAFEARRAY(BYTE) data
);

Parameters

data

[in] This parameter refers to the data to be written to the stream.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IWriteStream


IReferenceManager Interface

API Reference > Objects > FlexiCapture Processor >

IReferenceManager Interface

This interface provides means for resolving string references. This interface and all its methods are implemented on the client side.

By default, string references to Document Definitions, images, etc. are interpreted as references to files in the file system. However, if required, the user may define his own object (Reference Manager) which will resolve reference either as a path to a file in the local file system or as the binary representation of the requested object in the form of a stream in memory. This approach may be used to organize work with a remote storage location accessed using any protocol.

Methods

Name | Description
ResolveReference | Resolves the reference to a binary object.

Input parameter

The SetReferenceManager method of the FlexiCaptureProcessor object receives a pointer to this interface as an input parameter.

See also

Processing with a Customizable Processor Object

Custom Resolution of References

See sample: FlexiCapture Engine Code Snippets


ResolveReference Method of IReferenceManager Interface

ResolveReference Method of the IReferenceManager Interface

API Reference > Objects > FlexiCapture Processor > IReferenceManager >

ResolveReference Method of the IReferenceManager Interface

This method is implemented on the client side. This method resolves the reference to a binary object.

Syntax

Visual Basic .NET

Function ResolveReference(ByVal fileReference As String) As FileAdapter

C++

HRESULT ResolveReference(
BSTR fileReference,
IFileAdapter** fileAdapter
);

Parameters

fileReference

[in] This parameter specifies the file reference.

fileAdapter

[out, retval] A pointer to the IFileAdapter* pointer variable that provides access to the referenced file.

Return values

[C++ only] If this method returns a value other than S_OK, this indicates that an error occurred on the client side.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IReferenceManager

IFileAdapter


ICustomStorage Interface

API Reference > Objects > FlexiCapture Processor >

ICustomStorage Interface

This is a supplementary interface. This interface may be supported by the objects which allow saving their state in a custom storage. If an object supports custom storage, it implements ICustomStorage interface. It is the same object but we can see it through the ICustomStorage interface.

The following ABBYY FlexiCapture Engine objects support this interface:

·Document

·DocumentDefinition

Methods

Name | Description
LoadFromFile | Restores the object contents from a file on disk.
LoadFromStream | Restores the object contents from the stream.
SaveToFile | Saves the object contents into a file on disk.
SaveToStream | Saves the object contents into the stream.

Samples

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create a Document Definition
FCEngine::IDocumentDefinitionPtr documentDefinition = Engine->CreateDocumentDefinition();
// Load a Document Definition from file
FCEngine::ICustomStoragePtr customStorage = documentDefinition;
customStorage->LoadFromFile(L"C:\\Invoice_eng.fcdot");
// Modify if required and check the modified version
documentDefinition->Check();
// Save the modified Document Definition
customStorage->SaveToFile(L"C:\\Invoice_eng_COPY.fcdot");

See also

Loading and saving Document Definitions

See sample: FlexiCapture Engine Code Snippets, Redaction


LoadFromFile Method of the ICustomStorage Interface

LoadFromFile Method

API Reference > Objects > FlexiCapture Processor > ICustomStorage >

LoadFromFile Method

This method restores the object contents from a file on disk.

Syntax

Visual Basic .NET

Sub LoadFromFile(filePath As String)

C++

HRESULT LoadFromFile(
BSTR filePath
);

Parameters

filePath

[in] A path to the file on disk where the contents of the object is stored.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ICustomStorage
ClassificationTree

See sample: FlexiCapture Engine Code Snippets, Redaction


LoadFromStream Method

API Reference > Objects > FlexiCapture Processor > ICustomStorage >

LoadFromStream Method

This method restores the object contents from the stream.

Syntax

Visual Basic .NET

Sub LoadFromStream(stream As ReadStream)

C++

HRESULT LoadFromStream(
IReadStream* stream
);

Parameters

stream

[in] This parameter refers to a IReadStream variable that provides access to a read stream.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ICustomStorage
ClassificationTree

See sample: FlexiCapture Engine Code Snippets


SaveToFile Method

SaveToFile Method of the ICustomStorage Interface

API Reference > Objects > FlexiCapture Processor > ICustomStorage >

SaveToFile Method of the ICustomStorage Interface

This method saves the object contents into a file on disk.

Syntax

Visual Basic .NET

Sub SaveToFile(filePath As String)

C++

HRESULT SaveToFile(
BSTR filePath
);

Parameters

filePath

[in] This parameter specifies the path to the file where the object contents should be saved. If a file with this name already exists, it is overwritten without prompt.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ICustomStorage

See sample: FlexiCapture Engine Code Snippets


SaveToStream Method

SaveToStream Method of the ICustomStorage Interface

API Reference > Objects > FlexiCapture Processor > ICustomStorage >

SaveToStream Method of the ICustomStorage Interface

This method saves the contents of the object into the stream.

Syntax

Visual Basic .NET

Sub SaveToStream(stream As WriteStream)

C++

HRESULT SaveToStream(
IWriteStream* stream
);

Parameters

stream

[in] This parameter refers to a IWriteStream variable that provides access to a write stream.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ICustomStorage

See sample: FlexiCapture Engine Code Snippets


ClassificationResult Object

ClassificationResult Object (IClassificationResult Interface)

API Reference > Objects > FlexiCapture Processor >

ClassificationResult Object (IClassificationResult Interface)

note Note: This functionality is available only for rules-based classification.
This object contains results of image classification by ClassifyNextPage method of the FlexiCaptureProcessor object.

Properties

Name | Type | Description
Classes | ClassConfidences, read-only | Returns a collection of classes assigned by classifier to the page.
IsConfident | Boolean, read-only | Specifies whether the classification result is confident.
PageType | PageTypeEnum, read-only | Describes type of classified page.
SourceImageInfo | SourceImageInfo, read-only | Provides information about image source.

Methods

Name | Description
GetClassNames | Returns names of the classes to which the classified page can correspond.

Output parameter

This object is the output parameter of the ClassifyNextPage method of the FlexiCaptureProcessor object.

See also

Creating Document Definitions by Training


GetClassNames Method of ClassificationResult Object

GetClassNames Method of the ClassificationResult Object

API Reference > Objects > FlexiCapture Processor > ClassificationResult >

GetClassNames Method of the ClassificationResult Object

note Note: This functionality is available only for rules-based classification.
This method retrieves the possible class names for the classified page.

Syntax

Visual Basic .NET

Function GetClassNames() As StringsCollection

C++

HRESULT GetClassNames(
IStringsCollection** result
);

Parameters

result

[out, retval] A pointer to the IStringsCollection* variable that receives the interface pointer for the list of possible class names for the classified page.

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IFlexiCaptureProcessor::ClassifyNextPage


ClassConfidences

ClassConfidences Object (IClassConfidences Interface)

API Reference > Objects > FlexiCapture Processor >

ClassConfidences Object (IClassConfidences Interface)

note Note: This functionality is available only for rules-based classification.
This object contains a collection of all classes assigned by classifier to the page with corresponding confidence values. To access the classes of the certain page, use the Classes property of the corresponding ClassificationResult object.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | ClassConfidence, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

See also

ClassificationResult


Count Property

API Reference > Objects > FlexiCapture Processor > ClassConfidences >

Count Property

This property stores the number of elements in an ABBYY FlexiCapture Engine collection. Each ABBYY FlexiCapture Engine collection object has this property.

Syntax

Visual Basic .NET

Property Count As Int
read-only

C++

HRESULT get_Count(
int* Result
);

Parameters

Result

[out, retval] A pointer to a int variable that receives the value of this property. Must not be NULL.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following objects have this property:

·AssemblingErrors

·Batches

·BatchTypes

·BlockDefinitions

·Blocks

·BlocksCollection

·CheckmarkGroupBlock

·DocumentDefinitions

·Documents

·DocumentsCollection

·FieldDefinitions

·FieldInstances

·Fields

·FieldValuesCollection

·GroupLanguage

·HotFolderProfiles

·IntsCollection

·PageDefinitions

·Pages

·PredefinedLanguages

·Region

·RuleErrors

·ScanningProfiles

·SectionDefinitions

·SectionDefinitionsCollection

·StringsCollection

·TableColumns

·TextRegions

·TrainingBlocks

·TrainingDefinitions

·TrainingFields

·TrainingImageObjects

·TrainingPages

·VerificationGroup

See also

Item

Working with Collections

Working with Properties


Element Property

API Reference > Objects > FlexiCapture Processor > ClassConfidences >

Element Property

This property provides access to a single element of ABBYY FlexiCapture Engine collection.

note Note: This property allows you to access an element of the collection using the [] operator in C#.

Syntax

Visual Basic .NET

Property Element(Index As Int) As <ObjectType>

C++

HRESULT Element(
int Index,
<InterfaceType>** Result
);

Parameters

Index

[in] This variable contains the index of the element that is accessed via this method. It must be in the range from 0 to the Number of elements - 1, where the number of elements may be received from the Count property of the same collection.

ObjectType

[out, retval] The type of objects in the collection. For example, for the Batches collection this type is Batch.

Result

[out, retval] A variable of type <InterfaceType>* that receives a pointer to the interface of the collection element. Result must not be NULL. *Result is guaranteed to be non-NULL after a successful method call. InterfaceType is the type of the interface of the objects forming the collection.

Remarks

The following collection objects have this property:

·AssemblingErrors

·Batches

·BatchTypes

·BlockDefinitions

·Blocks

·BlocksCollection

·CheckmarkGroupBlock

·DocumentDefinitions

·Documents

·DocumentsCollection

·FieldDefinitions

·FieldInstances

·Fields

·FieldValuesCollection

·GroupLanguage

·HotFolderProfiles

·IntsCollection

·LicenseCollection

·PageDefinitions

·Pages

·PredefinedLanguages

·RuleErrors

·ScanningProfiles

·ScanSources

·SectionDefinitions

·SectionDefinitionsCollection

·StringsCollection

·TableColumns

·TextRegions

·TrainingBlocks

·TrainingDefinitions

·TrainingFields

·TrainingImageObjects

·TrainingPages

·VerificationGroup

See also

Count

Item

Working with Collections

Working with Properties


Item Method

API Reference > Objects > FlexiCapture Processor > ClassConfidences >

Item Method

This method provides access to a single element of ABBYY FlexiCapture Engine collection. Each ABBYY FlexiCapture Engine collection uses this method.

Syntax

Visual Basic .NET

Function Item(Index As Int) As <ObjectType>

C++

HRESULT Item(
int Index,
<InterfaceType>** Result
);

Parameters

Index

[in] This variable contains the index of the element that is accessed via this method. It must be in the range from 0 to the Number of elements - 1, where the number of elements may be received from the Count property of the same collection.

ObjectType

[out, retval] The type of objects in collection. For example, for the Batches collection this type is Batch.

Result

[out, retval] A variable of type <InterfaceType>* that receives a pointer to the interface of the collection element. Result must not be NULL. *Result is guaranteed to be non-NULL after a successful method call.
InterfaceType is the type of the interface of the objects forming the collection.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following objects provide this method:

·AssemblingErrors

·Batches

·BatchTypes

·BlockDefinitions

·Blocks

·BlocksCollection

·CheckmarkGroupBlock

·DocumentDefinitions

·Documents

·DocumentsCollection

·FieldDefinitions

·FieldInstances

·Fields

·FieldValuesCollection

·GroupLanguage

·HotFolderProfiles

·IntsCollection

·PageDefinitions

·Pages

·PredefinedLanguages

·RuleErrors

·ScanningProfiles

·ScanSources

·SectionDefinitions

·SectionDefinitionsCollection

·StringsCollection

·TableColumns

·TextRegions

·TrainingBlocks

·TrainingDefinitions

·TrainingFields

·TrainingImageObjects

·TrainingPages

·VerificationGroup

See also

Count

Working with Collections


ClassConfidence

ClassConfidence Object (IClassConfidence Interface)

API Reference > Objects > FlexiCapture Processor >

ClassConfidence Object (IClassConfidence Interface)

note Note: This functionality is available only for rules-based classification.
This object represents a class to which the page can correspond and the confidence level of the match.

Properties

Name | Type | Description
Name | String, read-only | Stores the name of the class to which the classified page can correspond.
Confidence | Int, read-only | Returns the confidence value associated with the classifier's choice.

Related objects

Output parameter

This object is the output parameter of the Item method of the ClassConfidences object.

See also

ClassificationResult

ClassConfidences


ClassificationTree Object

ClassificationTree Object (IClassificationTree Interface)

API Reference > Objects > FlexiCapture Processor >

ClassificationTree Object (IClassificationTree Interface)

note Note: This functionality is available only for rules-based classification.
This object represents a classification tree. A classifier tree is used for preliminary identification of individual pages and classifying them as belonging to a particular type. Classifier trees are saved in *.cfl files. Classification tree can be created in ABBYY FlexiLayout Studio or using the TrainingClassifier object.

Classifier trees may be used for the following purposes:

·To speed up the selection of a Document Definition to be matched. The use of a classifier tree prevents going through all Document Definitions one by one in search for the best match. Instead, the program can select the matching Document Definition based on the classifying attributes. The order of the search is determined by the user, who selects the appropriate classifying attributes and builds a classifier tree. Speed gains are most noticeable when using large number of Document Definitions.

·To speed up processing Document Definitions in different languages. If a classifier tree is used, instead of using all the languages of all the Document Definitions, the program will pre-recognize the documents twice: first, when classifying them and then when matching them with the selected Document Definition.

·To classify images without recognizing them. If you need only to divide a set of images into groups corresponding to different types, you don't have to run the recognition process, which takes time. Instead, you can use classifier tree to determine which Document Definition is the most probable for this image, and return this as the result of classification.

To load the classifier tree for processing, you need to create an empty object of this type and then load the contents of a *.cfl file into it.

note Note: Loading the classification tree with the help of the LoadFromFile or LoadFromStream method is required before you start working with the classification tree in any way.

Methods

Name | Description
GetClassNames | Returns names of all classes into which the classifier tree can separate images.
LoadFromFile | Restores the object contents from a file on disk.
LoadFromStream | Restores the object contents from the stream.

Input parameter

This object is the input parameter of the AddClassificationTree method of the FlexiCaptureProcessor object.

Output parameter

This object is the output parameter of the CreateClassificationTree method of the Engine object.

See also

Creating Document Definitions by Training


GetClassNames Method of the ClassificationTree Object

API Reference > Objects > FlexiCapture Processor > ClassificationTree >

GetClassNames Method of the ClassificationTree Object

note Note: This functionality is available only for rules-based classification.
This method retrieves all class names for the classifier tree.

note Note: Loading the classification tree with the help of the LoadFromFile or LoadFromStream method is required before you start working with the classification tree in any way, including the call to this method.

Syntax

Visual Basic .NET

Function GetClassNames() As StringsCollection

C++

HRESULT GetClassNames(
IStringsCollection** result
);

Parameters

result

[out, retval] A pointer to the IStringsCollection* variable that receives the interface pointer for the list of all classes into which the given classifier tree can separate images.

Return values

This method has no specific return values. It returns the standard return values of the ABBYY FlexiCapture Engine functions.

See also

IFlexiCaptureProcessor::ClassifyNextPage


Project Structure Objects

API Reference > Objects >

Project Structure Objects

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
A project is a single environment uniting the document batches and settings required to process them, such as Document Definitions, import profiles, etc. The project in ABBYY FlexiCapture Engine is represented by the Project object.

This section describes the objects, which provide access to the project itself, the batches, and processing settings:

·Project

·ProjectProperties

·Batches

·Batch

·BatchTypes

·BatchType

And callback interface:

·IBatchEvents

The hierarchy of the objects


Project Object

Project Object (IProject Interface)

API Reference > Objects > Project Structure >

Project Object (IProject Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

This object corresponds to a project. The project contains document batches and all the settings required to process them, such as document definitions, parameters of loading images and exporting results. The document batches of the project are accessible through the Batches property, while the settings are available through the Properties and DocumentDefinitions properties. The object contains properties for accessing different project attributes such as its identifier, title, and path to the project, and provides a set of methods for document processing.

The project should be set up in ABBYY FlexiCapture, and then used with the same configuration in ABBYY FlexiCapture Engine. Most of the project's settings are read-only.

warning Important! You must keep the reference to the Project object when any references to the objects of the project are used. If the reference to the Project object is released and its subobjects are still in use, errors will occur. See Working with Properties for details.

The Project object is a so-called "connectable object." The methods of the Project object report information about page processing progress through special outgoing interfaces. These interfaces are IBatchEvents (for C++) and the dispinterface DIBatchEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

note Note: ABBYY FlexiCapture Engine 12 works with projects created in ABBYY FlexiCapture 12 Release 2 Update 7, Build 12.0.2.3042, or earlier. Projects saved in the current version of ABBYY FlexiCapture Engine 12 can be used in ABBYY FlexiCapture 12 Release 2 Update 7, Build 12.0.2.3042, or later. You can also pass projects to and from ABBYY FlexiCapture 12 shipped with the current ABBYY FlexiCapture Engine 12 distribution.

Properties

Name | Type | Description
Batches | Batches, read-only | Returns the collection of batches of the project.
BatchTypes | BatchTypes, read-only | Returns the collection of the batch types defined in the project.
Comment | String, read-only | Stores the text description of the project.
DocumentDefinitions | DocumentDefinitions, read-only | Returns the collection of document definitions of the project.
Errors | StringsCollection, read-only | Returns the collection of error messages. The collection includes the descriptions of the errors which occurred during the latest execution of the ImportImages, ApplyDocumentDefinitions, Recognize, or Export method. The same messages you can receive using the IBatchEvents::OnError method.
ID | String, read-only | Returns the identifier of the project.
LanguageDatabase | PredefinedLanguages, read-only | Provides access to the collection of languages of the project.
Password | String, read-only | Specifies the password for accessing the project.
Path | String, read-only | Returns the full path to the project folder.
Properties | ProjectProperties, read-only | Returns the properties of the project. The properties contain the parameters of image loading, results exporting, etc.
Title | String, read-only | Stores the name of the project.
Warnings | StringsCollection, read-only | Returns the collection of warning messages. The collection includes the descriptions of the warnings which occurred during the latest execution of the ImportImages, ApplyDocumentDefinitions, Recognize, or Export method. The same messages you can receive using the IBatchEvents::OnWarning method.

Methods

Name | Description
ApplyDocumentDefinitions | Applies Document Definitions to the documents in the specified batches. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Close | Closes the project and frees resources. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Export | Saves the results of project processing. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
ImportImages | Imports images to the batches of the project. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Recognize | Performs recognition of the documents in the specified batches of the project. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
StartVerification | Performs verification of the documents in the specified batches of the project. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Related objects

Output parameter

This object is the output parameter of the OpenProject method of the Engine object.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Get project list of batches
FCEngine::IBatchesPtr batches = project->GetBatches();
...

See also

IBatchEvents

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


ApplyDocumentDefinitions Method of the Project Object

API Reference > Objects > Project Structure > Project >

ApplyDocumentDefinitions Method of the Project Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

This method applies Document Definitions of the project (specified by the IProject::DocumentDefinitions property) to the documents from the specified batches. Document Definitions matching is a process of selecting Document Definition that can be applied to a particular page and matching fields of the Document Definition against an image. The process must be performed before recognition.

Use this method to match the Document Definitions to project documents explicitly. With the help of this method you can select the mode of Document Definitions matching. Also you can use the Recognize method of the Project object with correct recognition mode, in this case Document Definitions will be matched automatically before recognition.

Syntax

Visual Basic .NET

Sub ApplyDocumentDefinitions( _
BatchIds As IntsCollection, _
Incremental As Boolean _
)

C++

HRESULT ApplyDocumentDefinitions(
IIntsCollection* BatchIds,
VARIANT_BOOL Incremental
);

Parameters

BatchIds

[in] This parameter refers to the IntsCollection object that contains a set of identifiers of the batches. Document Definitions should be matched to the documents of these batches. This parameter is optional and may be set to 0, in which case Document Definitions are matched to all the documents of the project.

Incremental

[in] This parameter specifies the mode of Document Definitions matching. It can be set to TRUE if you want to match Document Definitions to the documents which do not have applied Document Definitions and the documents with changed Document Definitions. When it is set to FALSE, ABBYY FlexiCapture Engine will match document definitions to all the documents of the project. This parameter is optional. The default value of the parameter is TRUE.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

·During this method call documents in the project can be reorganized, e.g. documents can be merged or split depending on the Document Definitions applied to them, also some document identifiers can be changed.

·To match Document Definitions to only several documents from the batch, use the ApplyDocumentDefinitions method of the Batch object.

See also

Project

IProject::Recognize


Close Method of the Project Object

API Reference > Objects > Project Structure > Project >

Close Method of the Project Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method closes the project.

Release all the references to the Project object, and then call this method. An open project uses more resources than a closed one. So if you have finished your work with the project and need to free some resources, call this method to close the project. We recommend using this method in finally blocks.

Syntax

Visual Basic .NET

Sub Close()

C++

HRESULT Close();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Project

IEngine::OpenProject

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


Export Method of the Project Object

API Reference > Objects > Project Structure > Project >

Export Method of the Project Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to save the results of project processing. You can save the results for all the documents of the project or specify particular batches to export results from. To set the destination, file format and other export settings use the ExportParams object.

Syntax

Visual Basic .NET

Sub Export( _
BatchIds As IntsCollection, _
ExportParams As ExportParams _
)

C++

HRESULT Export(
IIntsCollection* BatchIds,
IExportParams* ExportParams
);

Parameters

BatchIds

[in] This parameter refers to the IntsCollection object that contains a set of identifiers of the batches to export results from. This parameter is optional and may be set to 0, in which case export is performed for all the documents of the project.

ExportParams

[in] This parameter refers to the ExportParams object that contains parameters of export. This parameter is optional and may be set to 0, in which case for each document the export parameters of the corresponding Document Definition are used.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To export only several documents from the batch, use the Export method of the Batch object.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
...
// Add batches to the project, set necessary settings, and recognize project images
...
// Save the results
project->Export( 0, 0 );
...

See also

Project

IBatch::Export

Tuning Export Parameters


ImportImages Method of the Project Object

API Reference > Objects > Project Structure > Project >

ImportImages Method of the Project Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to import images to the project. Images are grouped into documents and batches in accordance with the settings specified in the ImportParams parameter. This parameter also defines the folder images are imported from.

Syntax

Visual Basic .NET

Sub ImportImages( _
ImportParams As ImageImportParams, _
StartBatch As Batch, _
StartDoc As Document _
)

C++

HRESULT ImportImages(
IImageImportParams* ImportParams,
IBatch* StartBatch
IDocument* StartDoc
);

Parameters

ImportParams

[in] This parameter refers to the ImageImportParams object that contains the parameters of image preprocessing and grouping into documents. This parameter also defines the folder images are imported from. You can specify a set of input folders via the IProjectProperties::HotFolderProfiles property of the Project object, select one of the HotFolderProfile objects of the collection, and pass the ImageImportParams subobject of the selected HotFolderProfile object as ImportParams parameter. In this case input folder of the selected profile will be used for import.

StartBatch

[in] This parameter refers to the Batch object that contains the batch that starts the group of batches to which the images should be imported.

StartDoc

[in] This parameter refers to the Document object that contains the document that starts the group of batch documents to which the images should be imported.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Project


Recognize Method of Project Object

Recognize Method of the Project Object

API Reference > Objects > Project Structure > Project >

Recognize Method of the Project Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method performs recognition of the documents in the specified batches of the project. You can process all the documents from the project or specify particular batches to recognize documents from. Depending on the selected recognition mode the method performs full recognition procedure (selects a Document Definition, applies it and performs data recognition), or fulfill only some steps of the procedure.

Syntax

Visual Basic .NET

Sub Recognize( _
BatchIds As IntsCollection, _
RecognitionMode As RecognitionModeEnum _
)

C++

HRESULT Recognize(
IIntsCollection* BatchIds,
RecognitionModeEnum RecognitionMode
);

Parameters

BatchIds

[in] This parameter refers to the IntsCollection object that contains a set of identifiers of the batches to recognize documents from. This parameter is optional and may be set to 0, in which case all the batches of the project are recognized.

RecognitionMode

[in] This variable of the RecognitionModeEnum type specifies the mode of recognition. This parameter is optional. By default only documents with changed Document Definitions and documents from the batches which were changed are recognized (the RM_ReRecognizeMinimal mode is used).

Return values

It also returns the standard return codes of the ABBYY FlexiCapture Engine functions.

Remarks

·During this method call documents in the project can be reorganized, e.g. documents can be merged or split depending on the Document Definitions applied to them, also some document identifiers can be changed.

·To recognize only several documents from the batch, use the Recognize method of the Batch object.

See also

Project

IBatch::Recognize


StartVerification Method of the Project Object

API Reference > Objects > Project Structure > Project >

StartVerification Method of the Project Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to perform verification of the documents in the specified batches of the project.

Syntax

Visual Basic .NET

Function StartVerification(BatchIDs As IntsCollection) As VerificationSession

C++

HRESULT StartVerification(
IIntsCollection* BatchIDs,
IVerificationSession** Result
);

Parameters

BatchIDs

[in] This parameter refers to the IntsCollection object that contains a set of indices of the batches to be verified.

Result

[out, retval] A pointer to IVerificationSession* pointer variable that receives the interface pointer of the resulting VerificationSession object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

You cannot run two verification sessions in one process simultaneously using ABBYY FlexiCapture Engine.

See also

Verifying Recognized Data

Project


ProjectProperties Object

ProjectProperties Object (IProjectProperties Interface)

API Reference > Objects > Project Structure >

ProjectProperties Object (IProjectProperties Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

This object allows you to view the properties of a project: hot folder import profiles, parameters of image preprocessing during loading, results export.

The project should be set up in ABBYY FlexiCapture and used unchanged in ABBYY FlexiCapture Engine. This object does not allow you to change the project configuration.

Properties

Name | Type | Description
DocumentDefinitionsPath | String, read-only | Specifies the full path to the folder containing Document Definitions of the project.
ExportParams | ExportParams, read-only | Returns the export parameters of the project. This property is deprecated and will be removed in future versions.
HotFolderProfiles | HotFolderProfiles, read-only | Provides access to the set of hot folder import profiles of the project. warning Important! The collection is read-only. Project import settings can be edited in ABBYY FlexiCapture but are read-only in ABBYY FlexiCapture Engine.
ImageLoadingParams | ImageLoadingParams, read-only | Returns the parameters of image preprocessing. warning Important! The property is read-only. Project settings can be edited in ABBYY FlexiCapture but are read-only in ABBYY FlexiCapture Engine.

Related objects

See also

Project

Working with Properties


Batches Object

Batches Object (IBatches Interface)

API Reference > Objects > Project Structure >

Batches Object (IBatches Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object is a collection of document batches that are part of the project you are working with. Besides standard collection methods and properties, it contains the FindByID method that allows you to find the batch by its identifier. To access the batches of the certain project, use the Batches property of the corresponding Project object.

The Batches object is a so-called "connectable object". The methods of the Batches object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Batch, read-only | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Adds a batch with the specified name at the end of the collection of batches. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
AddNewEx | Adds a batch of the specified batch type at the end of the collection of batches. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
FindByID | Provides access to a batch in the collection by the batch ID. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Item | Provides access to a single element of the collection by its index in this collection.
DeleteByID | Removes an element with the specified identifier from the collection. You cannot delete the batch, if it is open (the IBatch::IsOpen property is TRUE).
DeleteAll | Removes all the elements from the collection. You cannot delete the batch, if it is open (the IBatch::IsOpen property is TRUE).

Related objects

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Get project list of batches
FCEngine::IBatchesPtr batches = project->GetBatches();
// Add new batch
FCEngine::IBatchPtr batch = batches->AddNew( L"TestBatch" );
...

See also

Project

Batch

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


AddNew Method of the Batches Object

API Reference > Objects > Project Structure > Batches >

AddNew Method of the Batches Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method adds a batch with the specified name at the end of the collection of batches.

Syntax

Visual Basic .NET

Function AddNew(Name As String) As Batch

C++

HRESULT AddNew(
BSTR Name,
IBatch** Result
);

Parameters

Name

[in] This variable contains the name of the batch.

Result

[out, retval] A pointer to the IBatch* variable that receives the interface pointer for the added batch.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject(L"D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
...

See also

Batches

Batch

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


AddNewEx Method of the Batches Object

API Reference > Objects > Project Structure > Batches >

AddNewEx Method of the Batches Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method adds a batch of the specified batch type at the end of the collection of batches.

Syntax

Visual Basic .NET

Function AddNewEx( _
Type As BatchType, _
Name As String _
) As Batch

C++

HRESULT AddNewEx(
IBatchType* Type,
BSTR Name,
IBatch** Result
);

Parameters

Type

[in] Refers to the BatchType object, which specifies the batch type.

Name

[in] This variable contains the name of the batch.

Result

[out, retval] A pointer to the IBatch* variable that receives the interface pointer for the added batch.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Batches

Batch


DeleteAll Method

API Reference > Objects > Project Structure > Batches >

DeleteAll Method

This method is specific to ABBYY FlexiCapture Engine collection objects. It removes all the elements from collection and empties it.

Syntax

Visual Basic .NET

Sub DeleteAll()

C++

HRESULT DeleteAll();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following collection objects provide this method:

·Batches – you cannot delete the batch, if it is open (the IBatch::IsOpen property is TRUE)

·BlockDefinitions

·DocumentDefinitions

·Documents

·FieldValuesCollection

·IntsCollection

·PageDefinitions

·StringsCollection

See also

Working with Collections


DeleteById Method

API Reference > Objects > Project Structure > Batches >

DeleteById Method

This method is specific to collection objects. It removes an element with the specified identifier from the collection.

Syntax

Visual Basic .NET

Sub DeleteByID(Id As Int)

C++

HRESULT DeleteByID(
int Id
);

Parameters

Id

[in] This variable contains the identifier of the collection element. It should be received as the value of the ID property of the corresponding collection element.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions

Remarks

The following collection objects provide this method:

·Batches – you cannot delete the batch, if it is open (the IBatch::IsOpen property is TRUE)

·BlockDefinitions

·Documents

·PageDefinitions

·Pages

See also

DeleteAll

Working with collections


FindById Method of the Batches Object

API Reference > Objects > Project Structure > Batches >

FindById Method of the Batches Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to find a batch by its identifier.

Syntax

Visual Basic .NET

Function FindByID(ID As Int) As Batch

C++

HRESULT FindByID(
int ID,
IBatch** Result
);

Parameters

ID

[in] This variable contains the identifier of the batch to be found.

Result

[out, retval] A pointer to the IBatch* variable that receives the interface pointer for the batch. Returns NULL, if the batch with the specified identifier is not found.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Batches

Batch


Batch Object

Batch Object (IBatch Interface)

API Reference > Objects > Project Structure >

Batch Object (IBatch Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object corresponds to a batch. The batch is a set of documents grouped by the user. The assignment of documents to batches is user-defined: you can process all documents in one batch, or form batches from documents added on the same date or from a batch scanned in a single pass. Each batch is a part of a project. All the batches of the project are represented by the Batches object.

To start your work with the batch, you should first open it using the Open method. The documents of the batch are accessible through the Documents property, while the project containing the batch is available through the Project property. The object contains properties for accessing different batch attributes such as its identifier, title, and path to the batch, and provides a set of methods for document processing.

The Batch object is a so-called "connectable object." The methods of the Batch object report information about page processing progress through special outgoing interfaces. These interfaces are IBatchEvents (for C++) and the dispinterface DIBatchEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Comment | String | Allows you to specify any text comment for the batch. This comment can be viewed in ABBYY FlexiCapture.
Documents | Documents, read-only | Returns the collection of documents of the batch.
Errors | StringsCollection, read-only | Returns the collection of error messages. The collection includes the descriptions of the errors which occurred during the latest execution of the AddImage, AddImages, ApplyDocumentDefinitions, ForceApplyDocumentDefinition, Recognize, CheckRules, or Export method. The same messages you can receive using the IBatchEvents::OnError method.
ID | Int, read-only | Returns the identifier of the batch.
IsOpen | Boolean, read-only | Specifies whether the batch is open. If the value of this property is FALSE, not all the properties and methods of the Batch object are available. To open or close the batch, use the Open or Close methods of the Batch object respectively.
Project | Project, read-only | Returns the Project object which contains the batch.
Title | String | Stores the name of the batch.
Type | BatchType, read-only | Specifies the batch type.
Warnings | StringsCollection, read-only | Returns the collection of warning messages. The collection includes the descriptions of the warnings which occurred during the latest execution of the AddImage, AddImages, ApplyDocumentDefinitions, ForceApplyDocumentDefinition, Recognize, CheckRules, or Export method. The same messages you can receive using the IBatchEvents::OnWarning method.

Methods

Name | Description
AddImage | Adds one image from a file to the batch. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
AddImages | Adds images from several files to the batch. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
ApplyDocumentDefinitions | Applies Document Definitions to the documents of the batch. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
CheckRules | Checks all rules imposed on data in the specified documents. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Close | Closes the batch and frees resources. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
DeleteRecognitionResults | Deletes all recognition results in the specified documents. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Export | Saves results of processing of the specified documents in selected location. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
ForceApplyDocumentDefinition | Forcibly applies Document Definitions to the documents of the batch. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Open | Opens the batch. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Recognize | Recognizes the documents of the batch. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Scan | Starts synchronous scanning. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
StartVerification | Starts verification of the specified documents in the batch. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Related objects

Output parameter

This object is the output parameter of the AddNew, AddNewEx, Item, FindByID methods of the Batches object.

Input parameter

This object is the input parameter of the ImportImages method of the Project object.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
// Open the batch
batch->Open();
// Add images to the batch
batch->AddImage( L"D:\\SampleImages\\0001.tif" );
...
// Recognize documents
batch->Recognize( 0, Engine::RM_ReRecognizeMinimal, 0 );
// Export results
batch->Export( 0, 0 );
// Close the batch
batch->Close();

See also

Batches

IBatchEvents

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


AddImage Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

AddImage Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to add an image from file to the batch. The method creates document in the batch for added image.

Syntax

Visual Basic .NET

Sub AddImage(Path As String)

C++

HRESULT AddImage(
BSTR Path
);

Parameters

Path

[in] This variable contains the full path to the image file. For example, "D:\SampleImages\Sample.tif".

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To add several images to the batch, you can use the AddImages method of the Batch object. This method allows you to set different parameters of image adding.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
// Open the batch
batch->Open();
// Add image to the batch
batch->AddImage( L"D:\\SampleImages\\0001.tif" );
...

See also

Batch

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


AddImages Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

AddImages Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method adds specified images to the batch. The method creates documents in the batch for added images.

Syntax

Visual Basic .NET

Sub AddImages( _
Files As StringsCollection, _
DocID As Int, _
LoadingParams As ImageLoadingParams, _
GroupingParams As ImageGroupingParams, _
PasswordProtectedPdf As StringsCollection, _
DocIds As IntsCollection _
)

C++

HRESULT AddImages(
IStringsCollection* Files,
int DocID,
IImageLoadingParams* LoadingParams,
IImageGroupingParams* GroupingParams,
IStringsCollection** PasswordProtectedPdf,
IIntsCollection** DocIds
);

Parameters

Files

[in] This parameter refers to the StringsCollection object which contains a collection of paths to the files to be added.

DocID

[in] This parameter specifies the identifier of the document in the batch. The created documents will be inserted into the collection of batch documents after the document with the specified identifier. This parameter may be set to -1, in which case the documents will be added at the end of the batch.

LoadingParams

[in] This variable refers to the ImageLoadingParams object that stores parameters of image preparation during adding to the batch. This parameter may be 0. In this case the images are added using the parameters set in the project properties (the IProjectProperties::ImageLoadingParams property).

GroupingParams

[in] This variable refers to the ImageGroupingParams object that stores parameters that determine the principles of adding images to documents. This parameter may be 0. In this case the images are added using the parameters set while configuring the project in ABBYY FlexiCapture.

PasswordProtectedPdf

[in, out] A pointer to the IStringsCollection* variable that receives the interface pointer for the collection of paths to the files which were not added, because they are password-protected and cannot be opened (possible only for input files in PDF format).

DocIds

[in, out] A pointer to the IIntsCollection* variable that receives the interface pointer for the list of identifiers of the added documents.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To add one image to the batch, you can use the AddImage method of the Batch object.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
// Open the batch
batch->Open();
// Add images to the batch
FCEngine::IStringsCollectionPtr fileList = Engine->CreateStringsCollection();
fileList->Add( L"D:\\SampleImages\\0001.tif" );
...
FCEngine::IStringsCollectionPtr passwordProtected;
FCEngine::IStringsCollectionPtr passwordProtected = Engine->CreateStringsCollection();
FCEngine::IIntsCollectionPtr docIdList;
FCEngine::IIntsCollectionPtr docIdList = Engine->CreateStringsCollection();
batch->AddImages( fileList, -1, 0, 0, passwordProtected, docIdList );
...

See also

Batch


ApplyDocumentDefinitions Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

ApplyDocumentDefinitions Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method matches specified Document Definitions sections to documents of the batch. Document Definitions matching is a process of selecting document definition that can be applied to a particular page and matching document definition fields against an image. The process must be performed before recognition.

Use this method to match the Document Definitions to batch documents explicitly. With the help of this method you can select the mode of Document Definitions matching. Also you can use the Recognize method of the Batch object with correct recognition mode, in this case Document Definitions will be matched automatically before recognition.

Syntax

Visual Basic .NET

Sub ApplyDocumentDefinitions( _
DocIds As IntsCollection, _
Incremental As Boolean, _
Sections As SectionDefinitionsCollection _
)

C++

HRESULT ApplyDocumentDefinitions(
IIntsCollection* DocIds,
VARIANT_BOOL Incremental,
ISectionDefinitionsCollection* Sections
);

Parameters

DocIds

[in] This parameter refers to the IntsCollection object that contains a set of indices of the documents to match Document Definitions to. This parameter may be 0, in which case Document Definitions are matched to all the documents of the batch.

Incremental

[in] This parameter specifies the mode of Document Definitions matching. It can be set to TRUE if you want to match Document Definitions to the documents which do not have applied Document Definitions and the documents with changed Document Definitions. When it is set to FALSE, ABBYY FlexiCapture Engine will match document definitions to all the documents of the batch. This parameter is optional. The default value of the parameter is TRUE.

Sections

[in] This parameter refers to the SectionDefinitionsCollection object that specifies the sections of Document Definitions to match. This parameter may be 0, in which case ABBYY FlexiCapture Engine tries to match all Document Definitions of the project.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

During this method call documents in the batch can be reorganized, e.g. documents can be merged or split depending on the Document Definitions applied to them, also some document identifiers can be changed.

Samples

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
// Create the Engine object
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
// Open the batch
batch->Open();
// Add images to the batch
...
// Apply Document Definitions
batch->ApplyDocumentDefinitions( 0, VARIANT_FALSE, 0 );
batch->Recognize( 0, Engine::RM_ReRecognizeMinimal, 0 );
...

See also

Batch

IBatch::Recognize


CheckRules Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

CheckRules Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method checks all rules imposed on data in the specified documents.

Syntax

Visual Basic .NET

Sub CheckRules(DocIds As IntsCollection)

C++

HRESULT CheckRules(
IIntsCollection* DocIds
);

Parameters

DocIds

[in] This parameter refers to the IntsCollection object that contains a set of identifiers of the documents to check rules in. This parameter may be 0, in which case rules are checked in all the documents of the batch.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To check rules in a certain document field, use the CheckRules method of the Document object.

See also

Batch

IBatch::Recognize


Close Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

Close Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

This method closes the batch (sets the value of the IBatch::IsOpen property to FALSE).

Release all the references to the Batch object, and then call this method. If a batch is not closed, it cannot be deleted from the project. As well an open batch uses more resources than a closed one. So if you have finished your work with the batch and need to free some resources, call this method to close the batch. We recommend using this method in finally blocks.

Syntax

Visual Basic .NET

Sub Close()

C++

HRESULT Close();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Batch

IBatch::Open

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


DeleteRecognitionResults Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

DeleteRecognitionResults Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method deletes all recognition results in the specified documents.

Syntax

Visual Basic .NET

Sub DeleteRecognitionResults(DocIds As IntsCollection)

C++

HRESULT DeleteRecognitionResults(
IIntsCollection* DocIds
);

Parameters

DocIds

[in] This parameter refers to the IntsCollection object that contains the set of indices of the documents to delete recognition results in. This parameter may be 0, in which case recognition results are deleted in all the documents of the batch.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Batch


Export Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

Export Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method saves results of processing of the specified documents in selected location. You can save the results from all the documents of the batch or specify particular documents to export results from. To set the destination, file format and other export settings, use the ExportParams object.

Syntax

Visual Basic .NET

Sub Export( _
DocIds As IntsCollection, _
Params As ExportParams _
)

C++

HRESULT Export(
IIntsCollection* DocIds,
IExportParams* Params
);

Parameters

DocIds

[in] This parameter refers to the IntsCollection object that contains a set of identifiers of the documents to export results from. This parameter may be 0, in which case export is performed for all the documents of the batch.

Params

[in] This parameter refers to the ExportParams object that contains parameters of export. This parameter may be 0, in which case for each document the export parameters of the corresponding Document Definition are used.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To export results from documents of several batches, use the Export method of the Project object.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
// Open the batch
batch->Open();
// Add images to the batch and recognize documents
...
// Export results
batch->Export( 0, 0 );

See also

Batch

Tuning Export Parameters

See sample: FlexiCapture Engine Code Snippets


ForceApplyDocumentDefinition Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

ForceApplyDocumentDefinition Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method forcibly matches specified Document Definition section to selected pages of the batch. This method is useful when a static element (e.g. separator) of the Document Definition was not found on the images, but the Document Definition still can be applied to the images (other fields and static elements were found).

Use this method if it is impossible to match Document Definition to documents automatically (e.g. with the help of the ApplyDocumentDefinitions or Recognize methods of the Batch object).

Syntax

Visual Basic .NET

Sub ForceApplyDocumentDefinition( _
PageIds As IntsCollection, _
Section As SectionDefinition _
)

C++

HRESULT ForceApplyDocumentDefinition(
IIntsCollection* PageIds,
ISectionDefinition* Section
);

Parameters

PageIds

[in] This parameter refers to the IntsCollection object that contains a set of identifiers of the batch pages to match Document Definition section to.

Section

[in] This parameter refers to the SectionDefinition object that contains the section of Document Definition to match.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Batch

IBatch::Recognize


Open Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

Open Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method opens the batch (sets the value of the IBatch::IsOpen property to TRUE). You should open the batch before working with it as some properties and methods are not accessible for the closed batch. An open batch uses more resources than a closed one. So if you have finished your work with the batch and need to free some resources, call the Close method of the Batch object.

Syntax

Visual Basic .NET

Sub Open()

C++

HRESULT Open();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
// Open the batch
pBatch->Open();
// Add images to the batch, recognize documents, export results, etc.
...

See also

Batch

IBatch::Close

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


Recognize Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

Recognize Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method performs recognition of the documents from the batch. You can process all the documents from the batch or specify particular documents or document sections to recognize. Depending on the selected recognition mode the method performs full recognition procedure (selects a Document Definition, applies it and performs data recognition), or fulfill only some steps of the procedure (recognition of all the specified document batches or only changed ones).

Syntax

Visual Basic .NET

Sub Recognize( _
DocIds As IntsCollection, _
Mode As RecognitionModeEnum, _
Sections As SectionDefinitionsCollection _
)

C++

HRESULT Recognize(
IIntsCollection* DocIds,
RecognitionModeEnum Mode,
ISectionDefinitionsCollection* Sections
);

Parameters

DocIds

[in] This parameter refers to the IntsCollection object that contains a set of indices of the recognizing documents. This parameter may be 0, in which case all the documents of the batch are recognized.

Mode

[in] This variable of the RecognitionModeEnum type specifies the mode of recognition. This parameter may be 0, in which case only documents with changed Document Definitions and documents from the batches which were changed are recognized.

Sections

[in] This parameter refers to the SectionDefinitionsCollection object that specifies the sections of the applied Document Definition to recognize. This parameter may be 0, in which case all the sections are recognized.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

·During this method call documents in the batch can be reorganized, e.g. documents can be merged or split depending on the Document Definitions applied to them, also some document identifiers can be changed.

·To recognize documents from several batches, use the Recognize method of the Project object.

Samples

cicon2 C++ (COM) code

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Open the project
FCEngine::IProjectPtr project = Engine->OpenProject("D:\\TestProject\\TestProject.fcproj");
// Add new batch
FCEngine::IBatchPtr batch = project->Batches->AddNew( L"TestBatch" );
// Open the batch
batch->Open();
// Add images to the batch
...
//Recognize documents
batch->ApplyDocumentDefinitions( 0, VARIANT_FALSE, 0 );
batch->Recognize( 0, Engine::RM_ReRecognizeMinimal, 0 );

See also

Batch

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


Scan Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

Scan Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method starts synchronous scanning. The method adds scanned images to documents in the batch.

Syntax

Visual Basic .NET

Sub Scan( _
Multiple As Boolean, _
Profile As ScanningProfile, _
DocID As Int _
)

C++

HRESULT Scan(
VARIANT_BOOL Multiple,
IScanningProfile* Profile,
int DocID
);

Parameters

Multiple

[in] This variable of the Boolean type specifies whether multiple pages should be scanned at a time.

Profile

[in] This variable refers to the ScanningProfile object that stores parameters of image import.

DocID

[in] This parameter specifies the identifier of the document in the batch. The scanned documents will be inserted into the collection of batch documents after the document with the specified identifier. This parameter may be set to -1, in which case the documents will be added at the end of the batch.

Return values

This method has no specific return values. It returns standard return values of ABBYY FlexiCapture Engine functions.

See also

Batch


StartVerification Method of the Batch Object

API Reference > Objects > Project Structure > Batch >

StartVerification Method of the Batch Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to start verification process of the specified documents. See Verifying Recognized Data for details.

Syntax

Visual Basic .NET

Function StartVerification(DocIDs As IntsCollection) As VerificationSession

C++

HRESULT StartVerification(
IIntsCollection* DocIDs,
IVerificationSession** Result
);

Parameters

DocIDs

[in] This parameter refers to the IntsCollection object which contains a collection of identifiers of the documents to be verified.

Result

[out, retval] A pointer to the IVerificationSession* variable that receives the interface pointer for the verification session.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Batch

Verifying Recognized Data

See sample: FlexiCapture Engine Code Snippets


BatchTypes Object

BatchTypes Object (IBatchTypes Interface)

API Reference > Objects > Project Structure >

BatchTypes Object (IBatchTypes Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object represents a collection of batch types. Several batch types for the most commonly used sets of processing settings can be defined in the project. The full set of the batch types defined in the project are available via the BatchTypes property of the corresponding Project object.

The BatchTypes object is a so-called "connectable object". The methods of the BatchTypes object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | BatchType, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

See also

BatchType

Working with Properties

Working with Collections

ICollectionEvents

Working with Connectable Objects


BatchType Object

BatchType Object (IBatchType Interface)

API Reference > Objects > Project Structure >

BatchType Object (IBatchType Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object corresponds to a batch type. Batch type is an attribute of a batch which defines how its documents should be processed. Several batch types for the most commonly used sets of processing settings can be defined in the project. All the batch types of the project are represented by the BatchTypes object.

Properties

Name | Type | Description
Name | String, read-only | Returns the name of the batch type.

Related objects

Output parameter

This object is the output parameter of the Item method of the BatchTypes object.

Input parameter

This object is the input parameter of the AddNewEx method of the Batches object.

See also

BatchTypes

Working with Properties


IBatchEvents Interface

API Reference > Objects > Project Structure >

IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This is a callback interface that is used for reporting events from the Project and Batch objects to the listeners. This interface is implemented on the client side. See the detailed implementation advice for your development tool in Working with Connectable Objects. Below you can find a short summary.

In C++ you need to implement the IBatchEvents interface, obtain a connection point, and "advise" object implementing the interface to the Project or Batch object. As the interface is derived from the IUnknown interface, the client object should also implement the IUnknown methods.

Visual Basic users that want to receive notifications from one of these objects should declare the event source object of the BatchEventSource type WithEvents, initialize it with the Project or Batch object and implement the Sub similar to the following:

Private Sub eventsSource_OnBatchProgress(ByVal Batch As FCEngine.IBatch, _
ByVal ProcessedItemsCount As Int, _
ByVal RemainingItemsCount As Int)
...
End Sub

An object receiving notifications through this interface methods may do the following inside the methods implementation:

·Process any Windows messages, which is useful in applications having User Interface, to avoid an effect that the application "is not responding" during long recognition operations.

·Report percentage of Document Definitions matching, recognition, and export.

·Report recognizer tips, errors and warnings to the user.

·Report information about processing operation completed.

Methods

Name

Description

OnBatchProgress

Delivers to the client information about approximate percentage of the current operation (Document Definition matching, recognition, and export).

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

OnError

Delivers to the client information about the errors which occur during page processing.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

OnPageProgress

Delivers to the client information about page processing completed.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

OnPageRectProcessed

Delivers to the client information about processed page region.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

OnProcessMessages

Allows the client to terminate the current operation of batch processing.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

OnRecognizerTip

Delivers to the client recognizer tips.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

OnWarning

Delivers to the client information about the warnings which occur during page processing.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

See also

Batch

Project

Working with Connectable Objects

See sample: FlexiCapture Engine Code Snippets


OnBatchProgress Method of the IBatchEvents Interface

API Reference > Objects > Project Structure > IBatchEvents >

OnBatchProgress Method of the IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the Project and Batch objects. It delivers to the client information about the number of processed and remaining to process pages. Its implementation may show a progress indicator.

Syntax

Visual Basic .NET

Sub OnBatchProgress( _
ByVal batch As IBatch, _
ByVal processedItemsCount As Int, _
ByVal remainingItemsCount As Int _
)

C++

HRESULT OnBatchProgress(
IBatch* batch,
int processedItemsCount,
int remainingItemsCount
);

Parameters

batch

[in] This parameter refers to the Batch object which sends notifications.

processedItemsCount

[in] This parameter contains the number of processed pages.

remainingItemsCount

[in] This parameter contains the number of pages remaining to process.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IBatchEvents

Batch

Project

See sample: FlexiCapture Engine Code Snippets


OnError Method of the IBatchEvents Interface

API Reference > Objects > Project Structure > IBatchEvents >

OnError Method of the IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the Project and Batch objects. It delivers to the client information about the errors which occur during page processing.

Syntax

Visual Basic .NET

Sub OnError( _
ByVal Page As Page, _
ByVal ErrorMessage As String, _
ByRef ShouldTerminate As Boolean _
)

C++

HRESULT OnError(
IPage* Page,
BSTR ErrorMessage
VARIANT_BOOL* ShouldTerminate
);

Parameters

Page

[in] This parameter refers to the Page object corresponding to the page which is currently processed.

ErrorMessage

[in] This parameter contains the text description of the error.

ShouldTerminate

[in, out] You may set this variable to TRUE to indicate that the process should be terminated. In this case the current processing function returns E_ABORT.

Return values

[C++ only] If this method returns a value other than S_OK, it indicates that an error occurred on the client side, and in this case the value of the ShouldTerminate parameter is not taken into account.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IBatchEvents

Batch

Project


OnPageProgress Method of the IBatchEvents Interface

API Reference > Objects > Project Structure > IBatchEvents >

OnPageProgress Method of the IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the Project and Batch objects. It delivers to the client information about approximate percentage of the current operation of page processing (Document Definitions matching, recognition, or export). Its implementation may show a progress indicator.

Syntax

Visual Basic .NET

Sub OnPageProgress( _
ByVal Page As Page, _
ByVal Percentage As Int _
)

C++

HRESULT OnPageProgress(
IPage* Page,
int Percentage
);

Parameters

Page

[in] This parameter refers to the Page object corresponding to the page which is currently processed.

Percentage

[in] This parameter contains the percent of the work currently done. It is in the range from 0 to 100.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IBatchEvents

Batch

Project


OnPageRectProcessed Method of the IBatchEvents Interface

API Reference > Objects > Project Structure > IBatchEvents >

OnPageRectProcessed Method of the IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the Project and Batch objects. It delivers to the client information about processed page region – a rectangle on the page image which has been already processed.

Syntax

Visual Basic .NET

Sub OnPageRectProcessed( _
ByVal Page As Page, _
ByVal RecognitionPassNumber As Int, _
ByVal Left As Int, _
ByVal Top As Int, _
ByVal Right As Int, _
ByVal Bottom As Int _
)

C++

HRESULT OnPageRectProcessed(
IPage* Page,
int RecognitionPassNumber
int Left,
int Top,
int Right,
int Bottom
);

Parameters

Page

[in] This parameter refers to the Page object corresponding to the page which is currently processed.

RecognitionPassNumber

[in] This parameter reports the number of the recognition pass. It may be 0, 1 or 2. Rectangles from different passes may be filled up with different colors.

Left

[in] This parameter reports the coordinate of left border of the processed rectangle.

Top

[in] This parameter reports the coordinate of top border of the processed rectangle.

Right

[in] This parameter reports the coordinate of right border of the processed rectangle.

Bottom

[in] This parameter reports the coordinate of bottom border of the processed rectangle.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IBatchEvents

Batch

Project


OnProcessMessages Method of the IBatchEvents Interface

API Reference > Objects > Project Structure > IBatchEvents >

OnProcessMessages Method of the IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the Project and Batch objects. It allows the client to terminate the current operation of batch processing (Document Definitions matching, recognition, or export). It may also process any Windows messages to avoid an effect that the application "is not responding" during long recognition operations.

Syntax

Visual Basic .NET

Sub OnProcessMessages(ByRef ShouldTerminate As Boolean)

C++

HRESULT OnProcessMessages(
VARIANT_BOOL* ShouldTerminate
);

Parameters

ShouldTerminate

[in, out] You may set this variable to TRUE to indicate that the process should be terminated. In this case the current processing function returns E_ABORT.

Return values

[C++ only] If this method returns a value other than S_OK, it indicates that an error occurred on the client side, and in this case the value of the ShouldTerminate parameter is not taken into account.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IBatchEvents

Batch

Project

See sample: FlexiCapture Engine Code Snippets


OnRecognizerTip Method of the IBatchEvents Interface

API Reference > Objects > Project Structure > IBatchEvents >

OnRecognizerTip Method of the IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the Project and Batch objects. It delivers to the client recognizer tips.

Syntax

Visual Basic .NET

Sub OnRecognizerTip( _
ByVal Page As Page, _
ByVal RecognizerTip As String _
)

C++

HRESULT OnRecognizerTip(
IPage* Page,
BSTR RecognizerTip
);

Parameters

Page

[in] This parameter refers to the Page object corresponding to the page which is currently processed.

RecognizerTip

[in] This parameter contains the recognizer tip.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IBatchEvents

Batch

Project

See sample: FlexiCapture Engine Code Snippets


OnWarning Method of the IBatchEvents Interface

API Reference > Objects > Project Structure > IBatchEvents >

OnWarning Method of the IBatchEvents Interface

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the Project and Batch objects. It delivers to the client information about the warnings which occur during page processing. You can create, display, and operate a message box in this method.

Syntax

Visual Basic .NET

Sub OnWarning(
ByVal Page As Page, _
ByVal Text As String, _
ByVal Title As String, _
ByVal Type As Int, _
ByRef MessageBoxResult As Int _
)

C++

HRESULT OnWarning(
IPage* Page,
BSTR Text,
BSTR Title,
int Type,
int* MessageBoxResult
);

Parameters

Page

[in] This parameter refers to the Page object corresponding to the page which is currently processed.

Text

[in] This parameter contains the text description of the warning.

Title

[in] This parameter contains the message box title.

Type

[in] This parameter specifies the contents and behavior of the dialog box. This parameter can be a combination of MB_* flags. See the MSDN Library (http://msdn.microsoft.com/en-us/library/ms645505(VS.85).aspx) for details.

MessageBoxResult

[in, out] This parameter contains the result of the warning processing.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

IBatchEvents

Batch

Project


Document Structure Objects

API Reference > Objects >

Document Structure Objects

A document is a combination of one or several page images and data extracted from them. The document is represented by the Document object. Recognized document contains a set of pages with recognized blocks on them and a set of fields. Blocks contain the data received after recognition, while the fields contain recognized data with applied rules, imposed on these data by the Document Definition.

This section describes the following objects which provide access to the structure of the document:

·Documents(deprecated)

·DocumentsCollection

·Document

·Pages

·Page

·Fields

·Field

·FieldInstances

·FieldValue

·FieldChoiceValue

·FieldPictureValue

·FieldValuesCollection

·Blocks

·BlocksCollection

·Block

·and block types objects:

oBarcodeBlock

oCheckmarkGroupBlock

oCheckmarkBlock

oTextBlock

oTableBlock

oTableColumns

oTableColumn

You can find additional information in the Working with Recognized Data section.

The hierarchy of the objects


Documents Object

Documents Object (IDocuments Interface)

API Reference > Objects > Document Structure >

Documents Object (IDocuments Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object is a collection of batch documents. Besides standard collection methods and properties, it contains the methods for managing documents in the collection (moving, merging, splitting). The properties and methods of the object return closed documents (IDocument::LockType = LT_None). To receive the collection of documents of a certain batch, use the Documents property of the corresponding Batch object.

The Documents object is a so-called "connectable object". The methods of the Documents object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Document, read-only | Provides access to a single element of the collection.

Methods

Name

Description

AddNewFromPage

Creates a new document at the specified position in the batch by extracting the specified page from an existing document.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

FindByID

Provides access to an element of the collection by element ID.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Item

Provides access to a single element of the collection.

DeleteByID

Removes an element with the specified identifier from the collection.

DeleteAll

Removes all the elements from the collection.

Disassemble

Splits specified documents into pages.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Merge

Merges specified documents into one document.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

MoveByID

Changes the position of the specified document.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Related objects

See also

Document

Batch

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


AddNewFromPage Method of the Documents Object

API Reference > Objects > Document Structure > Documents >

AddNewFromPage Method of the Documents Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method creates a new document at the specified position in the batch by extracting the specified page from an existing document.

note Note: If the document in question has only one page, it will not be duplicated. The number of documents in the batch will stay the same.

Syntax

Visual Basic .NET

Function AddNewFromPage( _
page As Page, _
pos As Int
) As Document

C++

HRESULT AddNewFromPage(
IPage* page,
int pos,
IDocument** result
);

Parameters

page

[in] Refers to the Page object, which contains the page from which a new document should be created.

pos

[in] Specifies the index of the new document in the current batch. If the document is inserted in place of the existing document, the documents in the batch are shifted to the right. The document may also be inserted at the end of the batch, in which case the value of this parameter must be equal to the value of the IDocuments::Count property.

result

[out, retval] A pointer to the IDocument* variable that receives the interface pointer for the new document.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Documents


Disassemble Method of the Documents Object

API Reference > Objects > Document Structure > Documents >

Disassemble Method of the Documents Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method splits specified documents into pages.

Syntax

Visual Basic .NET

Sub Disassemble(DocIds As IntsCollection)

C++

HRESULT Disassemble(
IIntsCollection* DocIds
);

Parameters

DocIds

[in] This variable refers to the IntsCollection object that contains the identifiers of the documents which are to be split.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Documents


FindById Method of the Documents Object

API Reference > Objects > Document Structure > Documents >

FindById Method of the Documents Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to find a document by its identifier. The method returns closed document (IDocument::LockType = LT_None).

Syntax

Visual Basic .NET

Function FindByID(ID As Int) As Document

C++

HRESULT FindByID(
int ID,
IDocument** Result
);

Parameters

ID

[in] This variable contains the identifier of the document to be found.

Result

[out, retval] A pointer to the IDocument* variable that receives the interface pointer for the document. Returns NULL, if the document with the specified identifier is not found.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Documents


Merge Method of the Documents Object

API Reference > Objects > Document Structure > Documents >

Merge Method of the Documents Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method merges specified documents into one document. The method returns a closed document (IDocument::LockType = LT_None).

Syntax

Visual Basic .NET

Function Merge(DocIds As IntsCollection) As Document

C++

HRESULT Merge(
IIntsCollection* DocIds,
IDocument** Result
);

Parameters

DocIds

[in] This variable refers to the IntsCollection object that contains the identifiers of the documents which are to be merged.

Result

[out, retval] A pointer to the IDocument* variable that receives the interface pointer for the created document.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Documents


MoveById Method of the Documents Object

API Reference > Objects > Document Structure > Documents >

MoveById Method of the Documents Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to move the document with the specified identifier to the selected position in the collection.

Syntax

Visual Basic .NET

Sub MoveByID( _
Id As Int, _
NewPos As Int _
)

C++

HRESULT MoveByID(
int Id,
int NewPos
);

Parameters

Id

[in] This variable contains the identifier of the document which is to be moved. The identifier should be received as the value of the IDocument::ID property.

NewPos

[in] The document will be placed in the position before the document with this index. Must be in a range from 1 to the value of the IDocuments::Count property.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Documents


DocumentsCollection Object

DocumentsCollection Object (IDocumentsCollection Interface)

API Reference > Objects > Document Structure >

DocumentsCollection Object (IDocumentsCollection Interface)

This object is a collection of references to Document objects. This object is used as a parameter of the IEngine::CreateVerificationSession method. See Working with Collections.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Document, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Add | Adds an element at the end of the collection.
Item | Provides access to a Document object in the collection.

Related objects

Output parameter

This object is the output parameter of the CreateDocumentsCollection method of the Engine object.

Input parameter

This object is the input parameter of the CreateVerificationSession method of the Engine object.

See also

Document

Working with Collections

Documents

Working with Properties

See sample: FlexiCapture Engine Code Snippets


Add Method of DocumentsCollection Object

API Reference > Objects > Document Structure > DocumentsCollection >

Add Method of DocumentsCollection Object

This method adds a document at the end of the collection. The method adds a reference to an existing object.

Syntax

Visual Basic .NET

Sub Add(item As Document)

C++

HRESULT Add(
IDocument* item
);

Parameters

item

[in] Refers to the Document object, which should be added to the collection of documents.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

DocumentsCollection

Working with Collections


Document Object

Document Object (IDocument Interface)

API Reference > Objects > Document Structure >

Document Object (IDocument Interface)

This object corresponds to a processing document. A document is received as a result of work of the FlexiCapture processor.

The newly created Document object contains a collection of document pages which are accessible through the Pages property. During document definitions matching data fields are found in the document. You can access these fields via the Sections property, which refers to the sections of the document. These sections have child fields. Each child field can be either a group of fields (and has own child fields), or a simple field (without child fields). See Working with Recognized Data for details. After data extraction and recognition the document can be exported. If errors occur during document processing, information about these errors can be found in the corresponding properties of the Document object (AssemblingErrors, RuleErrors).

The Document object is also used in project editing scenarios as a part of a batch.

note Note: Working with projects in ABBYY FlexiCapture Engine 12 is deprecated and will be removed in future versions.

The Document object supports a set of supplementary interfaces:

·IField – The whole document can be considered as the top-level field which contains all the data fields of the document. Support of this interface means that you can treat the Document object as the Field object.

·ICustomStorage – This means that the Document object allows saving its state in a custom storage.

·IUndoable – This interface provides the ability to undo and redo the latest operations performed on the Document object.

Properties

Name

Type

Description

AsCustomStorage

ICustomStorage, read-only

Converts the document to ICustomStorage interface.

AsField

IField, read-only

Converts the document to IField interface.

AsUndoable

IUndoable, read-only

Converts the document to IUndoable interface.

AssemblingErrors

AssemblingErrors, read-only

Returns a collection of assembly errors.

Batch

Batch, read-only

Provides access to the Batch object the document belongs to.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Comment

String

Allows you to specify any text comment for the document. This comment can be viewed in ABBYY FlexiCapture.

DocumentDefinition

DocumentDefinition, read-only

Returns the Document Definition applied to the document.

HasRuleErrors

Boolean, read-only

Specifies whether the document has rule errors. Unlike the RuleErrors property, this property is available for a closed document.

ID

Int, read-only

Specifies the document identifier.

IsExported

Boolean, read-only

Specifies whether the document has been exported to the destination specified in the Document Definition (i.e. it has been exported with default parameters).

IsVerified

Boolean, read-only

Specifies whether the document has been verified.

LockType

LockTypeEnum, read-only

Returns the state of the document. The document can be closed, open for reading, or open for reading and writing.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Pages

Pages, read-only

Returns a collection of pages of the document.

RuleErrors

RuleErrors, read-only

Returns a collection of errors for unfulfilled rules.

Sections

Fields, read-only

Provides access to the sections of the document. These sections have child fields. Each child field can be either a group of fields (and has own child fields), or a simple field (without child fields). See Working with Recognized Data for details.

Title

String

Specifies the name of the document.

Methods

Name | Description
CheckRules | Checks all rules imposed on data in the specified field.
Open | Opens the document. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
RecognizeBlocks | Recognizes a collection of blocks in the document.
Save | Saves changes made to the document. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Close | Closes the document. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Related objects

Output parameter

This object is the output parameter of the following methods:

·RecognizeNextDocument method of the FlexiCaptureProcessor object

·Item, FindByID, Merge, AddNewFromPage methods of the Documents object (deprecated)

Input parameter

This object is the input parameter of the following methods:

·ImportImages method of the Project object (deprecated)

·Add method of the DocumentsCollection object

See also

Working with Recognized Data

Working with Properties

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing, Mobile Data Capture, Classification, Color Stamps Removal, Redaction


CheckRules Method of the Document Object

API Reference > Objects > Document Structure > Document >

CheckRules Method of the Document Object

This method allows you to check all rules imposed on data in the specified field. The rules are checked automatically after recognition, so there is no need to call this method manually immediately after recognition. You should call the method, if you have changed something in the document, e.g. correct the value of some field.

Syntax

Visual Basic .NET

Sub CheckRules(ModifiedField As Field)

C++

HRESULT CheckRules(
IField* ModifiedField
);

Parameters

ModifiedField

[in] This variable refers to the Field object corresponding to the document field in which rules are to be checked.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Document


Close Method of the Document Object

API Reference > Objects > Document Structure > Document >

Close Method of the Document Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method closes the document. It allows you to free some resources and save the changes made to the document. The method can be called on the documents received from the FlexiCaptureProcessor object by the RecognizeNextDocument method.

Note that if you save changes on close, the changed fields must be verified using the CheckRules method before closing the document.

warning Important! The documents received from the FlexiCaptureProcessor object are kept in memory, and you do not need explicitly open or close such documents, or save changes in them.

Syntax

Visual Basic .NET

Sub Close(SaveChanges As Boolean)

C++

HRESULT Close(
VARIANT_BOOL SaveChanges
);

Parameters

SaveChanges

[in] This variable specifies whether the changes made to the document should be saved. If the value of this parameter is FALSE, the changes are not saved. This parameter is optional. The default value of the parameter is TRUE.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Document

IDocument::Open

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


Open Method of the Document Object

API Reference > Objects > Document Structure > Document >

Open Method of the Document Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method opens the document, which belongs to some project. To work with such document (access its structure, parameters, etc.), you should first open it. Depending on the parameter passed to this method the document can be opened for reading or writing. To close the document, use the Close method of the Document object.

warning Important! The documents received from the FlexiCaptureProcessor object are kept in memory, and you do not need explicitly open or close such documents, or save changes in them.

Syntax

Visual Basic .NET

Sub Open(WriteAccess As Boolean)

C++

HRESULT Open(
VARIANT_BOOL WriteAccess
);

Parameters

WriteAccess

[in] This variable specifies whether the document is opened for reading or writing. If the value of this parameter is FALSE, the document is opened for reading. If you want to edit the document set this parameter to TRUE. This parameter is optional. The default value of the parameter is TRUE.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Document

IDocument::Close

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


RecognizeBlocks Method of the Document Object

API Reference > Objects > Document Structure > Document >

RecognizeBlocks Method of the Document Object

This method allows you to recognize a collection of blocks in the document.

Syntax

Visual Basic .NET

Sub RecognizeBlocks(blocks As BlocksCollection)

C++

HRESULT RecognizeBlocks(
IBlocksCollection* blocks
);

Parameters

blocks

[in] Refers to the BlocksCollection object, which contains the blocks to be recognized.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Samples

cicon2 C++ (COM) code

FCEngine::IEnginePtr Engine;
FCEngine::IBlockPtr block;
FCEngine::IDocumentPtr document;
FCEngine::IBlocksCollectionPtr blocks = Engine->CreateBlocksCollection();
blocks->Add(block);
...
document->RecognizeBlocks(blocks);

See also

Document


Save Method of the Document Object

API Reference > Objects > Document Structure > Document >

Save Method of the Document Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method saves changes made to the document, which belongs to some project. The method does not change the state of the document (the IDocument::LockType property).

Note that before saving, the changed fields must be verified using the CheckRules method.

warning Important! The documents received from the FlexiCaptureProcessor object are kept in memory, and you do not need explicitly open or close such documents, or save changes in them.

Syntax

Visual Basic .NET

Sub Save()

C++

HRESULT Save();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Document


Pages Object

Pages Object (IPages Interface)

API Reference > Objects > Document Structure >

Pages Object (IPages Interface)

This object is a collection of document pages. Besides standard collection methods and properties, it contains the MoveByID method that allows you to move pages in the document. To access the pages of the certain document use the Pages property of the corresponding Document object.

The Pages object is a so-called "connectable object". The methods of the Pages object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Page, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Attach | Moves the specified page from one document to another.
DeleteByID | Removes an element with the specified identifier from the collection.
Item | Provides access to a single element of the collection.
MoveByID | Moves an element to the specified position in the collection.

Related objects

See also

Document

Page

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture


Attach Method of the Pages Object

API Reference > Objects > Document Structure > Pages >

Attach Method of the Pages Object

This method allows you to move the specified page from one document to another.

Syntax

Visual Basic .NET

Sub Attach( _
page As Page, _
position As Int _
)

C++

HRESULT Attach(
IPage* page,
int position
);

Parameters

page

[in] This variable refers to the page which is to be moved.

position

[in] An index defining the point to move page to. Must be in a range from 0 to the value of the IPages::Count property.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Pages


MoveById Method of the Pages Object

API Reference > Objects > Document Structure > Pages >

MoveById Method of the Pages Object

This method allows you to move the page in the collection.

Syntax

Visual Basic .NET

Sub MoveByID( _
Id As Int, _
NewIndex As Int _
)

C++

HRESULT MoveByID(
int Id,
int NewIndex
);

Parameters

Id

[in] This variable contains the identifier of the page which is to be moved. The identifier should be received as the value of the IPage::ID property.

NewIndex

[in] The page will be placed in the position before the page with this index. Must be in a range from 1 to the value of the IPages::Count property.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Pages


Page Object

Page Object (IPage Interface)

API Reference > Objects > Document Structure >

Page Object (IPage Interface)

This object corresponds to a page of a document. A page represents an image of a document page and results of its processing. It provides a set of properties and methods for working with page image and managing page state. All the pages of the document are represented by the Pages object.

The whole page can be considered as the top-level block which contains all the blocks of the page. The Page object supports the IBlock interface. You may treat this object as the Block object.

Properties

Name | Type | Description
Blocks | Blocks, read-only | Returns the collection of page blocks.
ErrorText | String, read-only | Returns the text description of the error which occurred while processing the page.
ID | Int, read-only | Returns the identifier of the page.
Index | Int, read-only | Returns the index of the page in the collection of pages.
Image | ImageDocument, read-only | Provides access to the image of the page. The value of this property can be changed. If you do not want to change the image of the page you can use the ReadOnlyImage property.
ImageRotation | RotationTypeEnum, read-only | Specifies rotation that was performed upon the page image after opening or after the last call to IImageDocument::SaveModified method.
IsAnalyzed | Boolean, read-only | Specifies whether the page has been analyzed.
IsRecognized | Boolean, read-only | Specifies whether the page has been recognized.
KeyValue | FieldValue, read-only | Returns the key field value. The key field enables automatic checking of page assembly into documents. The values of key fields must be identical on all pages of the same document.
Name | String, read-only | Returns the name of the page.
OriginalImagePath | String, read-only | Returns the full path to the original image of the page.
PageDefinition | PageDefinition, read-only | Returns the Document Definition page applied to the document page.
ReadOnlyImage | ImageDocument, read-only | Provides access to the read-only image of the page. The value of this property cannot be changed. If you want to change the image of the page you should use the Image property.
SectionDefinition | SectionDefinition, read-only | Returns the section definition which contains the page definition applied to the document page.
SourceImageInfo | SourceImageInfo, read-only | Contains information about the source image.
Type | PageTypeEnum, read-only | Specifies the type of the page.
WarningText | String, read-only | Returns the text description of the warning which occurred while processing the page.

Methods

Name | Description
ChangeResolution | Changes resolution of the page image.
TransformImage | Performs specified transformations of the page image.
ExtractTextRegions | Extracts background text regions on the page.

Related objects

Output parameter

This object is the output parameter of the Item method of the Pages object.

Input parameter

This object is the input parameter of the following methods:

·MatchBlock method of the Block object

·AddNewFromPage method of the Documents object (deprecated)

See also

Pages

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture


ChangeResolution Method of Page Object

ChangeResolution Method of the Page Object

API Reference > Objects > Document Structure > Page >

ChangeResolution Method of the Page Object

This method changes the resolution of the page image. The size of the image in pixels remains unchanged.

Syntax

Visual Basic .NET

Sub ChangeResolution(NewResolution As Int)

C++

HRESULT ChangeResolution(
int NewResolution
);

Parameters

NewResolution

[in] The parameter contains the new value of the resolution. Must be greater than 0.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

Unlike the IImageDocument::ChangeResolution method this method allows you to change resolution of an image in a batch.

See also

Page


ExtractTextRegions Method of Page Object

ExtractTextRegions Method of the Page Object

API Reference > Objects > Document Structure > Page >

ExtractTextRegions Method of the Page Object

This method extracts text regions on the page. It allows you to access all background text on the recognized page, which might then be used for various purposes, such as indexing the documents for a future search, moving a block to the selected text, etc.

warning Important! This method works with flexible documents only.

Syntax

Visual Basic .NET

Function ExtractTextRegions() As TextRegions

C++

HRESULT ExtractTextRegions(
ITextRegions** result
);

Parameters

result

[out, retval] A pointer to the ITextRegions* variable that receives the interface pointer for the collection of all text regions found on the page.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Page

See sample: FlexiCapture Engine Code Snippets


TransformImage Method of the Page Object

API Reference > Objects > Document Structure > Page >

TransformImage Method of the Page Object

This method transforms the image of the current page. Among available transformations are inversion of colors, mirroring, rotation by 90, 180 and 270 degrees, etc.

Syntax

Visual Basic .NET

Sub TransformImage(TransformationType As ImageTransformationEnum)

C++

HRESULT TransformImage(
ImageTransformationEnum TransformationType
);

Parameters

TransformationType

[in] This variable specifies the transformation type. See the ImageTransformationEnum description for the supported transformations.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Page


Fields Object

Fields Object (IFields Interface)

API Reference > Objects > Document Structure >

Fields Object (IFields Interface)

This object is a collection of recognized fields. It may be a collection of document sections, or a collection of child fields of a composite field.

note Note: When working with recognized data of a document you must take into account that a document may have complex tree-like structure: document consists of sections, sections contain fields and group of fields and all of these may be repeating (contain multiple instances). See Working with Recognized Data for details.

Besides standard collection methods and properties, it contains the FindByName method that allows you to find the field by its name.

The Fields object is a so-called "connectable object". The methods of the Fields object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Field, read-only | Provides access to a single element of the collection.

Methods

Name | Description
FindByName | Finds an element by its name.
Item | Provides access to a single element of the collection.

Related objects

See also

Working with Recognized Data

Field

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, FlexiCapture Web Service, Mobile Data Capture, Color Stamps Removal, Redaction


FindByName Method of the Fields Object

API Reference > Objects > Document Structure > Fields >

FindByName Method of the Fields Object

This method allows you to find a field by its name.

Syntax

Visual Basic .NET

Function FindByName(Name As String) As Field

C++

HRESULT FindByName(
BSTR Name,
IField** Result
);

Parameters

Name

[in] This variable contains the name of the field to be found.

Result

[out, retval] A pointer to the IField* variable that receives the interface pointer for the field. Returns NULL, if the field with the specified name is not found.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Fields

Field

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, FlexiCapture Web Service, Mobile Data Capture, Color Stamps Removal, Redaction


Field Object

Field Object (IField Interface)

API Reference > Objects > Document Structure >

Field Object (IField Interface)

This object corresponds to a field of a document. A field is a document element intended for data extraction. Fields may be simple (without an internal structure) or composite, such as the table field where each cell can be viewed as a separate subordinate field of the table. See Working with Recognized Data for details.

A field can have several instances (the Instances property). This means that the field used to describe several variants of the same object. In essence, these multiple objects are one and the same field and share the same properties.

Each document field corresponds to the field of the Document Definition applied to the document (the document definition field is accessible through the FieldDefinition property).

Properties

Name | Type | Description
Blocks | BlocksCollection, read-only | Stores the collection of blocks, which corresponds to the field.
Children | Fields, read-only | Returns a collection of child fields of the composite field.
Document | Document, read-only | Provides access to the document containing the field.
FieldDefinition | FieldDefinition, read-only | Returns the corresponding field of the Document Definition applied to the document.
FullName | String, read-only | Returns the full name of the field. If this field is a subfield of a composite field, the full name contains the name of the field and names of all its parent fields. If the field is an instance of some field, the full name will include its index in the parent field. For example, "Invoice\InvoiceTable[0]\Quantity". If the field is simple, the value of the property is equal to the value of the Name property.
Instances | FieldInstances, read-only | Returns the collection of field instances (for the field with several instances).
Name | String, read-only | Returns the name of the field.
Suggests | StringsCollection, read-only | Returns the collection of suggestions for the field value.
Type | FieldTypeEnum, read-only | Returns the type of the field.
Value | FieldValue, read-only | Returns the field value.

Methods

Name | Description
ApplySuggest | Allows you to select one of the suggestions for the value of the field.

Related objects

Output parameter

This object is the output parameter of the following methods:

·Item, FindByName methods of the Fields object

·Item, AddNew method of the FieldInstances object

Input parameter

This object is the input parameter of the CheckRules method of the Document object.

See also

Working with Recognized Data

Fields

FieldInstances

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, FlexiCapture Web Service, Mobile Data Capture, Color Stamps Removal, Redaction


ApplySuggest Method of Field Object

ApplySuggest Method of the Field Object

API Reference > Objects > Document Structure > Field >

ApplySuggest Method of the Field Object

This method allows you to select one of the suggestions (see IField::Suggests) for the value of the field.

Syntax

Visual Basic .NET

Sub ApplySuggest(Suggest As String)

C++

HRESULT ApplySuggest(
BSTR Suggest
);

Parameters

Suggest

[in] This parameter specifies the suggestion which should be applied.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Field


FieldInstances Object

FieldInstances Object (IFieldInstances Interface)

API Reference > Objects > Document Structure >

FieldInstances Object (IFieldInstances Interface)

This object is a collection of field instances. The field instances are fields that occur several times in the form and describe several variants of the same object, such as several telephone numbers or addresses of one person, several table rows of one consignment note, etc. Fields with several instances allows you to link related data and not to use several identical unrelated fields instead.

Any field can have several instances. Their regions can be located at a distance from one another or even on different pages. Field instances have the same properties. See Working with Recognized Data for details.

To access the instances of the certain field, use the Instances property of the corresponding Field object.

The FieldInstances object is a so-called "connectable object". The methods of the FieldInstances object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Field, read-only | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Adds a new element to the collection.
Item | Provides access to a single element of the collection.
DeleteAt | Removes an element from the collection.

Related objects

See also

Working with Recognized Data

Field

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


AddNew Method of the FieldInstances Object

API Reference > Objects > Document Structure > FieldInstances >

AddNew Method of the FieldInstances Object

This method adds a field instance at the specified position in the collection.

Syntax

Visual Basic .NET

Function AddNew(Index As Int) As Field

C++

HRESULT AddNew(
int Index,
IField** Result
);

Parameters

Index

[in] Specifies the index of the field instance in the collection. The value of this parameter can be -1, which means that the field instance is added at the end of the collection.

Result

[out, retval] A pointer to the IField* variable that receives the interface pointer for the added field instance.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FieldInstances

Field


DeleteAt Method

API Reference > Objects > Document Structure > FieldInstances >

DeleteAt Method

This method is specific to collection objects. It removes an element from collection by its index.

Syntax

Visual Basic .NET

Sub DeleteAt(Index As Int)

C++

HRESULT DeleteAt(
int Index
);

Parameters

Index

[in] This variable contains the index of the collection element. It should be in a range from 0 to the value of the Count property of this collection minus 1.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions

Remarks

The following collection objects provide this method:

·HotFolderProfiles (the method is deprecated and will be removed in future versions)

·FieldInstances

·FieldValuesCollection

·

·IntsCollection

·StringsCollection

See also

DeleteAll

Working with Collections


FieldValue Object

FieldValue Object (IFieldValue Interface)

API Reference > Objects > Document Structure >

FieldValue Object (IFieldValue Interface)

This object corresponds to a recognized value of a field. The value contains the data, which type is defined by the Type property. The value of the certain field is accessible through the Value property of the Field object.

Properties

Name | Type | Description
AsBoolean | Boolean | Stores the Boolean value. The property is available only if the value of the Type property is FVT_Boolean.
AsChoice | FieldChoiceValue, read-only | Stores the field choice value. The property is available only if the value of the Type property is FVT_Choice.
AsDateTime | DATE | Stores the date and time value. The property is available only if the value of the Type property is FVT_DateTime.
AsDouble | Double | Stores the double value. The property is available only if the value of the Type property is FVT_Number.
AsInteger | __int64 | Stores the integer value. The property is available only if the value of the Type property is FVT_Number.
AsPicture | FieldPictureValue, read-only | Stores the field picture value. The property is available only if the value of the Type property is FVT_Picture.
AsString | String, read-only | Stores the value in string format.
AsText | Text, read-only | Stores the text value. The property is available only if the value of the Type property is FVT_Text, FVT_DateTime, FVT_Number, FVT_Currency.
Errors | StringsCollection, read-only | Stores the errors received when applying field rules.
IsSuspicious | Boolean, read-only | Specifies whether the field value is uncertainly recognized.
IsValid | Boolean, read-only | Specifies whether the field value is valid (checks its type).
IsVerified | Boolean, read-only | Specifies if the field value had been verified. The property cannot be changed directly but via the SetVerified method.
NeedsVerification | Boolean, read-only | Specifies whether the field value is needed to be verified.
Type | FieldValueTypeEnum, read-only | Returns the type of the field value.
Warnings | StringsCollection, read-only | Stores the warnings received during recognition and applying field rules.

Methods

Name | Description
SetVerified | Sets the IsVerified property to TRUE.

Related objects

Output parameter

This object is the output parameter of the Item method of the FieldValuesCollection object.

Input parameter

This object is the input parameter of the Add method of the FieldValuesCollection object.

See also

Working with Recognized Data

FieldValuesCollection

Field

IPage::KeyValue

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


SetVerified Method of the FieldValue Object

API Reference > Objects > Document Structure > FieldValue >

SetVerified Method of the FieldValue Object

This method sets the IFieldValue::IsVerified property to TRUE.

Syntax

Visual Basic .NET

Sub SetVerified()

C++

HRESULT SetVerified();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FieldValue


FieldChoiceValue Object

FieldChoiceValue Object (IFieldChoiceValue Interface)

API Reference > Objects > Document Structure >

FieldChoiceValue Object (IFieldChoiceValue Interface)

This object corresponds to a recognized value of a choice field. The value of the certain choice field is accessible through the AsChoice property of the FieldValue object.

Properties

Name | Type | Description
SelectedChoices | FieldValuesCollection | Stores the selected choices of the field. note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate FieldValuesCollection object with the help of the IEngine::CreateFieldValuesCollection method, change the necessary parameters, and then assign this object to the property.
Choices | FieldValuesCollection, read-only | Stores all the choices of the field.

Related objects

See also

Working with Recognized Data

FieldValue

Working with Properties


FieldPictureValue Object

FieldPictureValue Object (IFieldPictureValue Interface)

API Reference > Objects > Document Structure >

FieldPictureValue Object (IFieldPictureValue Interface)

This object corresponds to a value of a picture field. The value of the certain field is accessible through the AsPicture property of the FieldValue object.

Properties

Name | Type | Description
ColorType | ImageColorTypeEnum, read-only | Specifies the color type of images (color, gray, or black-and-white).
CompressionRatio | Int, read-only | Specifies the compression ratio for images in JPEG format. The value of this property is in range from 0 to 100.
CompressionType | ImageCompressionTypeEnum, read-only | Specifies the image compression type.
FileFormat | ImageFileFormatEnum, read-only | Specifies the image file format.

Related objects

See also

Working with Recognized Data

FieldValue

Working with Properties


FieldValuesCollection Object

FieldValuesCollection Object (IFieldValuesCollection Interface)

API Reference > Objects > Document Structure >

FieldValuesCollection Object (IFieldValuesCollection Interface)

This object is a collection of field values. It is used for representation of a set of values for a choice field. To access the values of the certain choice field, use the Choices property of the corresponding FieldChoiceValue object.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | FieldValue, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Add | Adds a new element at the end of the collection.
CopyFrom | Initializes properties of the current object with values of similar properties of another object.
DeleteAt | Removes an element from the collection.
DeleteAll | Removes all the elements from the collection.
Item | Provides access to a single element of the collection.

Related objects

Output parameter

This object is the output parameter of the CreateFieldValuesCollection method of the Engine object.

See also

FieldChoiceValue

Working with Collections

Working with Properties


Add Method of Collection Objects

API Reference > Objects > Document Structure > FieldValuesCollection >

Add Method of Collection Objects

This method adds an element at the end of the collection. The method adds a reference to an existing object.

Syntax

Visual Basic .NET

Sub Add(Value As <CollectionType>)

C++

HRESULT Add(
<CollectionType> Value
);

Parameters

Value

[in] This parameter contains the newly added element. Its type depends on the type of collection and is described in the following table:

Collection type | Element type (Visual Basic/C++)
FieldValuesCollection | FieldValue/IFieldValue*
IntsCollection | Int/int
SectionDefinitionsCollection | SectionDefinition/ISectionDefinition*
StringsCollection | String/BSTR

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Working with Collections


CopyFrom Method

API Reference > Objects > Document Structure > FieldValuesCollection >

CopyFrom Method

This method initializes properties of the current object with the values of similar properties of another object.

Syntax

Visual Basic .NET

Sub CopyFrom(From As ObjectType)

C++

HRESULT CopyFrom(
IObjectType* From
);

Parameters

From

[in] This variable refers to the object of the same type as the current one. This object serves as a source data to be copied into the current object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following objects provide this method:

·BarcodeParams

·ExportParams

·FieldValuesCollection

·ImageGroupingParams

·ImageLoadingParams

·ImageProcessingParams

·JpegExtendedParams

·Language

·IntsCollection

·PageAnalysisParams

·Region

·StringsCollection

See also

Working with Collections


TextRegions Object

TextRegions Object (ITextRegions Interface)

API Reference > Objects > Document Structure >

TextRegions Object (ITextRegions Interface)

This object is a collection of text regions recognized on a page. It provides all the standard collection methods.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | TextRegion, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

Output parameter

This object is the output parameter of the ExtractTextRegions method of the Page object.

See also

Page

Working with Collections

See sample: FlexiCapture Engine Code Snippets


TextRegion Object

TextRegion Object (ITextRegion Interface)

API Reference > Objects > Document Structure >

TextRegion Object (ITextRegion Interface)

This object represents a background text region on a recognized page. This region does not necessarily match any of the document fields. You can use it in your program, for example, as a source of supplementary information about the page.

Properties

Name | Type | Description
Text | Text, read-only | Recognized text in the region.
Region | Region, read-only | Geometrical region.

Related objects

Output parameter

This object is the output parameter of the Item method of the TextRegions object.

See also

IPage::ExtractTextRegions

See sample: FlexiCapture Engine Code Snippets


Blocks Object

Blocks Object (IBlocks Interface)

API Reference > Objects > Document Structure >

Blocks Object (IBlocks Interface)

This object represents a collection of blocks. It may exist as subobject of the Page or Block object, and serves as a storage of page blocks or a storage of child blocks of the block, respectively.

The Blocks object is a so-called "connectable object". The methods of the Blocks object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Block, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a Block object in the collection.

Related objects

See also

Block

Working with Collections

ICollectionEvents

Working with Connectable Objects

BlocksCollection

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


BlocksCollection Object

BlocksCollection Object (IBlocksCollection Interface)

API Reference > Objects > Document Structure >

BlocksCollection Object (IBlocksCollection Interface)

This object represents a collection of blocks. This is a collection of references to Block objects. This is a subset of document blocks, which belongs to some field. This object is also used as a parameter of the IDocument::RecognizeBlocks method. See Working with Collections.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Block, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Add | Adds an element at the end of the collection.
Item | Provides access to a Block object in the collection.

Related objects

Output parameter

This object is the output parameter of the CreateBlocksCollection method of the Engine object.

Input parameter

This object is the input parameter of the RecognizeBlocks method of the Document object.

See also

Block

Field

Working with Collections

Blocks

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


Add Method of BlocksCollection Object

API Reference > Objects > Document Structure > BlocksCollection >

Add Method of BlocksCollection Object

This method adds a block at the end of the collection. The method adds a reference to an existing object.

Syntax

Visual Basic .NET

Sub Add(item As Block)

C++

HRESULT Add(
IBlock* item
);

Parameters

item

[in] Refers to the Block object, which should be added to the collection of blocks.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

BlocksCollection

Working with Collections


Block Object

Block Object (IBlock Interface)

API Reference > Objects > Document Structure >

Block Object (IBlock Interface)

This object represents a single block in the document. Blocks are objects that enclose areas on images. Blocks in the document appear after Document Definition has been successfully matched. The blocks reproduce the structure defined in the Document Definition: for each element of the Document Definition structure (section, page, block) blocks are found during Document Definitions matching. A part of image that lays inside the block is recognized in the way defined by the block type (the Type property). If it is a compound block (section, checkmark group, etc.), it will contain a set of child blocks which are accessible through the Children property. The Block object exposes methods which cast it to a type-specific interface and thereby provide access to the extended attributes of a block of specific type.

note Note: The block contents may differ from the value of corresponding field. This is due to the fact that the field contains recognized text to which some rules have been applied while the block contains only text received after recognition.

Properties

Name | Type | Description
BlockDefinition | BlockDefinition, read-only | Returns the block of the Document Definition corresponding to the document block.
Children | Blocks, read-only | Provides access to the collection of child blocks of the compound block.
Field | Field, read-only | Provides access to the field in the document which corresponds to the block.
FieldDefinition | FieldDefinition, read-only | Returns the field of the Document Definition which corresponds to the document block.
IsMatched | Boolean, read-only | Specifies whether the block has been correctly matched.
Page | Page, read-only | Provides access to the page which contains the block.
Parent | Block, read-only | Provides access to the parent block of the block.
Region | Region | Provides access to the block region. A region is a collection of rectangles placed one under another and having common top/bottom coordinates. That is, the bottom line of the upper rectangle touches the top line of the lower one. Unlike other types of blocks, a table block may have no more than one rectangle in its region, that's why an attempt to assign a region with more that one rectangle to a table block will result in an error.
Type | BlockTypeEnum, read-only | Specifies the type of the block.

Methods

Name | Description
AsBarcodeBlock | Returns the block as the BarcodeBlock object. If the block is not a barcode block, NULL is returned.
AsCheckmarkBlock | Returns the block as the CheckmarkBlock object. If the block is not a checkmark block, NULL is returned.
AsCheckmarkGroupBlock | Returns the block as the CheckmarkGroupBlock object. If the block is not a checkmark group block, NULL is returned.
AsTableBlock | Returns the block as the TableBlock object. If the block is not a table block, NULL is returned.
AsTextBlock | Returns the block as the TextBlock object. If the block is not a text block, NULL is returned.
MatchBlock | Matches the block to the region.
Move | Offsets the block region by some vector.

Related objects

Output parameter

This object is the output parameter of the following methods:

·Item method of the Blocks object

·Item method of the BlocksCollection object

·FindCellBlock method of the TableBlock object

Input parameter

This object is the input parameter of the Add method of the BlocksCollection object.

See also

Blocks

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


AsBarcodeBlock Method of the Block Object

API Reference > Objects > Document Structure > Block >

AsBarcodeBlock Method of the Block Object

This method returns the block as the BarcodeBlock object. If the block is not a barcode block, NULL is returned.

Syntax

Visual Basic .NET

Function AsBarcodeBlock() As BarcodeBlock

C++

HRESULT AsBarcodeBlock(
IBarcodeBlock** result
);

Parameters

result

[out, retval] A pointer to the IBarcodeBlock* pointer variable that receives the interface pointer to the returned BarcodeBlock object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Block

BarcodeBlock


AsCheckmarkBlock Method of the Block Object

API Reference > Objects > Document Structure > Block >

AsCheckmarkBlock Method of the Block Object

This method returns the block as the CheckmarkBlock object. If the block is not a checkmark block, NULL is returned.

Syntax

Visual Basic .NET

Function AsCheckmarkBlock() As CheckmarkBlock

C++

HRESULT AsCheckmarkBlock(
ICheckmarkBlock** result
);

Parameters

result

[out, retval] A pointer to the ICheckmarkBlock* pointer variable that receives the interface pointer to the returned CheckmarkBlock object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Block

CheckmarkBlock


AsCheckmarkGroupBlock Method of the Block Object

API Reference > Objects > Document Structure > Block >

AsCheckmarkGroupBlock Method of the Block Object

This method returns the block as the CheckmarkGroupBlock object. If the block is not a checkmark group block, NULL is returned.

Syntax

Visual Basic .NET

Function AsCheckmarkGroupBlock() As CheckmarkGroupBlock

C++

HRESULT AsCheckmarkGroupBlock(
ICheckmarkGroupBlock** result
);

Parameters

result

[out, retval] A pointer to the ICheckmarkGroupBlock* pointer variable that receives the interface pointer to the returned CheckmarkGroupBlock object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Block

CheckmarkGroupBlock


AsTableBlock Method of the Block Object

API Reference > Objects > Document Structure > Block >

AsTableBlock Method of the Block Object

This method returns the block as the TableBlock object. If the block is not a table block, NULL is returned.

Syntax

Visual Basic .NET

Function AsTableBlock() As TableBlock

C++

HRESULT AsTableBlock(
ITableBlock** result
);

Parameters

result

[out, retval] A pointer to the ITableBlock* pointer variable that receives the interface pointer to the returned TableBlock object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Block

TableBlock


AsTextBlock Method of the Block Object

API Reference > Objects > Document Structure > Block >

AsTextBlock Method of the Block Object

This method returns the block as the TextBlock object. If the block is not a text block, NULL is returned.

Syntax

Visual Basic .NET

Function AsTextBlock() As TextBlock

C++

HRESULT AsTextBlock(
ITextBlock** result
);

Parameters

result

[out, retval] A pointer to the ITextBlock* pointer variable that receives the interface pointer to the returned TextBlock object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Block

TextBlock


MatchBlock Method of the Block Object

API Reference > Objects > Document Structure > Block >

MatchBlock Method of the Block Object

This method matches the block to the region.

Syntax

Visual Basic .NET

Sub MatchBlock( _
Region As Region, _
Page As Page _
)

C++

HRESULT MatchBlock(
IRegion* Region,
IPage* Page
);

Parameters

Region

[in] Refers to the Region object, which specifies the new region of the block.

Page

[in] Refers to the Page object, which contains the page to place the region on. This parameter may be 0, in which case the new region of the block will be set on the same page where the block is located.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

Matching the block to the region is not equivalent to setting the region of the block using the IBlock::Region property.

See also

Block


Move Method of the Block Object

API Reference > Objects > Document Structure > Block >

Move Method of the Block Object

Use this method to move the region of the block on a page.

Syntax

Visual Basic .NET

Sub Move( _
DeltaX As Int, _
DeltaY As Int _
)

C++

HRESULT Move(
int DeltaX,
int DeltaY
);

Parameters

DeltaX

[in] Horizontal offset by which to move the region of the block.

DeltaY

[in] Vertical offset by which to move the region of the block.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Block


BarcodeBlock Object

BarcodeBlock Object (IBarcodeBlock Interface)

API Reference > Objects > Document Structure > Block Types >

BarcodeBlock Object (IBarcodeBlock Interface)

This object provides access to specific properties of a recognized barcode block. To access the properties of the certain barcode block, use the AsBarcodeBlock method of the corresponding Block object.

Properties

Name | Type | Description
Orientation | BarcodeOrientationEnum, read-only | Stores the barcode orientation type detected during the recognition process.
Text | Text, read-only | Provides access to the recognized text of the barcode.
Type | BarcodeTypeEnum, read-only | Stores the barcode type detected during the recognition process.

Related objects

Output parameter

This object is the output parameter of the AsBarcodeBlock method of the Block object.

See also

Block

Barcode Types

Working with Properties


CheckmarkBlock Object

CheckmarkBlock Object (ICheckmarkBlock Interface)

API Reference > Objects > Document Structure > Block Types >

CheckmarkBlock Object (ICheckmarkBlock Interface)

This object provides access to specific properties of a recognized checkmark block. A document may contain separate checkmarks as well as checkmark groups. To access the properties of the certain separate checkmark block, use the AsCheckmarkBlock method of the corresponding Block object. To access a checkmark of a group, use the Item method of the CheckmarkGroupBlock object.

Properties

Name | Type | Description
IsChecked | Boolean, read-only | Specifies whether the checkmark in the block was selected.
IsSuspicious | Boolean, read-only | This property set to TRUE means that the checkmark was recognized uncertainly.
Rectangle | Rectangle, read-only | Returns the coordinates of the checkmark rectangle.

Related objects

Output parameter

This object is the output parameter of the following methods:

·Item method of the CheckmarkGroupBlock object

·AsCheckmarkBlock method of the Block object

See also

Block

CheckmarkGroupBlock

Working with Properties


CheckmarkGroupBlock Object

CheckmarkGroupBlock Object (ICheckmarkGroupBlock Interface)

API Reference > Objects > Document Structure > Block Types >

CheckmarkGroupBlock Object (ICheckmarkGroupBlock Interface)

This object represents a recognized block which contains a group of checkmarks. To access the properties of the certain checkmark group block, use the AsCheckmarkGroupBlock method of the corresponding Block object.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the group.
Element | CheckmarkBlock, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single checkmark block of the group.

Related objects

Output parameter

This object is the output parameter of the AsCheckmarkGroupBlock method of the Block object.

See also

Block

CheckmarkBlock

Working with Properties


TextBlock Object

TextBlock Object (ITextBlock Interface)

API Reference > Objects > Document Structure > Block Types >

TextBlock Object (ITextBlock Interface)

This object provides access to the specific properties of a recognized text block. To access the properties of a certain text block use the AsTextBlock method of the corresponding Block object.

Properties

Name | Type | Description
Text | Text, read-only | This property is currently used only for internal purposes. Do not use it in your applications.
TextType | TextTypeEnum, read-only | Stores the type of the text.

Related objects

Output parameter

This object is the output parameter of the AsTextBlock method of the Block object.

See also

Block

Working with Properties


TableBlock Object

TableBlock Object (ITableBlock Interface)

API Reference > Objects > Document Structure > Block Types >

TableBlock Object (ITableBlock Interface)

This object provides access to specific properties of a recognized table block. To access the properties of the certain table block, use the AsTableBlock method of the corresponding Block object.

A recognized table may include bound columns, which correspond to a table field in a Document Definition, and unbound columns, for which no field were found in the Document Definition. Bound columns contain recognized data, while unbound do not contain any recognized data. You can access recognized data in the cells of bound columns using the Cell property. The picture below illustrates the meaning of the object's properties:

Properties

Name | Type | Description
BoundColumnsCount | Int, read-only | Stores the number of bound columns in the table. Each bound column corresponds to a column in the Document Definition. Also a recognized table can have unbound columns for which no columns were found in the Document Definition. The total number of columns in the table (bound and unbound) is defined by the Count property of the TableColumns object (the Columns property).
Cell | Block, read-only | Provides access to the specified table cell.
Columns | TableColumns, read-only | Provides access to the collection of table columns.
HSeparators | IntsCollection, read-only | Returns the coordinates of the horizontal separators of the table block. This collection always contains at least two elements corresponding to the table block top and bottom borders.
RowsCount | Int, read-only | Stores the number of rows in the table.

Methods

Name | Description
AddColumn | Adds a column to the table.
AddHSeparator | Adds the horizontal separator to the table.
DeleteColumn | Deletes the specified column from the table.
DeleteHSeparator | Deletes the horizontal separator from the table.
FindCellBlock | Allows you to find a cell block, associated with the cell, located at specified point.

Related objects

Output parameter

This object is the output parameter of the AsTableBlock method of the Block object.

See also

Block

Working with Properties


Cell Property of the TableBlock Object

API Reference > Objects > Document Structure > Block Types > TableBlock >

Cell Property of the TableBlock Object

This property provides access to the table cell block by cell coordinate in base coordinates of the table grid.

Syntax

Visual Basic .NET

Property Cell( _
I As Int, _
J As Int, _
) As Block
read-only

C++

HRESULT get_Cell(
int I,
int J,
IBlock** Result
);

Parameters

I

[in] This variable contains the horizontal coordinate of the point in base coordinates of the table grid. The value of this parameter is in range from 0 to ITableBlock::BoundColumnsCount -1.

J

[in] This variable contains the vertical coordinate of the point in base coordinates of the table grid. The value of this parameter is in range from 0 to ITableBlock::RowsCount -1.

Result

[out, retval] A pointer to the IBlock* variable that receives the interface pointer for the cell block.

Return values

This property has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

Cell coordinates in a base grid are the coordinates of its left top corner in that grid. By the base grid here we assume the grid formed by table borders and separators. Each vertical separator increments the horizontal coordinate by one, and each horizontal separator increments the vertical coordinate by one. Coordinate axes are oriented from left to right and from top to bottom.

See also

TableBlock

Working with Properties


AddColumn Method of the TableBlock Object

API Reference > Objects > Document Structure > Block Types > TableBlock >

AddColumn Method of the TableBlock Object

This method adds a column to the table.

Syntax

Visual Basic .NET

Function AddColumn(X As Int) As TableColumn

C++

HRESULT AddColumn(
int X,
ITableColumn** Result
);

Parameters

X

[in] This parameter specifies the coordinate of the column border. The specified coordinate must be in range from left to right coordinate of an existing column. The method divides this column into two columns.

Result

[out, retval] A pointer to the ITableColumn* variable that receives the interface pointer for the added column.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TableBlock

TableColumn


AddHSeparator Method of the TableBlock Object

API Reference > Objects > Document Structure > Block Types > TableBlock >

AddHSeparator Method of the TableBlock Object

This method adds the horizontal separator to the table.

Syntax

Visual Basic .NET

Sub AddHSeparator(Y As Int)

C++

HRESULT AddHSeparator(
int Y
);

Parameters

Y

[in] This parameter specifies the vertical coordinate of the newly added horizontal separator in pixel coordinates relative to image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TableBlock


DeleteColumn Method of the TableBlock Object

API Reference > Objects > Document Structure > Block Types > TableBlock >

DeleteColumn Method of the TableBlock Object

This method deletes the column from the table.

Syntax

Visual Basic .NET

Sub DeleteColumn(X As Int)

C++

HRESULT DeleteColumn(
int X
);

Parameters

X

[in] This parameter specifies the coordinate of the column to be deleted. You can pass to this parameter any coordinate greater than the coordinate of the left border of the column and less than the coordinate of the right border of the column. You cannot delete the first and the last column.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TableBlock

TableColumn


DeleteHSeparator Method of the TableBlock Object

API Reference > Objects > Document Structure > Block Types > TableBlock >

DeleteHSeparator Method of the TableBlock Object

This method deletes the horizontal separator from the table.

Syntax

Visual Basic .NET

Sub DeleteHSeparator(Y As Int)

C++

HRESULT DeleteHSeparator(
int Y
);

Parameters

Y

[in] This parameter specifies the index of the horizontal separator in the collection of horizontal separators. It should be in a range from 0 to the value of the Count property of the collection of horizontal separators minus 1.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TableBlock


FindCellBlock Method of the TableBlock Object

API Reference > Objects > Document Structure > Block Types > TableBlock >

FindCellBlock Method of the TableBlock Object

This method provides access to the table cell block that contains the point with the specified pixel coordinates relative to image.

Syntax

Visual Basic .NET

Function FindCellBlock( _
X As Int, _
Y As Int _
) As Block

C++

HRESULT FindCellBlock(
int X,
int Y,
IBlock** Result
);

Parameters

X

[in] This variable contains the horizontal coordinate of the point in pixel coordinates relative to image.

Y

[in] This variable contains the vertical coordinate of the point in pixel coordinates relative to image.

Result

[out, retval] A pointer to the IBlock* variable that receives the interface pointer for the cell block. Returns NULL, if the table cell block is not found.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TableBlock


TableColumns Object

TableColumns Object (ITableColumns Interface)

API Reference > Objects > Document Structure > Block Types >

TableColumns Object (ITableColumns Interface)

This object represents a collection of columns. To access the columns of the certain table, use the Columns property of the corresponding TableBlock object.

The TableColumns object is a so-called "connectable object". The methods of the TableColumns object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of columns in the collection.
Element | TableColumn, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single column of the collection.

Related objects

See also

TableColumn

TableBlock

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties


TableColumn Object

TableColumn Object (ITableColumn Interface)

API Reference > Objects > Document Structure > Block Types >

TableColumn Object (ITableColumn Interface)

This object provides access to specific properties of a table column. All the columns of the table are represented by the TableColumns object.

Properties

Name

Type

Description

FieldDefinition

FieldDefinition

Provides access to the field definition which corresponds to the column. The property may return 0 in which case no field definition corresponds to this column.

note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate FieldDefinition object, initialize its properties with the help of the IFieldDefinition::CopyFrom method, change the necessary parameters, and then assign this object to the property.

LeftBorder

Int, read-only

Stores the coordinate of the left border of the column.

RightBorder

Int, read-only

Stores the coordinate of the right border of the column.

Related objects

Output parameter

This object is the output parameter of the Item method of the TableColumns object.

See also

TableColumns

Working with Properties


Document Definition Structure Objects

API Reference > Objects >

Document Definition Structure Objects

A Document Definition defines the principles of identification and processing of a certain type of documents. Each Document Definition specifies the document structure, i.e. description of the allowable order of pages forming the document of this type, definitions of document sections, location of fields and their signatures. Document Definitions also include export and processing settings. The Document Definition itself is represented by the DocumentDefinition object. It provides access to the set of objects, which reproduce the structure of a Document Definition, and the processing parameters.

This section describes the following objects, which provide access to the structure of a Document Definition and processing settings for individual fields:

·DocumentDefinitions (deprecated)

·DocumentDefinition

·SectionDefinitions

·SectionDefinition

·SectionDefinitionsCollection (deprecated)

·PageDefinitions

·PageDefinition

·FieldDefinitions

·FieldDefinition

·BlockDefinitions

·BlockDefinition

·FlexibleDescription

·and processing parameters objects:

oPageAnalysisParams

oRecognitionParams

oAnchorRecognitionParams

oBarcodeRecognitionParams

oBarcodeParams

oCheckmarkGroupRecognitionParams

oCheckmarkRecognitionParams

oPictureRecognitionParams

oSeparatorRecognitionParams

oStaticTextRecognitionParams

oTextRecognitionParams

oImageProcessingParams

You can find additional information in the Creating Document Definitions section.

The hierarchy of the objects


DocumentDefinitions Object

DocumentDefinitions Object (IDocumentDefinitions Interface)

API Reference > Objects > Document Definition Structure >

DocumentDefinitions Object (IDocumentDefinitions Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object is a collection of Document Definitions. Besides standard collection methods and properties, it contains methods which allow you to manage Document Definitions.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | DocumentDefinition, read-only | Provides access to a single element of the collection.

Methods

Name | Description
FindByName | Provides access to an element of the collection by its name. warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Item | Provides access to a single element of the collection.

Related objects

See also

Project

DocumentDefinition

Working with Collections

Working with Properties


FindByName Method of the DocumentDefinitions Object

API Reference > Objects > Document Definition Structure > DocumentDefinitions >

FindByName Method of the DocumentDefinitions Object

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method allows you to find a Document Definition by its name.

Syntax

Visual Basic .NET

Function FindByName(Name As String) As DocumentDefinition

C++

HRESULT FindByName(
BSTR Name,
IDocumentDefinition** Result
);

Parameters

Name

[in] This variable contains the name of the Document Definition to be found.

Result

[out, retval] A pointer to the IDocumentDefinition* variable that receives the interface pointer for the Document Definition. Returns NULL, if the Document Definition with the specified name is not found.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

DocumentDefinitions

DocumentDefinition


DocumentDefinition Object

DocumentDefinition Object (IDocumentDefinition Interface)

API Reference > Objects > Document Definition Structure >

DocumentDefinition Object (IDocumentDefinition Interface)

This object corresponds to a Document Definition. A Document Definition describes the location of document elements and indicates the fields to be used in data extraction.

A Document Definition can be received in two ways:

·It may be a part of ABBYY FlexiCapture 12 project, and in this case it is ABBYY FlexiCapture 12 Document Definition. When creating this document definition in ABBYY FlexiCapture, field properties are specified along with their range of values, data export settings are also configured.

·It may be created in ABBYY FlexiCapture Engine using CreateDocumentDefinition, CreateDocumentDefinitionFromAFL, CreateDocumentDefinitionFromImageFile, CreateDocumentDefinitionFromXFD methods of the Engine object.

note Note: Only the Document Definitions that do not belong to any project can be modified. Please note that working with projects in ABBYY FlexiCapture Engine is deprecated and will be removed in future versions. It is strongly recommended that you use FlexiCapture processor and its functionality in your scenarios.

The Document Definition can comprise any number of sections (the Sections property), which can contain one or several pages. Pages are added to a single section if the document has blocks continuing or recurring on several pages or tables continuing on the following page. All the pages of the document definition are accessible through the Pages property.

The DocumentDefinition object supports a set of supplementary interfaces:

·IFieldDefinition – the whole document definition can be considered as the top-level field definition which contains all the field definitions of the Document Definition. Support of this interface means that you can treat the DocumentDefinition object as the FieldDefinition object.

·ICustomStorage – This means that the DocumentDefinition object allows saving its state in a custom storage.

Properties

Name

Type

Description

CustomLanguages

CustomLanguages, read-only

Returns a collection of custom user-defined languages specified in the document definition.

DefaultLanguage

Language

Specifies the language to be used during recognition. The language can be changed for individual fields (see ITextRecognitionParams::Language), while the language specified by this property is used by default. See Setting Up Recognition Languages for details.

note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate Language object, change the necessary parameters, and then assign this object to the property.

DefaultTextType

TextTypeEnum

Specifies the text type. The text type can be changed for individual text blocks (see ITextRecognitionParams::TextType), while the text type specified by this property is used by default.

DefaultWritingStyle

LanguageIdEnum

Specifies the writing style of handprinted characters. The writing style can be changed for individual fields (see ITextRecognitionParams::WritingStyle), while the style specified by this property is used by default.

cicon2 Examples of various numeral writing styles

– Russian two

– American two

– "ordinary" five, can occur in any style

– Japanese five

– Russian one

– German one

– "ordinary" nine, can occur in any style

– Czech nine with the ring on the right

– American nine without the "hook" at the bottom

Description

String

Returns the text description of the Document Definition.

Errors

StringsCollection, read-only

Returns a collection of error descriptions for the latest call of the Check method. Contains only general errors. To receive the errors for a certain section of the Document Definition, use the ISectionDefinition::Errors property.

ExportParams

ExportParams

Specifies the parameters of export. With the help of this property you can set export parameters for documents to which this document definition is applied.

note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate ExportParams object with the help of the IEngine::CreateExportParams method, change the necessary parameters, and then assign this object to the property.

GUID

String, read-only

Returns the global unique identifier (GUID) of the document definition.

ID

Int, read-only

Returns the identifier of the Document Definition. The identifier is unique within the project.

IsEnabled

Boolean

Specifies if the Document Definition is to be used for document processing. This property set to FALSE excludes the document definition from document processing.

IsValid

Boolean, read-only

Specifies if the Document Definition is valid. The Document Definition is valid if there are no errors in it and it has not been changed since the last call of the Check method.

LicenseInfo

String, read-only

Specifies the information about the author of the Document Definition (e.g. copyright).

Name

String

Stores the name of the Document Definition.

PageAnalysisParams

PageAnalysisParams

Specifies the parameters of page analysis. Page analysis (orientation detection, image scaling, etc.) is performed when the Document Definition is applied in order to apply the Document Definition correctly.

note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate PageAnalysisParams object with the help of the IEngine::CreatePageAnalysisParams method, change the necessary parameters, and then assign this object to the property.

Pages

PageDefinitions, read-only

Returns the collection of pages of the Document Definition.

Sections

SectionDefinitions, read-only

Returns the sections of the document definition.

The section of a Document Definition is a set of pages (or a single page) and fields on these pages, which corresponds to a logically complete part of a document.

Warnings

StringsCollection, read-only

Returns a collection of warning descriptions for the latest call of the Check method. Contains only general warnings. To receive the warnings for certain section of the Document Definition, use the ISectionDefinition::Warnings property.

Methods

Name | Description
Check | Checks if Document Definition properties were configured correctly.

Related objects

Output parameter

This object is the output parameter of the following methods:

·CreateDocumentDefinition, CreateDocumentDefinitionFromAFL, CreateDocumentDefinitionFromImageFile, CreateDocumentDefinitionFromXFD methods of the Engine object.

·Item, FindByName methods of the DocumentDefinitions object. (deprecated)

Input parameter

This object is the input parameter of the AddDocumentDefinition method of the FlexiCaptureProcessor object.

See also

Creating Document Definitions

Setting Up Recognition Languages

Tuning Export Parameters

Working with Properties

See sample: Hello, FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, FlexiCapture Web Service, Multi-Core Processing, Mobile Data Capture, Classification, Color Stamps Removal, Redaction


Check Method of the DocumentDefinition Object

API Reference > Objects > Document Definition Structure > DocumentDefinition >

Check Method of the DocumentDefinition Object

The method checks the Document Definition and updates the value of the IDocumentDefinition::IsValid property.

Syntax

Visual Basic .NET

Function Check() As Boolean

C++

HRESULT Check(
VARIANT_BOOL* Result
);

Parameters

Result

[out, retval] A pointer to a Boolean variable that receives the result of checking.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

DocumentDefinition


SectionDefinitions Object

SectionDefinitions Object (ISectionDefinitions Interface)

API Reference > Objects > Document Definition Structure >

SectionDefinitions Object (ISectionDefinitions Interface)

This object is a collection of sections of a Document Definition. To access the sections of the certain Document Definition, use the Sections property of the corresponding DocumentDefinition object.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | SectionDefinition | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Creates a new SectionDefinition object and adds it at the end of the collection.
Item | Provides access to a single element of the collection.

Related objects

See also

DocumentDefinition

SectionDefinition

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets


AddNew Method of the SectionDefinitions Object

API Reference > Objects > Document Definition Structure > SectionDefinitions >

AddNew Method of the SectionDefinitions Object

This method creates a new SectionDefinition object and adds it at the end of the collection.

Syntax

Visual Basic .NET

Function AddNew(name As String) As SectionDefinition

C++

HRESULT AddNew(
BSTR name,
ISectionDefinition** result
);

Parameters

name

[in] This parameter specifies the name of the new section definition.

result

[out, retval] A pointer to the ISectionDefinition* pointer variable that receives the interface pointer of the added SectionDefinition object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

SectionDefinitions

SectionDefinition

See sample: FlexiCapture Engine Code Snippets


SectionDefinition Object

SectionDefinition Object (ISectionDefinition Interface)

API Reference > Objects > Document Definition Structure >

SectionDefinition Object (ISectionDefinition Interface)

This object corresponds to a section of a Document Definition. A section of a Document Definition is a set of pages (or a single page) and fields on these pages, which corresponds to a logically complete part of a document. Pages are added to a single section if the document has blocks continuing or recurring on several pages or tables continuing on the following page. All fields in a flexible description belong to one section of a Document Definition.

All sections of a Document Definition are represented by a SectionDefinitions object.

Properties

Name | Type | Description
Comment | String | Stores the text description of the section.
DocumentDefinition | DocumentDefinition, read-only | Provides access to the Document Definition containing the section.
Errors | StringsCollection, read-only | Returns a collection of error descriptions for the latest call of the Check method.
Fields | FieldDefinitions, read-only | Returns a collection of fields of the section.
FlexibleDescription | FlexibleDescription, read-only | Provides access to the flexible description of the section. If there is no flexible description in the section, the property returns 0.
ID | Int, read-only | Returns the identifier of the section.
IsEnabled | Boolean | Specifies if the section is to be used for Document Definition matching. This property set to FALSE excludes the section from document processing.
IsFlexible | Boolean, read-only | Specifies if the section is defined in a flexible description. If the value of this property is TRUE, the name of the field cannot be changed.
IsRepeatable | Boolean, read-only | Indicates if the section can repeat in the document, i.e. several corresponding field instances can appear in the document after the section definition applying.
IsValid | Boolean, read-only | Specifies if the section is valid. The section is valid if there is no errors in it and it has not been changed since the latest call of the Check method.
Name | String | Stores the name of the section.
Pages | PageDefinitions, read-only | Returns a collection of pages of the section.
Warnings | StringsCollection, read-only | Returns a collection of warnings descriptions for the latest call of the Check method.

Methods

Name | Description
Check | Checks if section properties were configured correctly.
LoadFlexibleDescription | Loads a flexible description from the specified ABBYY FlexiLayout Studio file.
LoadFlexibleDescriptionFromStream | Loads a flexible description from stream.
LoadXFDDescription | Loads a form from the specified XML Form Definition file.

Related objects

Output parameter

This object is the output parameter of the following methods:

·Item and AddNew methods of the SectionDefinitions object.

·Item method of the SectionDefinitionsCollection object. (deprecated)

Input parameter

This object is the input parameter of the following methods:

·ForceApplyDocumentDefinition method of the Batch object. (deprecated)

·Add method of the SectionDefinitionsCollection object. (deprecated)

See also

SectionDefinitions

Creating Document Definitions

Working with Properties

See sample: FlexiCapture Engine Code Snippets


Check Method of the SectionDefinition Object

API Reference > Objects > Document Definition Structure > SectionDefinition >

Check Method of the SectionDefinition Object

The method checks the section definition and updates the value of the ISectionDefinition::IsValid property.

Syntax

Visual Basic .NET

Function Check() As Boolean

C++

HRESULT Check(
VARIANT_BOOL* Result
);

Parameters

Result

[out, retval] A pointer to a Boolean variable that receives the result of checking.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

SectionDefinition


LoadFlexibleDescription Method of the SectionDefinition Object

API Reference > Objects > Document Definition Structure > SectionDefinition >

LoadFlexibleDescription Method of the SectionDefinition Object

This method allows you to load a flexible description from the file in ABBYY FlexiLayout Studio format (*.afl). ABBYY Flexible Layout files are created with ABBYY FlexiLayout Studio.

Syntax

Visual Basic .NET

Function LoadFlexibleDescription(Path As String) As FlexibleDescription

C++

HRESULT LoadFlexibleDescription(
BSTR Path,
IFlexibleDescription** Result
);

Parameters

Path

[in] This variable contains the path to the file containing flexible description (*.afl).

Result

[out, retval] A pointer to the IFlexibleDescription* variable that receives the interface pointer for the flexible description.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

SectionDefinition

FlexibleDescription


LoadFlexibleDescriptionFromStream Method of the SectionDefinition Object

API Reference > Objects > Document Definition Structure > SectionDefinition >

LoadFlexibleDescriptionFromStream Method of the SectionDefinition Object

This method allows you to load a flexible description from stream.

Syntax

Visual Basic .NET

Function LoadFlexibleDescriptionFromStream(Stream As IReadStream) As FlexibleDescription

C++

HRESULT LoadFlexibleDescriptionFromStream(
IReadStream* Stream,
IFlexibleDescription** Result
);

Parameters

Stream

[in] This parameter refers to the IReadStream variable that provides access to a read stream.

Result

[out, retval] A pointer to the IFlexibleDescription* variable that receives the interface pointer of the loaded flexible description.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

SectionDefinition

FlexibleDescription


LoadXFDDescription Method of the SectionDefinition Object

API Reference > Objects > Document Definition Structure > SectionDefinition >

LoadXFDDescription Method of the SectionDefinition Object

This method allows you to load a form from the XML Form Definition file (*.xfd). XML Form Definition — a special file format of a form designed with ABBYY FormDesigner.

Syntax

Visual Basic .NET

Sub LoadXFDDescription(Path As String)

C++

HRESULT LoadXFDDescription(
BSTR Path
);

Parameters

Path

[in] This variable contains the path to the file containing form (*.xfd).

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

SectionDefinition


SectionDefinitionsCollection Object

SectionDefinitionsCollection Object (ISectionDefinitionsCollection Interface)

API Reference > Objects > Document Definition Structure >

SectionDefinitionsCollection Object (ISectionDefinitionsCollection Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object is a collection of section definitions. This collection is a collection of references to SectionDefinition objects. It is used to pass various sets of parameters into methods that require them. See Working with Collections.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | SectionDefinition, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Add | Adds a new element at the end of the collection.
Item | Provides access to a single element of the collection.

Related objects

Output parameter

This object is the output parameter of the CreateSectionDefinitionsCollection method of the Engine object.

Input parameter

This object is the input parameter of the ApplyDocumentDefinitions, Recognize methods of the Batch object.

See also

SectionDefinition

Working with Collections

Working with Properties


PageDefinition Object

PageDefinition Object (IPageDefinition Interface)

API Reference > Objects > Document Definition Structure >

PageDefinition Object (IPageDefinition Interface)

This object corresponds to a page of a Document Definition. A Document Definition can comprise one or several pages. Each page of the Document Definition contains the image of the template page and blocks specified on the image. Document Definitions for multipage documents can have key blocks in each page (the KeyBlock property). The values of such blocks enable automatic checking of page assembly into documents. All the pages of a Document Definition or a section definition are represented by the PageDefinitions object.

The whole page definition can be considered as the top-level block definition which contains all the block definitions of the page definition. The PageDefinition object supports the IBlockDefinition interface. You may treat this object as the BlockDefinition object.

Properties

Name | Type | Description
Blocks | BlockDefinitions, read-only | Provides access to the collection of blocks on the page.
ID | Int, read-only | Returns the identifier of the page definition.
Image | ImageDocument, read-only | Stores the template image.
KeyBlock | BlockDefinition | Specifies the key block on the page. A key block enables automatic checking of page assembly into documents. The values of key blocks must be identical on all pages of the same document. An example of a key field is the last name of the person who completed the document, which must be written on each page, or a certain identification number.
Section | SectionDefinition, read-only | Returns the Document Definition section containing the page.

Methods

Name | Description
DetectBlocks | Detects blocks of the specified type within the specified region and adds them to the page definition.
SetImage | Sets the template image of the page.

Related objects

Output parameter

This object is the output parameter of the Item, AddNew methods of the PageDefinitions object.

See also

PageDefinitions

Working with Properties


DetectBlocks Method of the PageDefinition Object

API Reference > Objects > Document Definition Structure > PageDefinition >

DetectBlocks Method of the PageDefinition Object

This method detects blocks of the specified type within the specified region and adds them to the page definition. Please note that it does not guarantee that all the blocks will be detected correctly.

Syntax

Visual Basic .NET

Sub DetectBlocks( _
Region As Region, _
AutodetectBlockTypes As IntsCollection _
)

C++

HRESULT DetectBlocks(
IRegion* Region,
IIntsCollection* AutodetectBlockTypes
);

Parameters

Region

[in] Refers to the Region object, which specifies the new region of the block.

AutodetectBlockTypes

[in] This variable refers to a collection of block types that must be detected, represented by the constants of BlockTypeEnum cast to Int.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

PageDefinition


SetImage Method of the PageDefinition Object

API Reference > Objects > Document Definition Structure > PageDefinition >

SetImage Method of the PageDefinition Object

This method sets the IPageDefinition::Image property of the current page definition.

Syntax

Visual Basic .NET

Sub SetImage(ImagePath As String)

C++

HRESULT SetImage(
BSTR ImagePath
);

Parameters

ImagePath

[in] This variable specifies the path to the file with the image which is to be used as the template image for the page definition.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

PageDefinition


PageDefinitions Object

PageDefinitions Object (IPageDefinitions Interface)

API Reference > Objects > Document Definition Structure >

PageDefinitions Object (IPageDefinitions Interface)

This object is a collection of pages of a Document Definition or a section definition. To access the pages of the certain document definition, use the Pages property of the corresponding DocumentDefinition object. The pages of the certain section definition can be viewed via the Pages property of the SectionDefinition object.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | PageDefinition, read-only | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Adds a new element at the end of the collection.
DeleteAll | Removes all the elements from the collection.
DeleteByID | Removes an element with the specified identifier from the collection.
Item | Provides access to a single element of the collection.

Related objects

See also

PageDefinition

Working with Collections

Working with Properties


AddNew Method of the PageDefinitions Object

API Reference > Objects > Document Definition Structure > PageDefinitions >

AddNew Method of the PageDefinitions Object

This method adds a page definition at the end of the collection.

Syntax

Visual Basic .NET

Function AddNew(ImagePath As String) As PageDefinition

C++

HRESULT AddNew(
BSTR ImagePath,
IPageDefinition** Result
);

Parameters

ImagePath

[in] This variable contains the path to the image file which contains the template image of the page definition.

Result

[out, retval] A pointer to the IPageDefinition* variable that receives the interface pointer for the added page definition.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

PageDefinitions


FieldDefinitions Object

FieldDefinitions Object (IFieldDefinitions Interface)

API Reference > Objects > Document Definition Structure >

FieldDefinitions Object (IFieldDefinitions Interface)

This object represents a collection of field definition. It may be a collection of fields of a section definition or a collection of fields of a composite field definition.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | FieldDefinition, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

See also

FieldDefinition

Working with Collections

Working with Properties


FieldDefinition Object

FieldDefinition Object (IFieldDefinition Interface)

API Reference > Objects > Document Definition Structure >

FieldDefinition Object (IFieldDefinition Interface)

This object corresponds to a field of a Document Definition. A field of a Document Definition is an element intended for data extraction. Fields may be simple (without an internal structure) or composite, such as the table field where each cell can be viewed as a separate subordinate field of the table.

Properties

Name | Type | Description
Caption | String, read-only | Returns the name of the field. This name is used as the caption of the field in the ABBYY FlexiCapture document window. This property may be useful for customizing column names, particularly in the case of flexible descriptions where you cannot change the names of the fields.
Children | FieldDefinitions, read-only | Returns a collection of child fields of the composite field.
DocumentDefinition | DocumentDefinition, read-only | Provides access to the Document Definition containing the field.
ID | Int, read-only | Returns the identifier of the Document Definition field.
IsCalculable | Boolean, read-only | Specifies if the field value is to be calculated automatically using a rule.
IsDisabled | Boolean, read-only | Specifies if the field is disabled. If the value of this property is TRUE, the field will not be used during Document Definition applying.
IsManuallyEntered | Boolean, read-only | Specifies if the field should be found in the document, but should not be recognized. If the value of this property is TRUE, an operator is to enter its value manually.
IsReadOnly | Boolean, read-only | Specifies if the field is accessible only for viewing.
IsRepeatable | Boolean, read-only | Indicates if the field can repeat in its parent, i.e. several corresponding field instances can appear in the document after the field definition applying.
IsRequired | Boolean, read-only | Specifies if the field is required. If the field is not found in the document during Document Definition applying, an error is produced.
IsVisible | Boolean, read-only | Specifies if the field is visible. If the value of this property is TRUE, the field is displayed in the ABBYY FlexiCapture document window.
MarkFieldValueForVerification | FieldValueVerificationEnum, read-only | Specifies in which case to submit field value for verification.
Name | String, read-only | Returns the name of the field.
Parent | FieldDefinition, read-only | Returns the parent field.
RecognitionParams | RecognitionParams, read-only | Stores the recognition parameters of the field.
Type | FieldTypeEnum, read-only | Returns the type of the field.
ValueType | FieldValueTypeEnum | Specifies the type of the field value. Note: The field type can be changed but the changes can be made only among the following property values: FVT_Text FVT_DateTime FVT_Number FVT_Currency. Other types of the field can not be changed.

Related objects

Output parameter

This object is the output parameter of the Item method of the FieldDefinitions object.

See also

FieldDefinitions

Working with Properties

See sample: FlexiCapture Engine Code Snippets


BlockDefinitions Object

BlockDefinitions Object (IBlockDefinitions Interface)

API Reference > Objects > Document Definition Structure >

BlockDefinitions Object (IBlockDefinitions Interface)

This object represents a collection of blocks of a Document Definition page. To access the blocks of the certain Document Definition page, use the Blocks property of the corresponding PageDefinition object.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | BlockDefinition, read-only | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Adds a new element at the end of the collection.
DeleteAll | Removes all the elements from the collection.
DeleteByID | Removes an element with the specified identifier from the collection.
Item | Provides access to a single element of the collection.

Related objects

See also

BlockDefinition

PageDefinition

Working with Collections

Working with Properties


AddNew Method of the BlockDefinitions Object

API Reference > Objects > Document Definition Structure > BlockDefinitions >

AddNew Method of the BlockDefinitions Object

This method adds a block definition at the end of the collection.

Syntax

Visual Basic .NET

Function AddNew( _
Type As BlockTypeEnum, _
Region As Region, _
Name As String _
) As BlockDefinition

C++

HRESULT AddNew(
BlockTypeEnum Type,
IRegion* Region,
BSTR Name,
IBlockDefinition** Result
);

Parameters

Type

[in] This variable of the BlockTypeEnum type specifies the type of the block.

Note: the Type parameter can not be BT_Unknown or BT_Page.

Region

[in] This variable refers to the Region object that contains the region of the block. Region must not be NULL.

Name

[in] This variable specifies the name of the block.

Result

[out, retval] A pointer to the IBlockDefinition* variable that receives the interface pointer for the added Document Definition block.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

BlockDefinitions


BlockDefinition Object

BlockDefinition Object (IBlockDefinition Interface)

API Reference > Objects > Document Definition Structure >

BlockDefinition Object (IBlockDefinition Interface)

This object corresponds to a block of a Document Definition. A block defines type of data (the Type property) and region on an image to find these data in (the Region property). After Document Definition matching a block in the document (the Block object) will be found for each Document Definition block. The BlockDefinition object does not provide access to recognized data, it contains only data description. For recognized data see the properties of the Block object. All the blocks of the Document Definition page are represented by the BlockDefinitions object.

Properties

Name | Type | Description
Children | BlockDefinitions, read-only | Provides access to the collection of child blocks which this block contains.
Field | FieldDefinition, read-only | Provides access to the Document Definition field containing the block.
ID | Int, read-only | Returns the identifier of the Document Definition block.
Name | String, read-only | Returns the name of the block.
Page | PageDefinition, read-only | Provides access to the page of the Document Definition containing the block.
RecognitionParams | RecognitionParams | Stores the recognition parameters for the block.
Region | Region | Specifies the block region.
Type | BlockTypeEnum, read-only | Returns the type of the block.

Methods

Name | Description
Move | Moves the associated region.

Related objects

Output parameter

This object is the output parameter of the Item, AddNew methods of the BlockDefinitions object.

See also

BlockDefinitions

Working with Properties


Move Method of the BlockDefinition Object

API Reference > Objects > Document Definition Structure > BlockDefinition >

Move Method of the BlockDefinition Object

Use this method to move the region of the block.

Syntax

Visual Basic .NET

Sub Move( _
DeltaX As Int, _
DeltaY As Int _
)

C++

HRESULT Move(
int DeltaX,
int DeltaY
);

Parameters

DeltaX

[in] Horizontal offset by which to move the region of the block.

DeltaY

[in] Vertical offset by which to move the region of the block.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

BlockDefinition


FlexibleDescription Object

FlexibleDescription Object (IFlexibleDescription Interface)

API Reference > Objects > Document Definition Structure >

FlexibleDescription Object (IFlexibleDescription Interface)

This object corresponds to a flexible description. Flexible description is a formalized description of the document structure, designed to help detect fields. It is created with ABBYY FlexiLayout Studio and saved in a *.afl file. Flexible descriptions are usually created for bills, payment orders, and similar documents, when it is impossible to create a Document Definition with fixed field locations. This is because their location, size and number may not be identical, therefore a fixed Document Definition cannot be applied to all documents. In such documents, the program searches fields after pre-recognition of the entire page and creates a flexible description based on keywords and relative locations of fields.

Properties

Name | Type | Description
Comment | String, read-only | Stores the flexible description comment.
Name | String, read-only | Stores the name of the flexible description.

Related objects

Output parameter

This object is the output parameter of the LoadFlexibleDescription and LoadFlexibleDescriptionFromStream methods of the SectionDefinition object.

See also

SectionDefinition

Working with Properties


PageAnalysisParams Object

PageAnalysisParams Object (IPageAnalysisParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

PageAnalysisParams Object (IPageAnalysisParams Interface)

This object provides access to parameters used for tuning the page layout analysis process. You can configure document analysis using the PageAnalysisParams property of the DocumentDefinition object.

Properties

Name | Type | Description
CachePrerecognitionResults | Boolean | This property set to TRUE tells ABBYY FlexiCapture Engine to cache prerecognition results to speed up some operations. The default value of this property is FALSE.
DetectClockwiseOrientation | Boolean | If this property is set to TRUE, the page orientation is detected during layout analysis, and if the image is rotated clockwise from its normal orientation, ABBYY FlexiCapture Engine automatically rotates the image. The default value of this property is FALSE.
DetectCounterclockwiseOrientation | Boolean | If this property is set to TRUE, the page orientation is detected during layout analysis, and if the image is rotated counterclockwise from its normal orientation, ABBYY FlexiCapture Engine automatically rotates the image. The default value of this property is FALSE.
DetectUpsidedownOrientation | Boolean | If this property is set to TRUE, the page orientation is detected during layout analysis, and if it is upside down, ABBYY FlexiCapture Engine automatically rotates the image. The default value of this property is FALSE.
MaxHorizontalShrinkPercent | Int | Specifies the maximum percentage of Document Definition shrinking by width. By default the value of this property is 10%.
MaxHorizontalStretchPercent | Int | Specifies the maximum percentage of Document Definition stretching by width. By default the value of this property is 10%.
MaxVerticalShrinkPercent | Int | Specifies the maximum percentage of Document Definition shrinking by height. By default the value of this property is 10%.
MaxVerticalStretchPercent | Int | Specifies the maximum percentage of Document Definition stretching by height. By default the value of this property is 10%.
PrescaleOnAnchors | Boolean | This property set to TRUE enables image scaling using anchors. The default value of this property is TRUE.
PrescaleOnText | Boolean | This property set to TRUE enables image scaling using text lines. The default value of this property is FALSE.
VerticalScanned | Boolean | This property set to TRUE tells ABBYY FlexiCapture Engine to use special algorithms to despeckle vertical scanned images. The default value of this property is TRUE.

Methods

Name | Description
CopyFrom | Initializes properties of the current object with values of similar properties of another object.

Related objects

Output parameter

This object is the output parameter of the CreatePageAnalysisParams method of the Engine object.

See also

DocumentDefinition

Working with Properties


RecognitionParams Object

RecognitionParams Object (IRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

RecognitionParams Object (IRecognitionParams Interface)

This object allows you to tune the recognition parameters for the block. Parameters of recognition are specified with each block of the document definition and depend on the block type. The RecognitionParams object exposes methods which cast it to a type-specific interface and thereby provide access to the recognition parameters of a block of specific type. The recognition parameters of the block are set in the RecognitionParams property of the BlockDefinition object.

Properties

Name | Type | Description
IsIdentifier | Boolean | Specifies if the block is used as an identifier. Identifier is a static element used for certain selection of a Document Definition from among several Document Definitions with identical locations of anchors. If an anchor barcode or static text is used as an identifier, you can specify the values of such identifiers with the help of the IBarcodeRecognitionParams::Value or IStaticTextRecognitionParams::Value properties, respectively. In this case when applying a Document Definition the program will compare recognized data in the image with the value of the identifier, and the Document Definition match will be possible only if these values match.
IsReference | Boolean | Specifies if the block is used for finding some other block (e.g. static text block which contains the word "Surname" can be used to find a text block which contains a surname).
Type | BlockTypeEnum, read-only | Returns the type of the block.

Methods

Name | Description
AsAnchorParams | Returns the object as the AnchorRecognitionParams object. If the block is not an anchor block, NULL is returned.
AsBarcodeParams | Returns the object as the BarcodeRecognitionParams object. If the block is not a barcode block, NULL is returned.
AsCheckmarkGroupParams | Returns the object as the CheckmarkGroupRecognitionParams object. If the block is not a checkmark group block, NULL is returned.
AsCheckmarkParams | Returns the object as the CheckmarkRecognitionParams object. If the block is not a checkmark block, NULL is returned.
AsPictureParams | Returns the object as the PictureRecognitionParams object. If the block is not a picture block, NULL is returned.
AsSeparatorParams | Returns the object as the SeparatorRecognitionParams object. If the block is not a separator block, NULL is returned.
AsStaticTextParams | Returns the object as the StaticTextRecognitionParams object. If the block is not a static text block, NULL is returned.
AsTextParams | Returns the object as the TextRecognitionParams object. If the block is not a text block, NULL is returned.

Related objects

Input parameter

This object is the input parameter of the RecognizeBlock method of the TrainingPage object.

See also

BlockDefinition

FieldDefinition

Working with Properties

See sample: FlexiCapture Engine Code Snippets


AsAnchorParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsAnchorParams Method of the RecognitionParams Object

This method returns the object as the AnchorRecognitionParams object. If the block is not an anchor block, NULL is returned.

Syntax

Visual Basic .NET

Function AsAnchorParams() As AnchorRecognitionParams

C++

HRESULT AsAnchorParams(
IAnchorRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the IAnchorRecognitionParams* pointer variable that receives the interface pointer to the returned AnchorRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

AnchorRecognitionParams


AsBarcodeParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsBarcodeParams Method of the RecognitionParams Object

This method returns the object as the BarcodeRecognitionParams object. If the block is not a barcode block, NULL is returned.

Syntax

Visual Basic .NET

Function AsBarcodeParams() As BarcodeRecognitionParams

C++

HRESULT AsBarcodeParams(
IBarcodeRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the IBarcodeRecognitionParams* pointer variable that receives the interface pointer to the returned BarcodeRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

BarcodeRecognitionParams


AsCheckmarkGroupParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsCheckmarkGroupParams Method of the RecognitionParams Object

This method returns the object as the CheckmarkGroupRecognitionParams object. If the block is not a checkmark group block, NULL is returned.

Syntax

Visual Basic .NET

Function AsCheckmarkGroupParams() As CheckmarkGroupRecognitionParams

C++

HRESULT AsCheckmarkGroupParams(
ICheckmarkGroupRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the ICheckmarkGroupRecognitionParams* pointer variable that receives the interface pointer to the returned CheckmarkGroupRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

CheckmarkGroupRecognitionParams


AsCheckmarkParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsCheckmarkParams Method of the RecognitionParams Object

This method returns the object as the CheckmarkRecognitionParams object. If the block is not a checkmark block, NULL is returned.

Syntax

Visual Basic .NET

Function AsCheckmarkParams() As CheckmarkRecognitionParams

C++

HRESULT AsCheckmarkParams(
ICheckmarkRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the ICheckmarkRecognitionParams* pointer variable that receives the interface pointer to the returned CheckmarkRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

CheckmarkRecognitionParams


AsPictureParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsPictureParams Method of the RecognitionParams Object

This method returns the object as the PictureRecognitionParams object. If the block is not a picture block, NULL is returned.

Syntax

Visual Basic .NET

Function AsPictureParams() As PictureRecognitionParams

C++

HRESULT AsPictureParams(
IPictureRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the IPictureRecognitionParams* pointer variable that receives the interface pointer to the returned PictureRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

PictureRecognitionParams


AsSeparatorParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsSeparatorParams Method of the RecognitionParams Object

This method returns the object as the SeparatorRecognitionParams object. If the block is not a separator block, NULL is returned.

Syntax

Visual Basic .NET

Function AsSeparatorParams() As SeparatorRecognitionParams

C++

HRESULT AsSeparatorParams(
ISeparatorRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the ISeparatorRecognitionParams* pointer variable that receives the interface pointer to the returned SeparatorRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

SeparatorRecognitionParams


AsStaticTextParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsStaticTextParams Method of the RecognitionParams Object

This method returns the object as the StaticTextRecognitionParams object. If the block is not a static text block, NULL is returned.

Syntax

Visual Basic .NET

Function AsStaticTextParams() As StaticTextRecognitionParams

C++

HRESULT AsStaticTextParams(
IStaticTextRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the IStaticTextRecognitionParams* pointer variable that receives the interface pointer to the returned StaticTextRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

StaticTextRecognitionParams


AsTextParams Method of the RecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > RecognitionParams >

AsTextParams Method of the RecognitionParams Object

This method returns the object as the TextRecognitionParams object. If the block is not a text block, NULL is returned.

Syntax

Visual Basic .NET

Function AsTextParams() As TextRecognitionParams

C++

HRESULT AsTextParams(
ITextRecognitionParams** result
);

Parameters

result

[out, retval] A pointer to the ITextRecognitionParams* pointer variable that receives the interface pointer to the returned TextRecognitionParams object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognitionParams

TextRecognitionParams

See sample: FlexiCapture Engine Code Snippets


AnchorRecognitionParams Object

AnchorRecognitionParams Object (IAnchorRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

AnchorRecognitionParams Object (IAnchorRecognitionParams Interface)

This object provides functionality for tuning parameters of anchor recognition. The anchors are special elements of form design, which are used to match Document Definitions. A black square, rectangle, cross or corner may be an anchor. Anchors are normally located in the corners of a form.

These parameters are used in Document Definitions and can be set through the AsAnchorParams method of the RecognitionParams object.

Properties

Name | Type | Description
Type | AnchorTypeEnum | Specifies the type of the anchor.

Related objects

Output parameter

This object is the output parameter of the AsAnchorParams method of the RecognitionParams object.

See also

RecognitionParams

Working with Properties


BarcodeRecognitionParams Object

BarcodeRecognitionParams Object (IBarcodeRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

BarcodeRecognitionParams Object (IBarcodeRecognitionParams Interface)

This object provides functionality for tuning parameters of barcode recognition.

A barcode can be highlighted in the Document Definition as a field or as a static element. This depends on the barcode meaning in the documents being processed: if it is intended for Document Definition matching or identification, it is created in the static elements mode (anchor barcode). Meanwhile, if a barcode is intended for data capture, it is created in the field marking mode. The recognition parameters for them are identical except for the Value property which is used only for anchor barcodes.

Recognition parameters of the barcode block in the Document Definition are accessed using the AsBarcodeParams method of the RecognitionParams object of the block.

Properties

Name | Type | Description
BarcodeParams | BarcodeParams | Specifies possible orientation and type of barcode. note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate BarcodeParams object with the help of the IEngine::CreateBarcodeParams method, change the necessary parameters, and then assign this object to the property.
ImageProcessingParams | ImageProcessingParams | Specifies parameters of image preprocessing inside the barcode block. note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate ImageProcessingParams object with the help of the IEngine::CreateImageProcessingParams method, change the necessary parameters, and then assign this object to the property.
IsRequired | Boolean | If the value of this property is TRUE, the Document Definition will be matched only if the barcode is matched. Set the property to TRUE if there are many very similar Document Definitions in the batch that can be distinguished only by the values of their barcodes. In this case, it will speed up Document Definition selection. Set this property to FALSE if you wish the Document Definition to be matched even if there is no barcode or if it is too faint.
Value | String | If an anchor barcode is used as an identifier (the IRecognitionParams::IsIdentifier property is set to TRUE), you can specify the value of such identifier. In this case when applying the document definition the program will compare recognized data in the image with the value of the identifier, and the Document Definition matching will be possible only if these values match.

Related objects

Output parameter

This object is the output parameter of the AsBarcodeParams method of the RecognitionParams object.

See also

RecognitionParams

Working with Properties


BarcodeParams Object

BarcodeParams Object (IBarcodeParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

BarcodeParams Object (IBarcodeParams Interface)

This object allows you to tune type and orientation of the barcode which can be found in the document. These parameters are used in Document Definitions and served for barcode recognition. To set the parameters, use the BarcodeParams property of the BarcodeRecognitionParams object. To view the parameters of recognized barcode, see the properties of the BarcodeBlock object.

Properties

Name | Type | Description
AllowedOrientations | Int | The value of this property is an OR superposition of the BarcodeOrientationEnum enumeration constants which denote the types of barcode orientation. For example, if it is set to BO_Left_To_Right | BO_Down_To_Top, ABBYY FlexiCapture Engine will presume that barcode blocks may be oriented either from left to right or from down to top, ignoring all other variants.
AllowedTypes | Int | The value of this property is an OR superposition of the BarcodeTypeEnum enumeration constants which denote the types of barcode. For example, if it is set to BT_EAN13 | BT_EAN8, ABBYY FlexiCapture Engine will try to recognize barcode blocks in either EAN 13 or EAN 8 standard, ignoring all other variants.

Methods

Name | Description
CopyFrom | Initializes properties of the current object with values of similar properties of another object.

Related objects

Output parameter

The object is the output parameter of the CreateBarcodeParams method of the Engine object.

See also

BarcodeRecognitionParams

RecognitionParams

Barcode Types

Working with Properties


CheckmarkGroupRecognitionParams Object

CheckmarkGroupRecognitionParams Object (ICheckmarkGroupRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

CheckmarkGroupRecognitionParams Object (ICheckmarkGroupRecognitionParams Interface)

This object provides functionality for tuning parameters of checkmark group recognition. These parameters are used in Document Definitions and can be set using the AsCheckmarkGroupParams method of the RecognitionParams object.

Properties

Name | Type | Description
CheckmarkType | CheckmarkTypeEnum | Specifies the type of checkmarks in the group.
ImageProcessingParams | ImageProcessingParams | Specifies parameters of image preprocessing inside the checkmark group block. note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate ImageProcessingParams object with the help of the IEngine::CreateImageProcessingParams method, change the necessary parameters, and then assign this object to the property.
IsCorrectionEnabled | Boolean | Specifies if correction of checkmarks in the group is enabled.
MaximumCheckedInGroup | Int | Specifies the maximal number of selected checkmarks.
MinimumCheckedInGroup | Int | Specifies the minimal number of selected checkmarks.

Related objects

Output parameter

This object is the output parameter of the AsCheckmarkGroupParams method of the RecognitionParams object.

See also

RecognitionParams

Working with Properties


CheckmarkRecognitionParams Object

CheckmarkRecognitionParams Object (ICheckmarkRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

CheckmarkRecognitionParams Object (ICheckmarkRecognitionParams Interface)

This object provides functionality for tuning parameters of checkmark recognition. These parameters are used in Document Definitions and can be set using the AsCheckmarkParams method of the RecognitionParams object.

Properties

Name | Type | Description
CheckmarkType | CheckmarkTypeEnum | Specifies the type of checkmark.
ImageProcessingParams | ImageProcessingParams | Specifies parameters of image preprocessing inside the checkmark block. The property returns a constant object. To modify the value of the property, you must first receive an intermediate ImageProcessingParams object with the help of the IEngine::CreateImageProcessingParams, change the necessary parameters, and then assign this object to the property.
IsCorrectionEnabled | Boolean | Specifies if correction of the checkmark is enabled.

Related objects

Output parameter

This object is the output parameter of the AsCheckmarkParams method of the RecognitionParams object.

See also

RecognitionParams

Working with Properties


PictureRecognitionParams Object

PictureRecognitionParams Object (IPictureRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

PictureRecognitionParams Object (IPictureRecognitionParams Interface)

This object provides functionality for tuning parameters of pictures recognition. These parameters are used in Document Definitions and can be set using the AsPictureParams method of the RecognitionParams object.

Properties

Name | Type | Description
DontRecognize | Boolean | Specifies if pictures should be excluded from recognition. If the value of this property is TRUE, text on the pictures is not recognized.

Related objects

Output parameter

This object is the output parameter of the AsPictureParams method of the RecognitionParams object.

See also

RecognitionParams

Working with Properties


SeparatorRecognitionParams Object

SeparatorRecognitionParams Object (ISeparatorRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

SeparatorRecognitionParams Object (ISeparatorRecognitionParams Interface)

This object provides functionality for tuning parameters of separators recognition. The separator is either a horizontal or a vertical line on the image. These parameters are used in Document Definitions and can be set through the AsSeparatorParams method of the RecognitionParams object.

Properties

Name | Type | Description
Direction | BlackSeparatorDirectionEnum, read-only | Specifies the separator direction: vertical or horizontal.
Type | BlackSeparatorTypeEnum | Specifies the separator type: solid, dotted, or white.

Related objects

Output parameter

This object is the output parameter of the AsSeparatorParams method of the RecognitionParams object.

See also

RecognitionParams

Working with Properties


StaticTextRecognitionParams Object

StaticTextRecognitionParams Object (IStaticTextRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

StaticTextRecognitionParams Object (IStaticTextRecognitionParams Interface)

This object provides functionality for tuning parameters of static text recognition. These parameters are used in Document Definitions and can be set through the AsStaticTextParams method of the RecognitionParams object.

Properties

Name | Type | Description
MaxErrors | Int | Specifies the maximum number of allowed errors in the static text string.
Value | String | If a static text is used as an identifier (the IRecognitionParams::IsIdentifier property is set to TRUE), you can specify the value of such identifier. In this case when applying the document definition the program will compare recognized data in the image with the value of the identifier, and the Document Definition matching will be possible only if these values match.

Related objects

Output parameter

This object is the output parameter of the AsStaticTextParams method of the RecognitionParams object.

See also

RecognitionParams

Working with Properties


TextRecognitionParams Object

TextRecognitionParams Object (ITextRecognitionParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

TextRecognitionParams Object (ITextRecognitionParams Interface)

This object allows you to tune the recognition parameters of the text. These parameters are used in Document Definitions and can be set through the AsTextParams method of the RecognitionParams object.

Properties

Name

Type

Description

AdjustPosition

Boolean

Specifies whether recognizer should look for the best position for the text block on document image.

CaseRecognitionMode

CaseRecognitionModeEnum

Specifies the mode of letter case recognition.

CellsCount

Int

Specifies the number of character cells for a recognized block. This property is valid only for the handprint recognition. It has sense only for the field marking types (the FieldMarkingType property) that imply splitting the text into cells. The value of this property must be a positive number. The property can also be set to -1, which means that the number of cells should not be changed.

ErrorHighlightLevel

ErrorHighlightLevelEnum

Specifies the confidence level at which a character in recognized text is marked as uncertainly recognized (the ICharParams::IsSuspicious property is set to TRUE for such character). The name of the property reflects the fact that the uncertain characters are highlighted with background color in the ABBYY FlexiCapture document window.

FieldMarkingType

FieldMarkingTypeEnum

Specifies the type of marking around letters (for example, underline, frame, box, etc.). This property is valid only for the handprint recognition.

note Note: For correct handprint recognition use CellsCount property that allows you to set the number of character cells for a recognized block.

ImageProcessingParams

ImageProcessingParams

Specifies the parameters of image preprocessing for the text block.

note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate ImageProcessingParams object with the help of the IEngine::CreateImageProcessingParams, change the necessary parameters, and then assign this object to the property.

Language

Language

Specifies the text language.

note Note: The property returns a constant object. To modify the value of the property, you must first receive an intermediate Language object using the methods of the TextRecognitionParams object, change the necessary parameters, and then assign this object to the property.

MarkingRegion

Region, read-only

Contains the text marking region.

OneLinePerBlock

Boolean

This property set to TRUE tells ABBYY FlexiCapture Engine to presume that the text in block to which the current TextRecognitionParams object belongs contains no more than one text line.

OneWordPerLine

Boolean

This property set to TRUE tells ABBYY FlexiCapture Engine to presume that no text line may contain more than one word, so the lines of text will be recognized as a single word.

TextType

Int

Specifies possible types of the text to be recognized as an OR superposition of TextTypeEnum constants.

UserPatternsFile

String

Contains the full path to a file of the user pattern used for recognition. If the value of this property is not empty, information from the user pattern file will be used during recognition.

WritingStyle

LanguageIdEnum

Specifies the writing style (defined by locale).

cicon2 Examples of various numeral writing styles

– Russian two

– American two

– "ordinary" five, can occur in any style

– Japanese five

– Russian one

– German one

– "ordinary" nine, can occur in any style

– Czech nine with the ring on the right

– American nine without the "hook" at the bottom

Methods

Name | Description
CreateEmbeddedLanguage | Creates a recognition language from an existing one. This language can then be assigned to the Language property.
CreateEmbeddedLanguageByDataType | Creates a special recognition language, which can be used for recognition of the specified field value type.

Related objects

Output parameter

This object is the output parameter of the AsTextParams method of the RecognitionParams object.

See also

RecognitionParams

Setting Up Recognition Languages

Working with Properties

See sample: FlexiCapture Engine Code Snippets


CreateEmbeddedLanguage Method of the TextRecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > TextRecognitionParams >

CreateEmbeddedLanguage Method of the TextRecognitionParams Object

This method creates a recognition language from an existing one. This language can then be assigned to the ITextRecognitionParams::Language property.

You can create a simple or group language depending on the specified type. For example, you can create a simple language on the base of the English language, change some its parameters, and then use it for recognition of a field.

Syntax

Visual Basic .NET

Function CreateEmbeddedLanguage( _
type As LanguageTypeEnum, _
prototype As Language _
) As Language

C++

HRESULT CreateEmbeddedLanguage(
LanguageTypeEnum type,
ILanguage* prototype,
ILanguage** result
);

Parameters

type

[in] This variable specifies the type of the created language: simple or group. See the descriptions of the LanguageTypeEnum constants.

prototype

[in] This variable refers to the Language object, which should be used as a prototype for the new language creation. This language must have the same type as specified in the type parameter. You may pass NULL as the value of this parameter, in which case the default Language object of the type specified will be created.

result

[out, retval] A pointer to the ILanguage* variable that receives the interface pointer for the created language.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TextRecognitionParams

Setting Up Recognition Languages


CreateEmbeddedLanguageByDataType Method of the TextRecognitionParams Object

API Reference > Objects > Document Definition Structure > Processing Parameters > TextRecognitionParams >

CreateEmbeddedLanguageByDataType Method of the TextRecognitionParams Object

This method creates a special recognition language, which can be used for recognition of the specified field value type.

It is not always convenient to specify the type of field value (IFieldDefinition::ValueType) as this restricts field values. E.g. if a user enters incorrect data to such field, this will produce an error. To avoid specifying some special type of field value, you may:

1.Create a special language using this method. Set its parameters for recognition of a specific text.

2.Assign the created language to ITextRecognitionParams::Language property of the recognition parameters of the corresponding field.

Syntax

Visual Basic .NET

Function CreateEmbeddedLanguageByDataType(type As FieldValueTypeEnum) As Language

C++

HRESULT CreateEmbeddedLanguageByDataType(
FieldValueTypeEnum type,
ILanguage** result
);

Parameters

type

[in] This variable specifies the type of the field value. See the descriptions of the FieldValueTypeEnum constants. Only the FVT_DateTime, FVT_Number, FVT_Currency constants can be used as the value of this parameter.

result

[out, retval] A pointer to the ILanguage* variable that receives the interface pointer for the created language.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Setting Up Recognition Languages

TextRecognitionParams


ImageProcessingParams Object

ImageProcessingParams Object (IImageProcessingParams Interface)

API Reference > Objects > Document Definition Structure > Processing Parameters >

ImageProcessingParams Object (IImageProcessingParams Interface)

This object specifies how a block image is to be preprocessed before recognition. Most recognition parameters objects have child objects of the ImageProcessingParams type that are available through the corresponding properties. Image processing parameters should be set for each block that is to be recognized, if any non-trivial image preprocessing upon that block is needed. The ImageProcessingParams object may specify image rotation and its mirroring around the vertical axis. Rotation is the first operation in sequence of geometrical transformation, and mirroring is the second one.

Properties

Name | Type | Description
ProhibitCorrectLocalSkew | Boolean | This property allows you to prohibit local skew correction. Correction of local skew is performed if the skew for the whole page is calculated uncertainly. It is the last operation in a sequence defined by the ImageProcessingParams object attributes.
GarbageSize | Int | Specifies the size in pixels of black dots which must be considered garbage.
Invert | Boolean | Specifies if the image colors are to be inverted during preprocessing.
MirrorHorizontal | Boolean | Specifies if the image is mirrored around the vertical axis during preprocessing.
RemoveTexture | Boolean | Specifies if the background noise is cleared before recognition process start.
RotationType | RotationTypeEnum | Specifies what type of rotation will be performed upon the image during its preprocessing.

Methods

Name | Description
CopyFrom | Initializes properties of the current object with values of similar properties of another object.

Related objects

Output parameter

The object is the output parameter of the CreateImageProcessingParams method of the Engine object.

See also

TextRecognitionParams

BarcodeRecognitionParams

CheckmarkRecognitionParams

CheckmarkGroupRecognitionParams

Working with Properties


Document Definition Training Objects

API Reference > Objects >

Document Definition Training Objects

ABBYY FlexiCapture Engine provides a set of objects, which allows you to create your own Document Definition by training. The main object in this set is the TrainingBatch object. See Creating Document Definitions by Training for details.

This section describes the following objects:

·TrainingBatch

·TrainingDefinitions

·TrainingDefinition

·TrainingFields

·TrainingField

·TrainingPages

·TrainingPage

·TrainingBlocks

·TrainingBlock

·TrainingImageObjects

·TrainingImageObject

·TrainingClassifier (deprecated)

The hierarchy of the objects


TrainingBatch Object

TrainingBatch Object (ITrainingBatch Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingBatch Object (ITrainingBatch Interface)

This object corresponds to a training batch. The training batch is a set of image pages used to train a set of Document Definitions.

See details on how to use this object in Creating Document Definitions by Training.

Properties

Name | Type | Description
Definitions | TrainingDefinitions, read-only | Returns the collection of Document Definitions, which are trained using this training batch.
Pages | TrainingPages, read-only | Returns the collection of pages in the training batch.

Methods

Name | Description
AddImageFile | Adds an image file to the training batch.
Close | Closes the training batch and frees resources.
PrepareNextPageNotSubmittedForTraining | Prepares and returns the next page, which is not verified and submitted for training and requires user attention.
SetPageDefinition | Associates a page in the training batch with a Document Definition. This method is used to correct mistakes made during automatic selection of a Document Definition for a page. The method is not used if the training batch contains only one Document Definition.
SubmitPageForTraining | Submits the page as verified and ready for training.

Related objects

Output parameter

This object is the output parameter of the CreateTrainingBatch, OpenTrainingBatch methods of the Engine object.

Samples

cicon2 C# code

string rootFolder = "D:\\Training\\ISBN";
string batchFolder = rootFolder + "\\_TrainingBatch";
ITrainingBatch trainingBatch = engine.CreateTrainingBatch( batchFolder, "English" );
try {
ITrainingDefinition newDefinition = trainingBatch.Definitions.AddNew( "ISBN" );
trainingBatch.AddImageFile( rootFolder + "\\00.jpg" );
trainingBatch.AddImageFile( rootFolder + "\\01.jpg" );
// The user iterates through the added images until all pages have been submitted for training
ITrainingPage page = trainingBatch.PrepareNextPageNotSubmittedForTraining();
while( page != null ) {
// The user can 'draw' fields and references on any page while inside this loop.
// Any modification in the Document Definition will reset
// the ITrainingPage::IsLayoutVerified property for all pages and
// the loop will automatically reiterate through all pages.
// In this sample we try to emulate the user 'drawing' fields on the first page.
if( page == trainingBatch.Pages[0] ) {
// On the first page we 'look' for known text strings and 'draw' fields around them
for( int j = 0; j < page.ImageObjects.Count; j++ ) {
ITrainingImageObject obj = page.ImageObjects[j];
string text = obj.RecognizedText;
if( text == "978-1-4095-3439-6" ) {
// We want to extract this data field.
// Create a data field and define its geometry on the current page.
ITrainingField isbnField = newDefinition.Fields.AddNew( "ISBN", TrainingFieldTypeEnum.TFT_Field );
page.SetFieldBlock( isbnField, obj.Region );
break;
}
}
for( int j = 0; j < page.ImageObjects.Count; j++ ) {
ITrainingImageObject obj = page.ImageObjects[j];
string text = obj.RecognizedText;
if( text == "ISBN" ) {
// We want to use this text for reference.
// Create a reference element and define its geometry on the current page.
ITrainingField isbnTag = newDefinition.Fields.AddNew( "ISBNTag", TrainingFieldTypeEnum.TFT_ReferenceText );
page.SetFieldBlock( isbnTag, obj.Region );
break;
}
}
// We assume that we have succeeded in defining two items
}
// After the user has defined the layout
// (or verified the automatically computed layout for subsequent images),
// he must submit the result for training.
// In this sample we assume that the computed layout is always correct,
// so just mark the page as verified and ready for training.
trainingBatch.SubmitPageForTraining( page );
// Fetch the next page that requires attention. The method will return null when all pages have been verified.
page = trainingBatch.PrepareNextPageNotSubmittedForTraining();
}
// Export to AFL
newDefinition.ExportToAFL( batchFolder + "\\NewDefinition.afl" );
} finally {
trainingBatch.Close();
}

See also

Creating Document Definitions by Training

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


AddImageFile Method of the TrainingBatch Object

API Reference > Objects > Document Definition Training Objects > TrainingBatch >

AddImageFile Method of the TrainingBatch Object

This method adds an image from file to the training batch.

Syntax

Visual Basic .NET

Sub AddImageFile(filePath As String)

C++

HRESULT AddImageFile(
BSTR filePath
);

Parameters

filePath

[in] This variable contains the full path to the image file. For example, "D:\SampleImages\Sample.tif".

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingBatch


Close Method of the TrainingBatch Object

API Reference > Objects > Document Definition Training Objects > TrainingBatch >

Close Method of the TrainingBatch Object

This method closes the training batch.

Release all the references to the TrainingBatch object, and then call this method. An open batch uses more resources than a closed one. So if you have finished your work with the batch and need to free some resources, call this method to close the batch. We recommend using this method in finally blocks.

Syntax

Visual Basic .NET

Sub Close()

C++

HRESULT Close();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingBatch


PrepareNextPageNotSubmittedForTraining Method of the TrainingBatch Object

API Reference > Objects > Document Definition Training Objects > TrainingBatch >

PrepareNextPageNotSubmittedForTraining Method of the TrainingBatch Object

This method prepares and returns the next page, which is not verified and submitted for training and requires user attention.

Syntax

Visual Basic .NET

Function PrepareNextPageNotSubmittedForTraining() As TrainingPage

C++

HRESULT PrepareNextPageNotSubmittedForTraining(
ITrainingPage** result
);

Parameters

result

[out, retval] A pointer to the ITrainingPage* pointer variable that provides access to the next training page. If there is no more pages that require user attention (all pages in the batch have the ITrainingPage::IsLayoutVerified property set to TRUE), the method returns NULL.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingBatch


SetPageDefinition Method of the TrainingBatch Object

API Reference > Objects > Document Definition Training Objects > TrainingBatch >

SetPageDefinition Method of the TrainingBatch Object

This method associates a page in the training batch with a Document Definition. This method is used to correct mistakes made during automatic selection of a Document Definition for a page. The method is not used if the training batch contains only one Document Definition.

Syntax

Visual Basic .NET

Sub SetPageDefinition(page As TrainingPage, definition As TrainingDefinition)

C++

HRESULT SetPageDefinition(
ITrainingPage* page,
ITrainingDefinition* definition
);

Parameters

page

[in] Specifies the page, which Document Definition should be changed, as a TrainingPage object.

definition

[in] Specifies the new Document Definition for the page as a TrainingDefinition object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingBatch


SubmitPageForTraining Method of the TrainingBatch Object

API Reference > Objects > Document Definition Training Objects > TrainingBatch >

SubmitPageForTraining Method of the TrainingBatch Object

This method submits the page as verified and ready for training. This method call changes the value of the ITrainingPage::IsLayoutVerified property to TRUE.

Syntax

Visual Basic .NET

Sub SubmitPageForTraining(page As TrainingPage)

C++

HRESULT SubmitPageForTraining(
ITrainingPage* page
);

Parameters

page

[in] Specifies the page, which is ready for training, as a TrainingPage object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingBatch


TrainingDefinitions Object

TrainingDefinitions Object (ITrainingDefinitions Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingDefinitions Object (ITrainingDefinitions Interface)

This object is a collection of Document Definition obtained during training. Besides standard collection functionality, it provides access to the classifier for Document Definitions being trained. A classifier is intended for preliminary identification of pages prior to applying Document Definitions as well as for selecting the matching FlexiLayout or layout alternative.

Properties

Name | Type | Description
Classifier | TrainingClassifier, read-only | Provides access to the classifier for Document Definitions being trained. warning Important! This property is deprecated and will be removed in future versions.
Count | Int, read-only | Stores the number of elements in the collection.
Element | TrainingDefinition, read-only | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Adds a new element at the end of the collection
Delete | Removes the specified element from the collection.
Item | Provides access to a single element of the collection by its index in this collection.

Related objects

See also

TrainingDefinition

Creating Document Definitions by Training

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


AddNew Method of the TrainingDefinitions Object

API Reference > Objects > Document Definition Training Objects > TrainingDefinitions >

AddNew Method of the TrainingDefinitions Object

This method adds a new Document Definition with the specified name at the end of the collection.

Syntax

Visual Basic .NET

Function AddNew(Name As String) As TrainingDefinition

C++

HRESULT AddNew(
BSTR Name,
ITrainingDefinition** Result
);

Parameters

Name

[in] Specifies the name of the new Document Definition.

Result

[out, retval] A pointer to the ITrainingDefinition* variable that receives the interface pointer for the added Document Definition.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingDefinitions

TrainingDefinition


Delete Method of Collection Objects

API Reference > Objects > Document Definition Training Objects > TrainingDefinitions >

Delete Method of Collection Objects

This method deletes the specified element from the collection.

Syntax

Visual Basic .NET

Sub Delete(Value As <ElementType>)

C++

HRESULT Delete(
I<ElementType>* Value
);

Parameters

Value

[in] This parameter refers to the object to be deleted. ElementType is the type of objects in the collection. See the table below for details.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The table below describes the collections which provide this property and the types of elements in the collections:

Collection type | Element type
GroupLanguage | Language
TrainingBlocks | TrainingBlock
TrainingDefinitions | TrainingDefinition
TrainingFields | TrainingField
TrainingPages | TrainingPage

See also

Working with Collections


TrainingDefinition Object

TrainingDefinition Object (ITrainingDefinition Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingDefinition Object (ITrainingDefinition Interface)

This object corresponds to a Document Definition obtained during training.

Properties

Name | Type | Description
Fields | TrainingFields, read-only | Returns the collection of fields of the Document Definition.
Language | String | Specifies the recognition language, which is used for recognition with this Document Definition.
Name | String | Specifies the name of the Document Definition.
PossibleTextTypes | IntsCollection | This property contains a collection of TextTypeEnum values. The property tells ABBYY FlexiCapture Engine to presume that the text to recognize is of one of the types the collection contains. Only the following constants can be elements of the collection: TT_Normal, TT_Typewriter, TT_Matrix.

Methods

Name | Description
ExportToAFL | Creates a FlexiLayout (*.afl) from the Document Definition.

Related objects

Output parameter

This object is the output parameter of the following methods:

·AddNew, Item method of the TrainingDefinitions object

·FastClassify method of the TrainingClassifier object (deprecated)

Input parameter

This object is the input parameter of the following methods:

·Delete method of the TrainingDefinitions object

·SetPageDefinition method of the TrainingBatch object

See also

Creating Document Definitions by Training

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


ExportToAFL Method of the TrainingDefinition Object

API Reference > Objects > Document Definition Training Objects > TrainingDefinition >

ExportToAFL Method of the TrainingDefinition Object

This method creates a FlexiLayout (*.afl) from the Document Definition.

Syntax

Visual Basic .NET

Sub ExportToAFL(filePath As String)

C++

HRESULT ExportToAFL(
BSTR filePath
);

Parameters

filePath

[in] This variable contains the full path to the *.afl file.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingDefinition


TrainingFields Object

TrainingFields Object (ITrainingFields Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingFields Object (ITrainingFields Interface)

This object is a collection of fields of a Document Definition obtained during training.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | TrainingField, read-only | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Adds a new field with the specified name and type at the end of the collection of fields.
Delete | Removes the specified element from the collection.
Item | Provides access to a single element of the collection by its index in this collection.

Related objects

See also

TrainingField

Creating Document Definitions by Training

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


AddNew Method of the TrainingFields Object

API Reference > Objects > Document Definition Training Objects > TrainingFields >

AddNew Method of the TrainingFields Object

This method adds a new field with the specified name and type at the end of the collection of fields.

Syntax

Visual Basic .NET

Function AddNew( _
Name As String, _
Type As TrainingFieldTypeEnum _
) As TrainingField

C++

HRESULT AddNew(
BSTR Name,
TrainingFieldTypeEnum Type,
ITrainingField** Result
);

Parameters

Name

[in] This variable specifies the name of the field.

Type

[in] This variable specifies the type of the field. See the description of the TrainingFieldTypeEnum constants.

Result

[out, retval] A pointer to the ITrainingField* variable that receives the interface pointer for the added field.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingFields

TrainingField


TrainingField Object

TrainingField Object (ITrainingField Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingField Object (ITrainingField Interface)

This object corresponds to a field of a Document Definition obtained during training. It may be either a data field, or a reference elements. Data fields are those, which are used to extract data. Reference elements help FlexiCapture Engine to locate data fields on the page.

Properties

Name | Type | Description
ID | Int, read-only | Specifies the identifier of the field.
Name | String | Specifies the name of the field.
Type | TrainingFieldTypeEnum, read-only | Specifies the type of the field.

Related objects

Output parameter

This object is the output parameter of the Item, AddNew method of the TrainingFields object.

Input parameter

This object is the input parameter of the GetFieldBlock, SetFieldBlock methods of the TrainingPage object.

See also

Creating Document Definitions by Training

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


TrainingPages Object

TrainingPages Object (ITrainingPages Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingPages Object (ITrainingPages Interface)

This object is a collection of pages of a training batch. These pages are examples of those images, which you want to be recognized with new Document Definitions.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | TrainingPage, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Delete | Removes the specified element from the collection.
Item | Provides access to a single element of the collection by its index in this collection.

Related objects

See also

TrainingPage

Creating Document Definitions by Training

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


TrainingPage Object

TrainingPage Object (ITrainingPage Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingPage Object (ITrainingPage Interface)

This object corresponds to a page of a training batch. The training page is an example of those images, which you want to be recognized with a training Document Definition.

When the page is added to the batch, the object contains only information about the source image (Image, SourceImageFileName, SourceImageFilePage properties).

After preliminary recognition (which can be done using either the PrepareLayout method of the TrainingPage object or the PrepareNextPageNotSubmittedForTraining method of the TrainingBatch object), the page contains information about the raw image objects found on the page — these are text lines and their regions on the image.

What should be done in order that the page may be used for training Document Definitions is to correlate raw image objects with the fields of a Document Definition. This is done using the methods of the TrainingFields object and the GetFieldBlock, SetFieldBlock, RecognizeBlock methods of the TrainingPage object. As a result, the collection of blocks of the page (Blocks property) becomes meaningful.

After that, the page can be submitted for training (using the SubmitPageForTraining method of the TrainingBatch object), in which case its IsLayoutVerified property is set to TRUE.

Properties

Name | Type | Description
Blocks | TrainingBlocks, read-only | Provides access to the collection of blocks of the page.
Definition | TrainingDefinition, read-only | Specifies the Document Definition which corresponds to this page. The value of this property can be changed using the SetPageDefinition method of the TrainingBatch object.
ID | Int, read-only | Specifies the identifier of the page.
Image | ImageDocument, read-only | Provides access to the image of the page.
ImageObjects | TrainingImageObjects, read-only | Provides access to the collection of raw objects found on the page during preliminary recognition.
IsLayoutVerified | Boolean, read-only | Specifies whether the page layout is verified and ready for training. The value of this property is changed by the ITrainingBatch::SubmitPageForTraining method. Any modification in the Document Definition of a page in the training batch resets the value of this property for all pages.
SourceImageFileName | String, read-only | Specifies the path to the source image file of this page.
SourceImageFilePage | Int, read-only | Specifies the index of the source page of this page in the multi-page source image file.

Methods

Name | Description
GetFieldBlock | Gets the block of a field on this image.
PrepareLayout | Prepares the page. Analyzes the image and extracts image objects, tries to predict layout.
RecognizeBlock | Recognizes text in the specified block.
SetFieldBlock | Sets the block region of a field on this image. Creates a new block if necessary.

Related objects

Output parameter

This object is the output parameter of the following methods:

·Item method of the TrainingPages object

·PrepareNextPageNotSubmittedForTraining method of the TrainingBatch object

Input parameter

This object is the input parameter of the following methods:

·SubmitPageForTraining, SetPageDefinition methods of the TrainingBatch object

·FastClassify method of the TrainingClassifier object (deprecated)

See also

Creating Document Definitions by Training

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


GetFieldBlock Method of the TrainingPage Object

API Reference > Objects > Document Definition Training Objects > TrainingPage >

GetFieldBlock Method of the TrainingPage Object

This method gets block region for a field on this image.

Syntax

Visual Basic .NET

Function GetFieldBlock( _
element As TrainingField _
) As TrainingBlock

C++

HRESULT GetFieldBlock(
ITrainingField* element,
ITrainingBlock** result
);

Parameters

element

[in] This variable refers to the TrainingField object, which block should be obtained.

result

[out, retval] A pointer to the ITrainingBlock* variable that receives the interface pointer for the block.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingPage


PrepareLayout Method of the TrainingPage Object

API Reference > Objects > Document Definition Training Objects > TrainingPage >

PrepareLayout Method of the TrainingPage Object

This method analyzes the image, extracts image objects, and tries to predict layout. The method is used for preliminary recognition before training a Document Definition on this page.

Syntax

Visual Basic .NET

Sub PrepareLayout()

C++

HRESULT PrepareLayout();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingPage

ITrainingBatch::PrepareNextPageNotSubmittedForTraining


RecognizeBlock Method of the TrainingPage Object

API Reference > Objects > Document Definition Training Objects > TrainingPage >

RecognizeBlock Method of the TrainingPage Object

This method recognizes text in the specified block.

Syntax

Visual Basic .NET

Function RecognizeBlock( _
block As TrainingBlock, _
params As RecognitionParams _
) As String

C++

HRESULT RecognizeBlock(
ITrainingBlock* block,
IRecognitionParams* params,
BSTR* result
);

Parameters

block

[in] This variable refers to the TrainingBlock object. Specifies the block, which should be recognized.

params

[in] This variable refers to the RecognitionParams object, which contains the parameters of recognition.

result

[out, retval] Contains a string with recognized text.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingPage


SetFieldBlock Method of the TrainingPage Object

API Reference > Objects > Document Definition Training Objects > TrainingPage >

SetFieldBlock Method of the TrainingPage Object

This method sets the block region of a field on this image. The method creates a new block if necessary.

Syntax

Visual Basic .NET

Function SetFieldBlock( _
element As TrainingField, _
region As Region _
) As TrainingBlock

C++

HRESULT SetFieldBlock(
ITrainingField* element,
IRegion* region,
ITrainingBlock** result
);

Parameters

element

[in] This variable refers to the TrainingField object. Specifies the field, which block is set.

region

[in] This variable refers to the Region object, which contains the region of the block.

result

[out, retval] A pointer to the ITrainingBlock* variable that receives the interface pointer for the block.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingPage


TrainingBlocks Object

TrainingBlocks Object (ITrainingBlocks Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingBlocks Object (ITrainingBlocks Interface)

This object is a collection of blocks of a page in a training batch.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | TrainingBlock, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Delete | Removes the specified element from the collection.
Item | Provides access to a single element of the collection by its index in this collection.

Related objects

See also

TrainingBlock

Creating Document Definitions by Training

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


TrainingBlock Object

TrainingBlock Object (ITrainingBlock Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingBlock Object (ITrainingBlock Interface)

This object corresponds to the block on a page in a training batch. The block corresponds to a field of a Document Definition, applied to the image page.

Properties

Name | Type | Description
Field | TrainingField, read-only | Specifies the field, which corresponds to the block.
Region | Region, read-only | Specifies the region of the block.

Related objects

Output parameter

This object is the output parameter of the following methods:

·Item method of the TrainingBlocks object

·GetFieldBlock, SetFieldBlock methods of the TrainingPage object

Input parameter

This object is the input parameter of the RecognizeBlock method of the TrainingPage object.

See also

Creating Document Definitions by Training

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


TrainingImageObjects Object

TrainingImageObjects Object (ITrainingImageObjects Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingImageObjects Object (ITrainingImageObjects Interface)

This object is a collection of training image objects. Training image objects are found on the page during preliminary recognition — these are text lines and their regions on the image.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | TrainingImageObject, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection by its index in this collection.

Related objects

See also

TrainingImageObject

Creating Document Definitions by Training

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


TrainingImageObject Object

TrainingImageObject Object (ITrainingImageObject Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingImageObject Object (ITrainingImageObject Interface)

This object corresponds to an object found on the image during preliminary recognition. These are text lines and their regions on the image.

Properties

Name | Type | Description
RecognizedText | String, read-only | Specifies the recognized text of the object, if it contains any text.
Region | Region, read-only | Specifies the region of the object.

Related objects

Output parameter

This object is the output parameter of the Item method of the TrainingImageObjects object.

See also

Creating Document Definitions by Training

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


TrainingClassifier Object

TrainingClassifier Object (ITrainingClassifier Interface)

API Reference > Objects > Document Definition Training Objects >

TrainingClassifier Object (ITrainingClassifier Interface)

warning Important! This object is deprecated and will be removed in future versions.
This object corresponds to a training classifier. A classifier is intended for preliminary identification of pages prior to applying Document Definitions as well as for selecting the matching FlexiLayout or layout alternative. The classifier is created when training several Document Definitions of a training batch.

After training is finished, classifier can be saved as a classification tree to a *.cfl file. The created *.cfl file can be loaded into a ClassificationTree object and then used for processing with FlexiCapture processor (the IFlexiCaptureProcessor::AddClassificationTree method).

Properties

Name | Type | Description
IsValid | Boolean, read-only | Specifies whether the classifier is valid and can be exported. The classifier can be not valid, if there is not enough images in the training batch for classification.

Methods

Name | Description
ExportToCFL | Saves the training classifier as a classification tree to a *.cfl file. warning Important! This method is deprecated and will be removed in future versions.
FastClassify | Performs preliminary classification of the page in the training batch. warning Important! This method is deprecated and will be removed in future versions.

Related objects

See also

Creating Document Definitions by Training

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Creating simple Document Definitions by training


ExportToCFL Method of the TrainingClassifier Object

API Reference > Objects > Document Definition Training Objects > TrainingClassifier >

ExportToCFL Method of the TrainingClassifier Object

warning Important! This method is deprecated and will be removed in future versions.
This method saves the training classifier as a classification tree to a *.cfl file.

The created *.cfl file can be loaded to FlexiCapture Processor using the IFlexiCaptureProcessor::AddClassificationTreeFile method.

Syntax

Visual Basic .NET

Sub ExportToCFL(filePath As String)

C++

HRESULT ExportToCFL(
BSTR filePath
);

Parameters

filePath

[in] This variable contains the full path to the *.cfl file.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingClassifier

IFlexiCaptureProcessor::AddClassificationTree


FastClassify Method of the TrainingClassifier Object

API Reference > Objects > Document Definition Training Objects > TrainingClassifier >

FastClassify Method of the TrainingClassifier Object

warning Important! This method is deprecated and will be removed in future versions.
This method performs preliminary classification of the page in the training batch. The method always returns a valid training Document Definition. The results of preliminary classification can be used to display a tip on selecting a proper Document Definition in a user interface.

Syntax

Visual Basic .NET

Function FastClassify( _
page As TrainingPage, _
definition As TrainingDefinition, _
) As Boolean

C++

HRESULT FastClassify(
ITrainingPage* page,
ITrainingDefinition** definition,
VARIANT_BOOL* result
);

Parameters

page

[in] This variable refers to the TrainingPage object, which specifies the page that should be classified.

definition

[out] A pointer to the ITrainingDefinition* variable that receives the interface pointer for the resulting Document Definition. The method always returns a valid Document Definition.

result

[out, retval] This parameter is FALSE, if the page was classified uncertainly.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

TrainingClassifier


Language-Related Objects

API Reference > Objects >

Language-Related Objects

Recognition languages can be defined for the whole document or for individual data fields. They are defined in Document Definitions. ABBYY FlexiCapture Engine provides a set of predefined languages, and allows you to create your own languages with user dictionaries. The collection of predefined languages is represented by the PredefinedLanguages object. Each language in this collection is the Language object.

This section describes the following objects which provide access to languages:

·PredefinedLanguages

·Language

·SimpleLanguage

·GroupLanguage

·Dictionary

·EnumDictionaryWords

You can find additional information in the Setting up Recognition Languages section.

The hierarchy of the objects


PredefinedLanguages Object

PredefinedLanguages Object (IPredefinedLanguages Interface)

API Reference > Objects > Language-Related Objects >

PredefinedLanguages Object (IPredefinedLanguages Interface)

This object represents a collection of ABBYY FlexiCapture Engine predefined languages. Predefined languages are languages supported by default. The collection of predefined languages is created upon FlexiCapture Engine initialization and exists until it is deinitialized. Each language in the collection is represented by the Language object.

Besides standard collection functionality, this object exposes the FindLanguage method that allows you to get the Language object by its internal name.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of languages in the collection.
Element | Language, read-only | Provides access to a single element of the collection.

Methods

Name | Description
FindLanguage | Finds an element of the collection by its internal name.
Item | Provides access to a single element of the collection.

Related objects

See also

Language

Setting Up Recognition Languages

Working with Properties

See sample: FlexiCapture Engine Code Snippets


FindLanguage Method of the PredefinedLanguages Object

API Reference > Objects > Language-Related Objects > PredefinedLanguages >

FindLanguage Method of the PredefinedLanguages Object

This method finds an element of the PredefinedLanguages collection by its internal name and returns a pointer to its interface.

Syntax

Visual Basic .NET

Function FindLanguage(InternalName As String) As Language

C++

HRESULT FindLanguage(
BSTR InternalName,
ILanguage** Result
);

Parameters

InternalName

[in] This variable specifies the internal name of the language.

Result

[out, retval] A pointer to the ILanguage* pointer variable that receives the interface pointer of the Language object with the specified internal name. Returns NULL, if the language with the specified name is not found.

Return values

If the specified language is not available, this method returns E_INVALIDARG error code and NULL pointer to the language. It may also return standard return values of ABBYY FlexiCapture Engine functions.

See also

PredefinedLanguages

Language

See sample: FlexiCapture Engine Code Snippets


Language Object

Language Object (ILanguage Interface)

API Reference > Objects > Language-Related Objects >

Language Object (ILanguage Interface)

This object represents a recognition language. This object contains properties reflecting language attributes, such as its external name, components and category. The recognition languages can be set for particular Document Definition (IDocumentDefinition::DefaultLanguage) or its text block (ITextRecognitionParams::Language).

A language may be either simple (e.g. English, Russian) or compound (composed of several simple languages). See the Type property. The Language object exposes methods which cast it to a type-specific interface and thereby provide access to the extended attributes of a language of specific type.

Properties

Name | Type | Description
DatatypeCategory | DatatypeCategoryEnum, read-only | Specifies the category of data for which the language is designed.
ExternalName | String | Specifies the external name of the language. This name can be localized and used in user interface.
InternalName | String, read-only | Stores the internal name of the language. It is this name that should be passed to the IPredefinedLanguages::FindLanguage method.
LanguageCategory | LanguageCategoryEnum, read-only | Indicates the category to which the recognition language belongs. You may use this property to organize languages in your user interface.
LetterSet | String, read-only | Stores the letter set of the recognition language.
Type | LanguageTypeEnum, read-only | Specifies the type of the recognition language. Recognition language can be simple (e.g. English, Russian), or be composed of several simple languages.

Methods

Name | Description
AsSimpleLanguage | Returns the language as the SimpleLanguage object. If the language is not a simple language, NULL is returned.
AsGroupLanguage | Returns the language as the GroupLanguage object. If the language is not a language composed of several simple languages, NULL is returned.
CopyFrom | Initializes properties of the current object with values of similar properties of another object.

Related objects

Output parameter

This object is the output parameter of the following methods:

·Item, FindLanguage methods of the PredefinedLanguages object

·Item method of the GroupLanguage object

·CreateEmbeddedLanguage, CreateEmbeddedLanguageByDataType methods of the TextRecognitionParams object

Input parameter

This object is the input parameter of the following methods:

·CreateEmbeddedLanguage method of the TextRecognitionParams object

·DetectOrientationByText method of the ImageProcessingTools object

See also

Setting Up Recognition Languages

PredefinedLanguages

Working with Properties

See sample: FlexiCapture Engine Code Snippets


AsGroupLanguage Method of the Language Object

API Reference > Objects > Language-Related Objects > Language >

AsGroupLanguage Method of the Language Object

This method returns the language as the GroupLanguage object. If the language is not a language composed of several simple languages, NULL is returned.

Syntax

Visual Basic .NET

Function AsGroupLanguage() As GroupLanguage

C++

HRESULT AsGroupLanguage(
IGroupLanguage** result
);

Parameters

result

[out, retval] A pointer to the IGroupLanguage* pointer variable that receives the interface pointer to the returned GroupLanguage object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Language

GroupLanguage

See sample: FlexiCapture Engine Code Snippets


AsSimpleLanguage Method of the Language Object

API Reference > Objects > Language-Related Objects > Language >

AsSimpleLanguage Method of the Language Object

This method returns the language as the SimpleLanguage object. If the language is not a simple language, NULL is returned.

Syntax

Visual Basic .NET

Function AsSimpleLanguage() As SimpleLanguage

C++

HRESULT AsSimpleLanguage(
ISimpleLanguage** result
);

Parameters

result

[out, retval] A pointer to the ISimpleLanguage* pointer variable that receives the interface pointer to the returned SimpleLanguage object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Language

SimpleLanguage

See sample: FlexiCapture Engine Code Snippets


SimpleLanguage Object

SimpleLanguage Object (ISimpleLanguage Interface)

API Reference > Objects > Language-Related Objects >

SimpleLanguage Object (ISimpleLanguage Interface)

This object represents a simple recognition language. For example, English or French languages may be represented by SimpleLanguage object. This object provides access to a simple language attributes and allows you to get/set its internal name, letter sets, dictionary type, etc.

Properties

Name | Type | Description
AllowWordsFromDictionaryOnly | Boolean | Specifies if only the dictionary words are allowed during recognition in this language. If this property is TRUE, a word that is not found in the dictionary of the language can appear in the recognized text only if ABBYY FlexiCapture Engine found no dictionary variants. If no dictionary is associated with the language, the language will not be used for recognition.
IsNaturalLanguage | Boolean | Specifies if this language is a natural language. Natural languages are designed for recognizing common texts. Formal languages are not natural ones.
LanguageId | LanguageIdEnum | Defines the ID of the language.
LetterSet | String | Provides access to the specified letter set of the base language.
RegularExpression | String | Specifies the rules that define what words are allowed in a language and what words are not allowed. See Working with Regular Expressions for details.
UsePredefinedDictionary | Boolean | Specifies if the predefined dictionary should be used for recognition. This type of dictionary is already provided for the predefined languages that have built-in dictionary support (see the comments in the list of predefined languages). Predefined dictionaries are usually represented by three files. They have names which are usually the same as the full or short name of the language and an .amd, .amm, .amt extension.
UserDefinedDictionary | Dictionary, read-only | Specifies the user dictionary to be used for recognition. The specified dictionary is only used, if the UseUserDefinedDictionary property is set to TRUE.
UseUserDefinedDictionary | Boolean | Specifies if a user dictionary should be used for recognition. The user dictionary is specified in the UserDefinedDictionary property.

Related objects

Output parameter

This object is the output parameter of AsSimpleLanguage method of the Language object.

See also

Setting Up Recognition Languages

Language

Working with Properties

See sample: FlexiCapture Engine Code Snippets


LetterSet Property of SimpleLanguage Object

LetterSet Property of the SimpleLanguage Object

API Reference > Objects > Language-Related Objects > SimpleLanguage >

LetterSet Property of the SimpleLanguage Object

Every simple recognition language is characterized by a number of letter sets. These types are described by the LanguageLetterSetEnum enumeration constants values. This property provides access to these letter sets. It allows you to get and set a specified letter set in a form of a string containing the letter set characters.

Syntax

Visual Basic .NET

Property LetterSet(type As LanguageLetterSetEnum) As String

C++

HRESULT get_LetterSet(
LanguageLetterSetEnum type,
BSTR* pVal
);
HRESULT put_LetterSet(
LanguageLetterSetEnum type,
BSTR newVal
);

Parameters

type

[in] A variable of LanguageLetterSetEnum type that describes the type of the letter set that you want to get or set.

pVal

[out, retval] A pointer to BSTR variable that receives the value of this property. Must not be NULL.

newVal

[in] A variable of BSTR type that contains the new value of the property.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

SimpleLanguage

LanguageLetterSetEnum

Working with Properties

See sample: FlexiCapture Engine Code Snippets


GroupLanguage Object

GroupLanguage Object (IGroupLanguage Interface)

API Reference > Objects > Language-Related Objects >

GroupLanguage Object (IGroupLanguage Interface)

This object represents a language composed of several simple languages. Actually it is a group of languages.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of simple languages in the group.
Element | Language, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Add | Adds a language to the group.
Delete | Deletes a language from the group.
Item | Provides access to a single language in the group.

Related objects

Output parameter

This object is the output parameter of the AsGroupLanguage method of the Language object.

See also

Setting Up Recognition Languages

Language

SimpleLanguage

Working with Properties

See sample: FlexiCapture Engine Code Snippets


Add Method of the GroupLanguage Object

API Reference > Objects > Language-Related Objects > GroupLanguage >

Add Method of the GroupLanguage Object

This method adds a language to the group. The method adds a reference to an existing object.

Syntax

Visual Basic .NET

Sub Add(Value As Language)

C++

HRESULT Add(
ILanguage* Value
);

Parameters

Value

[in] This parameter refers to the Language object to be added.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

GroupLanguage

See sample: FlexiCapture Engine Code Snippets


Dictionary Object

Dictionary Object (IDictionary Interface)

API Reference > Objects > Language-Related Objects >

Dictionary Object (IDictionary Interface)

This object is designed for working with user dictionaries. User dictionaries are dictionaries that contain word forms of words of a certain language. Each word form in the dictionary has its own weight that defines its priority when there appear several variants for a word during recognition. The weight is a number that may have four discrete values: 25, 50, 100 and 200. User dictionaries may be connected to the SimpleLanguage object — object representing one simple recognition language.

Properties

Name | Type | Description
Name | String | Stores the name of the dictionary. After creation of the Dictionary object this property stores the name of the dictionary file (without path and extension). You may assign it any other value. This property is not saved into the file associated with the dictionary.
WordsCount | Int, read-only | Returns the number of words in the dictionary.

Methods

Name | Description
AddWord | Adds a word to the dictionary.
AddWords | Adds a group of words to the dictionary.
DeleteAllWords | Deletes all words from the dictionary.
DeleteWord | Deletes a word from the dictionary.
DeleteWords | Deletes a group of words from the dictionary.
EnumWords | Returns an object of the EnumDictionaryWords type that allows you to iterate through the words in the dictionary.

Related objects

See also

Setting Up Recognition Languages

SimpleLanguage

Working with Properties

See sample: FlexiCapture Engine Code Snippets


AddWord Method of Dictionary Object

AddWord Method of the Dictionary Object

API Reference > Objects > Language-Related Objects > Dictionary >

AddWord Method of the Dictionary Object

This method adds a new word to the dictionary.

Syntax

Visual Basic .NET

Sub AddWord( _
word As String, _
weight As Int _
)

C++

HRESULT AddWord(
BSTR word,
int weight
);

Parameters

word

[in] This parameter contains the newly added word.

weight

[in] The weight assigned to the word in the dictionary. Must be in the range from 1 to 200. The higher the weight for a word is, the more likely this word will be taken as a variant during recognition. The normal value for this parameter is 100. Visual Basic users see this parameter as having default value of 100. The weight assigned to the word in the dictionary may have a set of discrete values only. These values are 25, 50, 100, 200. The value passed in this parameter is rounded to the nearest of the discrete set of values.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

It is not recommended to use this method for adding a large number of words to the dictionary, because after adding each word the dictionary is rebuilt, and thus the operation takes a rather long time. For adding a group of words into the dictionary, use the IDictionary::AddWords method instead.

See also

Dictionary

IDictionary::AddWords

See sample: FlexiCapture Engine Code Snippets


AddWords Method of Dictionary Object

AddWords Method of the Dictionary Object

API Reference > Objects > Language-Related Objects > Dictionary >

AddWords Method of the Dictionary Object

This method adds a group of words to the dictionary.

Syntax

Visual Basic .NET

Sub AddWords( _
words As StringsCollection, _
weights As IntCollection _
)

C++

HRESULT AddWords(
IStringsCollection* words,
IIntsCollection* weights
);

Parameters

words

[in] This parameter of the StringsCollection type contains the collection of the newly added words.

weights

[in] This parameter of the IntsCollection type that must have the same size as the collection of words, is used to pass information about the weights for the newly added words. The weights for the words must be in the range from 1 to 200. You may pass 0 for this parameter in which case all the words will be included in the dictionary with default weights of 100. The weight assigned to the word in the dictionary may have a set of discrete values only. These values are 25, 50, 100, 200. The value passed in this parameter is rounded to the nearest of the discrete set of values.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

·For more efficient operation it is recommended to pre-sort the added words in alphabetical order.

·For adding one word into the dictionary, you can use the IDictionary::AddWord method.

See also

Dictionary

IDictionary::AddWord


DeleteAllWords Method of Dictionary Object

DeleteAllWords Method of the Dictionary Object

API Reference > Objects > Language-Related Objects > Dictionary >

DeleteAllWords Method of the Dictionary Object

This method deletes all words from the dictionary.

Syntax

Visual Basic .NET

Sub DeleteAllWords()

C++

HRESULT DeleteAllWords();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To delete a group of words or a single word from the dictionary, use the IDictionary::DeleteWords or IDictionary::DeleteWord method, respectively.

See also

Dictionary

IDictionary::DeleteWords

IDictionary::DeleteWord


DeleteWord Method of Dictionary Object

DeleteWord Method of the Dictionary Object

API Reference > Objects > Language-Related Objects > Dictionary >

DeleteWord Method of the Dictionary Object

This method deletes a word from the dictionary.

Syntax

Visual Basic .NET

Sub DeleteWord(word As String)

C++

HRESULT DeleteWord(
BSTR word
);

Parameters

word

[in] This parameter contains the word that is to be deleted. If the deleted word is not present in the dictionary, no error occurs.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To delete a group of words or all words from the dictionary, use the IDictionary::DeleteWords or IDictionary::DeleteAllWords method, respectively.

See also

Dictionary

IDictionary::DeleteWords

IDictionary::DeleteAllWords


DeleteWords Method of Dictionary Object

DeleteWords Method of the Dictionary Object

API Reference > Objects > Language-Related Objects > Dictionary >

DeleteWords Method of the Dictionary Object

This method deletes a group of words from the dictionary.

Syntax

Visual Basic .NET

Sub DeleteWords(words As StringsCollection)

C++

HRESULT DeleteWords(
IStringCollection* words
);

Parameters

words

[in] This parameter of the StringsCollection type contains the collection of words to be deleted. If any of the deleted words is not present in the dictionary, no error will occur.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To delete a single word or all words from the dictionary, use the IDictionary::DeleteWord or IDictionary::DeleteAllWords method, respectively.

See also

Dictionary

IDictionary::DeleteWord

IDictionary::DeleteAllWords


EnumWords Method of Dictionary Object

EnumWords Method of the Dictionary Object

API Reference > Objects > Language-Related Objects > Dictionary >

EnumWords Method of the Dictionary Object

This method returns an object of the EnumDictionaryWords type that allows you to iterate through the words in the dictionary. This method makes a copy of the dictionary, and thus all the modifications that are performed upon the dictionary after getting the EnumDictionaryWords object do not affect the latter. That is, if a word is added to the dictionary after the EnumDictionaryWords object was received for it, this word will not be included into iteration.

Syntax

Visual Basic .NET

Function EnumWords() As EnumDictionaryWords

C++

HRESULT EnumWords(
IEnumDictionaryWords** result
);

Parameters

result

[out, retval] A pointer to the IEnumDictionaryWords* pointer variable that receives the interface pointer to the returned EnumDictionaryWords object. Must not be NULL.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Dictionary

See sample: FlexiCapture Engine Code Snippets


EnumDictionaryWords Object

EnumDictionaryWords Object (IEnumDictionaryWords Interface)

API Reference > Objects > Language-Related Objects >

EnumDictionaryWords Object (IEnumDictionaryWords Interface)

This object serves for iterating words included in a user-defined dictionary. The user-defined dictionary is represented by the Dictionary object. The EnumDictionaryWords object is got from the IDictionary::EnumWords method. All modifications to the parent Dictionary object after receiving its enumerator object do not affect the latter. That is, if a new word is added to the dictionary, it will not appear in the iteration.

Methods

Name | Description
Next | Retrieves the next word from the iteration sequence.
Reset | Restarts the iteration.

Related objects

Output parameter

This object is the output parameter of the EnumWords method of the Dictionary object.

See also

Dictionary

Working with Properties

See sample: FlexiCapture Engine Code Snippets


Next Method of EnumDictionaryWords Object

Next Method of the EnumDictionaryWords Object

API Reference > Objects > Language-Related Objects > EnumDictionaryWords >

Next Method of the EnumDictionaryWords Object

This method retrieves the next word from the iteration sequence together with the word's weight in the dictionary.

Syntax

Visual Basic .NET

Function Next(confidence As Int) As String

C++

HRESULT Next(
int* confidence,
BSTR* result
);

Parameters

confidence

[out] This parameter serves for passing out the confidence of the word. Confidence or weight of the word in the dictionary defines the priority level for a word; this value is used to choose among word variants during text recognition. The higher this value is, the more preferable is this variant for the recognized word. When the iteration is over, 0 will be assigned to this parameter.

result

[out, retval] A pointer to the BSTR variable that receives the return value of this method — word from the dictionary. When the iteration is over, 0 is returned.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

EnumDictionaryWords

See sample: FlexiCapture Engine Code Snippets


Reset Method of EnumDictionaryWords Object

Reset Method of the EnumDictionaryWords Object

API Reference > Objects > Language-Related Objects > EnumDictionaryWords >

Reset Method of the EnumDictionaryWords Object

This method restarts the iteration. This method may be called any time during iteration to reset the iteration.

Syntax

Visual Basic .NET

Sub Reset()

C++

HRESULT Reset();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

EnumDictionaryWords


Text-Related Objects

API Reference > Objects >

Text-Related Objects

Text of recognized data is represented by the Text object. It provides access to the parameters of characters and the text itself. Recognized text is an attribute of a text or barcode block. As a field value the object contains the text, on which some rules have been imposed.

This section describes the following objects which provide access to a recognized text:

·Text

·RecognizedWordInfo

·RecognizedCharacterInfo

·CharParams

The hierarchy of the objects


Text Object

Text Object (IText Interface)

API Reference > Objects > Text-Related Objects >

Text Object (IText Interface)

This object represents a recognized text. The object exposes properties for accessing different text attributes and methods allowing operations upon it. The Text object exists as a subobject of some other object representing a unit of layout (text block, table cell, etc.).

Properties

Name

Type

Description

DefaultCharParams

CharParams

Stores the default character parameters. The parameters can be changed for individual characters, while the parameters specified by this property are used by default.

Length

Int, read-only

Specifies the length of the text.

PlainText

String, read-only

Stores the plain text. In the plain text all special characters are replaced with spaces.

RecognizedWordsCount

Int, read-only

Specifies the number of recognized words in the text. Please note that a word is a fragment of text separated for the purposes of recognition and not necessarily a word in the linguistic sense.

warning Important! This property is part of recognition variants API. If you intend to use it, enable recognition variants saving by a call to the EnableRecognitionVariants method of the Engine object before recognition. Otherwise the value of RecognizedWordsCount will be 0.

Text

String, read-only

Stores the text.

Methods

Name | Description
Delete | Removes a range from the current text.
GetCharParams | Provides access to the parameters of the specified character in the text.
GetCharParamsEx | Provides access to the extended recognition information for the character at the specified position in the text. Using this method you can quickly access the main recognition variant of the character (the one which is used in the resulting text).
GetRecognizedWord | Provides access to the specified recognition variant of the selected word in the text.
Insert | Inserts new text into the current text.
NextGroup | Finds the next character in the text, which has the selected parameters different from such parameters of the character specified. This method can be used to find all uncertainly recognized characters, etc.
SetCharParams | Sets parameters of the specified character in the text.

Related objects

Output parameter

This object is the output parameter of the following methods and properties:

·CreateText method of the Engine object

·Text property of the TextRegion object

See also

Working with Recognized Data

TextBlock

BarcodeBlock

FieldValue

Working with Properties


Delete Method of Text Object

Delete Method of the Text Object

API Reference > Objects > Text-Related Objects > Text >

Delete Method of the Text Object

This method removes a range of text specified by the positions of symbols.

Syntax

Visual Basic .NET

Sub Delete( _
From As Int, _
To As Int _
)

C++

HRESULT Delete(
int From,
int To
);

Parameters

From

[in] The variable specifies the index of character in the text for the starting point of the range to be removed.

To

[in] The variable specifies the index of character in the text for the ending point of the range to be removed. This character itself is not removed from the text.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The ending position for the text to be removed should be farther in the text than the starting one, otherwise an error code is returned. The symbol in From position is removed from the text, while the character in To position is not removed.

See also

Text

IText::Insert


GetCharParams Method of Text Object

GetCharParams Method of the Text Object

API Reference > Objects > Text-Related Objects > Text >

GetCharParams Method of the Text Object

This method provides access to the parameters of the specified character in the text.

Syntax

Visual Basic .NET

Sub GetCharParams( _
Pos As Int, _
Params As CharParams _
)

C++

HRESULT GetCharParams(
int Pos,
ICharParams* Params
);

Parameters

Pos

[in] Specifies the index of the character inside the text. This index must be in the range from 0 to the length of the text. The length of the text may be obtained from the IText::Length property. When the length of the text is passed into this method, this property refers to the parameters that would have received a character if it was inserted at the end of the text.

Params

[in] Refers to the CharParams object. This object properties are initialized with values corresponding to parameters of the character. A valid object should be passed as this parameter.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Text

CharParams

IText::SetCharParams

IText::GetCharParamsEx


GetCharParamsEx Method of Text Object

GetCharParamsEx Method of the Text Object

API Reference > Objects > Text-Related Objects > Text >

GetCharParamsEx Method of the Text Object

This method provides access to extended recognition information for the character at the specified position in the text. Using this method you can quickly access the main recognition variant for the character (the one which is used in the resulting text).

Syntax

Visual Basic .NET

Sub GetCharParamsEx( _
Pos As Int, _
Params As CharParams _
ParamsEx As RecognizedCharacterInfo _
)

C++

HRESULT GetCharParamsEx(
int Pos,
ICharParams* Params
IRecognizedCharacterInfo* ParamsEx
);

Parameters

Pos

[in] Specifies the index of the character inside the text. This index must be in the range from 0 to the length of the text (IText::Length). When the length of the text is passed into this method, this property refers to the parameters that would have received a character if it was inserted at the end of the text.

Params

[in] Refers to the CharParams object. This object properties are initialized with values corresponding to parameters of the character. A valid object should be passed as this parameter.

ParamsEx

[in] Refers to the RecognizedCharacterInfo object. This object properties are initialized with values corresponding to parameters of the main character variant. A valid object should be passed as this parameter.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Text

CharParams

IText::GetCharParams


GetRecognizedWord Method of Text Object

GetRecognizedWord Method of the Text Object

API Reference > Objects > Text-Related Objects > Text >

GetRecognizedWord Method of the Text Object

This method provides access to the specified recognition variant of the selected word in the text. Using this method you can view the main recognition variant of the word (which is used in the resulting text) and all other variants.

warning Important! This method is part of recognition variants API. It is available only if you enable recognition variants saving by a call to the EnableRecognitionVariants method of the Engine object before recognition.

note Note: The API working with recognition variants is not available for recognizing handprinted texts.

Syntax

Visual Basic .NET

Sub GetRecognizedWord( _
wordIndex As Int, _
variantIndex As Int, _
result As RecognizedWordInfo _
)

C++

HRESULT GetRecognizedWord(
int wordIndex,
int variantIndex,
IRecognizedWordInfo* result
);

Parameters

wordIndex

[in] Specifies the index of the word in the text. It must be in range from 0 to the value of IText::RecognizedWordsCount minus 1.

variantIndex

[in] Specifies the index of the recognition variant of the word in the internal collection of word recognition variants. The number of elements in the collection you can obtain using the IRecognizedWordInfo::RecognitionVariantsCount property of any variant of the word recognition. Recognition variants are ranked from the best to the worst. The value of the parameter can be -1, which means that the main recognition variant should be returned.

result

[in] Refers to the RecognizedWordInfo object. This object properties are initialized with values corresponding to parameters of the word variant. A valid object should be passed as this parameter.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Text


Insert Method of Text Object

Insert Method of the Text Object

API Reference > Objects > Text-Related Objects > Text >

Insert Method of the Text Object

This method inserts a new text into the current text before the specified symbol.

Syntax

Visual Basic .NET

Sub Insert( _
Text As Text, _
Pos As Int _
)

C++

HRESULT Insert(
IText* Text,
int Pos
);

Parameters

Text

[in] This variable refers to the Text object that is to be inserted.

Pos

[in] An index of a character in the text before which the text is inserted.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Text

IText::Delete


NextGroup Method of Text Object

NextGroup Method of the Text Object

API Reference > Objects > Text-Related Objects > Text >

NextGroup Method of the Text Object

This method returns the index of the next character in the text, which has the selected parameters different from such parameters of the character specified.

For example, if you set the value of the Mask parameter to CFL_Suspicious (which means that the ICharParams::IsSuspicious property should be taken into account) and the character with the Pos index is not suspicious, the method will return the index of the next suspicious character, and vice versa if the character with the Pos index is suspicious, the method will return the index of the next character, which is not suspicious.

Syntax

Visual Basic .NET

Function NextGroup( _
Pos As Int, _
Mask As Int _
) As Int

C++

HRESULT NextGroup(
int Pos,
int Mask,
int* Result
);

Parameters

Pos

[in] This variable contains the index of the character, which defines parameters of the search for the next character.

Mask

[in] This variable contains any OR combination of the CharParamsFlags flags. It defines what character parameters are taken into account when searching for the next character.

Result

[out, retval] A pointer to a int variable that receives the position of the next character, which has the selected parameters different from such parameters of the character with the Pos index. If the next character is not found, the length of the paragraph is returned.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Text

CharParamsFlags


SetCharParams Method of Text Object

SetCharParams Method of the Text Object

API Reference > Objects > Text-Related Objects > Text >

SetCharParams Method of the Text Object

This method sets parameters for a group of characters.

Syntax

Visual Basic .NET

Sub SetCharParams( _
Pos As Int, _
Count As Int, _
Params As CharParams, _
Mask As Int _
)

C++

HRESULT SetCharParams(
int Pos,
int Count,
ICharParams* Params,
int Mask
);

Parameters

Pos

[in] Position of character in paragraph that starts the group of characters for which the parameters are set. It should be in the range from 0 to the length of the text.

Count

[in] A number of characters for which the parameters are set. It should be no less than 0 and meet the following requirement: Pos + Count <= text length + 1

Params

[in] This variable refers to the CharParams object that contains the new parameters for the group of characters. It must refer to a valid object.

Mask

[in] This variable may contain any OR combination of the CharParamsFlags flags. It specifies what parameters are to be copied from the Params object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Text

CharParamsFlags

CharParams

IText::GetCharParams


RecognizedWordInfo Object

RecognizedWordInfo Object (IRecognizedWordInfo Interface)

API Reference > Objects > Text-Related Objects >

RecognizedWordInfo Object (IRecognizedWordInfo Interface)

This object represents the variant of the word recognition. The object provides access to the variant itself and its parameters. You can select the best recognition variant for a word using your own algorithm. See Working with Recognition Variants for details.

note Note: The API working with recognition variants is not available for recognizing handprinted texts.

Properties

Name | Type | Description
MeanStrokeWidth | Double, read-only | Returns the average stroke width in the RLE representation of a word image, expressed in pixels.
ModelType | WordModelTypeEnum, read-only | Returns the type of model used while composing this variant of word recognition.
Text | String, read-only | Returns the variant of the word recognition.
RecognitionVariantsCount | Int, read-only | Specifies the number of recognition variants for the word.
WordConfidence | Int, read-only | Returns the value of recognition confidence for this variant of word recognition. It represents an estimate of probability that this variant is correct, but it is unsafe to assume that confidence is a positive number or make any other assumptions about its absolute value. The only meaningful use of confidence is for comparing two recognition variants for the same word. In this case, the variant with the higher confidence is more probable.

Methods

Name | Description
GetRecognizedCharacter | Provides access to a recognition variant and parameters of a character at a given position in the word.

Output parameter

This object is the output parameter of the CreateRecognizedWordInfo method of the Engine object.

Input parameter

This object is the input parameter of the GetRecognizedWord method of the Text object.

See also

RecognizedCharacterInfo

Working with Recognition Variants

Working with Properties


GetRecognizedCharacter Method of RecognizedWordInfo Object

GetRecognizedCharacter Method of the RecognizedWordInfo Object

API Reference > Objects > Text-Related Objects > RecognizedWordInfo >

GetRecognizedCharacter Method of the RecognizedWordInfo Object

This method provides access to a recognition variant and parameters of a character at a given position in the word. Using this method you can view the main recognition variant of the character (which is used in the resulting text) and all other variants.

note Note: The API working with recognition variants is not available for recognizing handprinted texts.

Syntax

Visual Basic .NET

Sub GetRecognizedCharacter( _
index As Int, _
variantIndex As Int, _
result As RecognizedCharacterInfo _
)

C++

HRESULT GetRecognizedCharacter(
int index,
int variantIndex,
IRecognizedCharacterInfo* result
);

Parameters

index

[in] Specifies the index of the character in the word. It must be in range from 0 to the length of the word (length of the IRecognizedWordInfo::Text string) minus 1.

variantIndex

[in] Specifies the index of the recognition variant of the character in the internal collection of character recognition variants. The number of variants in the collection can be obtained using the IRecognizedCharacterInfo::RecognitionVariantsCount property of any variant of the character recognition. Recognition variants are ranked from the best to the worst. The value of the parameter can be -1, which means that the main recognition variant should be returned.

result

[in] Refers to the RecognizedCharacterInfo object. This object properties are initialized with values corresponding to parameters of the character variant. A valid object should be passed as this parameter.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

RecognizedWordInfo


RecognizedCharacterInfo Object

RecognizedCharacterInfo Object (IRecognizedCharacterInfo Interface)

API Reference > Objects > Text-Related Objects >

RecognizedCharacterInfo Object (IRecognizedCharacterInfo Interface)

This object represents the variant of the character recognition. The object provides access to the variant itself and its parameters. You can select the best recognition variant for a character using your own algorithms. See Working with Recognition Variants for details.

note Note: The API working with recognition variants is not available for recognizing handprinted texts.

Properties

Name | Type | Description
Bottom | Int, read-only | Stores the coordinate of the bottom border of the character rectangle for this variant of character recognition.
Character | String, read-only | Returns the variant of a character recognition.
CharConfidence | Int, read-only | Stores the value of recognition confidence for this variant of character recognition. It represents an estimate of probability that this variant is correct, but it is unsafe to assume that confidence is a positive number or make any other assumptions about its absolute value. The only meaningful use of confidence is for comparing two recognition variants for the same character. In this case, the variant with the higher confidence is more probable.
IsSubscript | Boolean, read-only | Specifies whether the variant of a character recognition is subscript.
IsSuperscript | Boolean, read-only | Specifies whether the variant of a character recognition is superscript.
LanguageId | LanguageIdEnum, read-only | Specifies the identifier of the character language.
Left | Int, read-only | Stores the coordinate of the left border of the character rectangle for this variant of character recognition.
RecognitionVariantsCount | Int, read-only | Stores the number of recognition variants available for the character.
RecognitionVariantIndex | Int, read-only | Stores the index of the variant in the internal collection of character recognition variants.
Region | Region, read-only | Specifies the character exact region for this variant of character recognition. The region may not be rectangular and initially is contained in the rectangle defined by the Left, Top, Right, and Bottom properties. If you change the character exact region, the Left, Top, Right, and Bottom properties are not changed.
Right | Int, read-only | Stores the coordinate of the right border of the character rectangle for this variant of character recognition.
SerifProbability | Int, read-only | The value of this property specifies probability that the variant of a character recognition is written with a Serif font. It is in the range from 0 to 100, and -1 corresponds to the fact that this probability is undefined.
Top | Int, read-only | Stores the coordinate of the top border of the character rectangle for this variant of character recognition.

Output parameter

This object is the output parameter of the CreateRecognizedCharacterInfo method of the Engine object.

Input parameter

This object is the input parameter of the following methods:

·GetCharParamsEx method of the Text object

·GetRecognizedCharacter method of the RecognizedWordInfo object

See also

RecognizedWordInfo

Working with Recognition Variants

Working with Properties


CharParams Object

CharParams Object (ICharParams Interface)

API Reference > Objects > Text-Related Objects >

CharParams Object (ICharParams Interface)

This object allows you to access the parameters of a single character in recognized text. All the Boolean properties of a newly created object of this type are set to FALSE.

This object does not provide access to the variants of character recognition. A single variant of a character recognition is represented by the RecognizedCharacterInfo object.

Properties

Name | Type | Description
CharConfidence | Int, read-only | Stores the value of recognition confidence of the character. This is the confidence of the main (selected) recognition variant. It represents an estimate of probability that this variant is correct, in comparison to other recognition variants. See also What is the difference between the CharConfidence and the IsSuspicious properties? This property is only valid for characters from the documents recognized with FlexiCapture processor.
IsEditedByRules | Boolean | Specifies whether the character has been edited during rules checking. By default, the value of this property is FALSE.
IsEditedByUser | Boolean | Specifies whether the character has been edited by a user. By default, the value of this property is FALSE.
IsSuspicious | Boolean | This property set to TRUE means that the character was recognized uncertainly. By default, the value of this property is FALSE.
LanguageId | LanguageIdEnum | Specifies the identifier of the character language. By default this property is initialized with system default language ID.
NeedsGroupVerification | Boolean | Specifies whether the character should be submitted for group verification. We recommend submitting only checkmarks and fields containing numbers for group verification. By default, the value of this property is FALSE.
NeedsVerification | Boolean | Specifies whether the character should be submitted for verification. By default, the value of this property is FALSE.
PageID | Int | Specifies the identifier of the page that contains the character rectangle.
RecognizedWordCharacterIndex | Int, read-only | Stores the index of the character in the word, which contains this character.
RecognizedWordIndex | Int, read-only | Stores the index of the word, which contains the character, in the collection of recognized words.
Rectangle | Rectangle | Specifies the coordinates of the character.

Related objects

Output parameter

This object is the output parameter of the CreateCharParams method of the Engine object.

Input parameter

This object is the input parameter of the following methods:

·CreateText method of the Engine object

·GetCharParams, GetCharParamsEx, SetCharParams method of the Text object

See also

Text

Working with Properties


Image-Related Objects

API Reference > Objects >

Image-Related Objects

An unrecognized document contains a combination of one or several page images. Each page image is represented by the ImageDocument object. This object contains a number of image planes, represented by a respective number of the Image objects. These planes are: full-size black-and-white copy of the deskewed image, full-size color copy of the deskewed image, and a small color preview, which is optional. ABBYY FlexiCapture Engine also provides the ImageModification object, which allows you to modify an image, prepare it for recognition, etc.

This section describes the following objects:

·ImageDocument

·Image

·ImageModification

·ImageProcessingTools

·DenoiseFilterParams

·FrequencyTransformParams

·ImageFile

The hierarchy of the objects


ImageDocument Object

ImageDocument Object (IImageDocument Interface)

API Reference > Objects > Image-Related Objects >

ImageDocument Object (IImageDocument Interface)

This object corresponds to an open image, or “image document” – an image in the so-called “internal format”. Its attributes reflect the attributes of an image. ImageDocument object is a root for a collection of the Image objects, or “image planes”. Each image document includes 3 image planes:

·Black-and-white plane. It is the black-and-white copy of the source image. The copy is deskewed or non-deskewed depending on the values of the CorrectSkewXXX properties of the ImageLoadingParams object.

·Color plane. It is the color or gray copy of the source image. The copy is deskewed or non-deskewed depending on the values of the CorrectSkewXXX properties of the ImageLoadingParams object. If a source image was black-and-white, this page is the same as the "black-and-white" plane.

·Preview. A small gray image used for displaying the preview in user interface.

Each image plane of the above-mentioned set is characterized by its own size and resolution. The size and resolution of black-and-white and color images are the same. Since image documents consist of deskewed images, the ImageDocument object has a set of coordinate conversion functions. Use the ConvertCoordinates function to convert pixel coordinates from one image page to another. Remember that the recognition functions use the deskewed page.

Properties

Name | Type | Description
BlackWhiteImage | Image, read-only | Provides access to the black-and-white image plane of the current ImageDocument object.
ColorImage | Image, read-only | Provides access to the color image plane of the current ImageDocument object.
ImageColorType | ImageColorTypeEnum, read-only | Each color plane of the ImageDocument is characterized by its own color type. This property specifies the color type for the whole ImageDocument as the maximum of the corresponding values for its color planes (black-and-white, gray, color).
ImageRotation | RotationTypeEnum, read-only | Specifies rotation that was performed upon the current ImageDocument object from the opening or from the last call to the SaveModified method.
ImageWasInverted | Boolean, read-only | This property set to TRUE specifies that the image colors were inverted after opening or after the last call to SaveModified method.
ImageWasMirrored | Boolean, read-only | This property set to TRUE specifies that the image was mirrored around the vertical axis after opening or after the last call to SaveModified method.
IsInternalFormat | Boolean, read-only | Specifies if image is in ABBYY FlexiCapture Engine internal format.
IsModified | Boolean, read-only | Specifies if any modifications were made upon the ImageDocument object since it was obtained from the image file or from the last call of the SaveModified method. Information about modifications is available through the ImageWasInverted, ImageWasMirrored and IPage::ImageRotation properties.
IsReadOnly | Boolean, read-only | Specifies if the current representation of image file by the ImageDocument object is read-only. If it is read-only, modification methods upon it will lead to error code returned.
IsSkewCorrected | Boolean, read-only | Specifies whether the skew of the image was fully corrected. This property is TRUE if the image does not need any skew correction (all the CorrectSkewXXX properties of the ImageLoadingParams object are set to FALSE) or if the skew was fully corrected during the preparation process as defined by the CorrectSkewXXX properties of the ImageLoadingParams object. If the value of this property is FALSE, an attempt to correct the skew of the image failed.
PreviewImage | Image, read-only | Provides access to the preview image plane of the current ImageDocument object. Not all open images contain this image plane, therefore the object accessed through this property may be NULL.
SkewAngle | Double, read-only | Stores the tangent of skew angle that was detected for the image and corrected during opening. If the skew angle is negative the image is rotated clockwise; if the angle is positive the image is rotated counter-clockwise. The image can be rotated around any point. The size of the deskewed image is always larger than the size of the original image.
SourceImageFileFormat | ImageFileFormatEnum, read-only | Provides information about format of the source image file of the current ImageDocument object. If this information is not available or image was received from scanner, the value of this property is IFF_UnknownFormat. note Note: Information about format of the source image file is not saved in ABBYY FlexiCapture Engine.
SourceImageScannerInfo | String, read-only | Provides information about scanner used to acquire the image. If information about source image parameters is not available or image was received from file, the value of this property is empty string.
SourceImageScanThreshold | Int, read-only | Provides information about scanning intensity threshold for the current ImageDocument object. If information about source image parameters is not available or image was obtained from file, the value of this property is -1.
SourceImageXResolution | Int, read-only | Provides information about horizontal resolution of the source image of the current ImageDocument object. If information about source image parameters is not available, the value of this property is 0.
SourceImageYResolution | Int, read-only | Provides information about vertical resolution of the source image of the current ImageDocument object. If information about source image parameters is not available, the value of this property is 0.

Methods

Name | Description
ChangeResolution | Changes resolution of the image.
ConvertCoordinates | Converts coordinates of a pixel between image planes of the ImageDocument object.
SaveModified | Saves all modifications that were performed upon the current ImageDocument object into the folder on disk.
SaveTo | Saves the contents of the ImageDocument object into a folder on disk. The image is saved in ABBYY FineReader Engine internal format. The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to FineReader Engine, and vice versa.
SaveToFile | Saves the contents of the ImageDocument object into a file. The file is saved in a format which cannot be viewed in any external program. The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to FineReader Engine, and vice versa.
SaveToMemory | Saves the contents of the ImageDocument object into the global memory. The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa.

Related objects

Output parameter

This object is the output parameter of the LoadImageDocFromFile, LoadImageDocFromMemory, LoadImageDocument methods of the Engine object.

Input parameter

This object is the input parameter of the AddImageDocument method of the FlexiCaptureProcessor object.

See also

Image

Page

PageDefinition

Integration with ABBYY FineReader Engine

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal


ChangeResolution Method of ImageDocument Object

ChangeResolution Method of the ImageDocument Object

API Reference > Objects > Image-Related Objects > ImageDocument >

ChangeResolution Method of the ImageDocument Object

This method changes the resolution of the image. The size of the image in pixels remains unchanged.

Syntax

Visual Basic .NET

Sub ChangeResolution(NewResolution As Int)

C++

HRESULT ChangeResolution(
int NewResolution
);

Parameters

NewResolution

[in] The parameter contains the new value of the resolution. Must be in range from 50 to 3200 dpi.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

This operation cannot be applied to read-only image.

See also

ImageDocument


ConvertCoordinates Method of ImageDocument Object

ConvertCoordinates Method of the ImageDocument Object

API Reference > Objects > Image-Related Objects > ImageDocument >

ConvertCoordinates Method of the ImageDocument Object

This method converts coordinates of a pixel defined on an image plane to coordinates defined on another image plane. Conversion between all possible pairs of image planes is permitted.

Syntax

Visual Basic .NET

Sub ConvertCoordinates( _
FromPage As ImageTypeEnum, _
ToPage As ImageTypeEnum, _
X As Int, _
Y As Int _
)

C++

HRESULT ConvertCoordinates(
ImageTypeEnum FromPage,
ImageTypeEnum ToPage,
int* X,
int* Y
);

Parameters

FromPage

[in] This variable of the ImageTypeEnum type specifies the image page from which the coordinates of pixel are to be converted.

ToPage

[in] This variable of the ImageTypeEnum type specifies the image page to which the coordinates of pixel are to be converted.

X

[in, out] This variable stores the horizontal coordinate of the pixel relative to the source image page before the method call, and the horizontal coordinate of the pixel relative to the target image page after the method call.

Y

[in, out] This variable stores the vertical coordinate of the pixel relative to the source image page before the method call, and the vertical coordinate of the pixel relative to the target image page after the method call.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The coordinates of pixels on the black-and-white image page and the color image page are the same.

See also

ImageTypeEnum


SaveModified Method of ImageDocument Object

SaveModified Method of the ImageDocument Object

API Reference > Objects > Image-Related Objects > ImageDocument >

SaveModified Method of the ImageDocument Object

This method saves all the modifications that were performed upon the current ImageDocument object into the folder on disk. It does not overwrite the source image file. It sets the value of the IImageDocument::IsModified property to FALSE.

Syntax

Visual Basic .NET

Sub SaveModified()

C++

HRESULT SaveModified();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageDocument


SaveToFile Method of ImageDocument Object

SaveTo Method of the ImageDocument Object

API Reference > Objects > Image-Related Objects > ImageDocument >

SaveTo Method of the ImageDocument Object

This method saves the contents of the ImageDocument object into a folder on disk. The image is saved in ABBYY FlexiCapture Engine internal format. The ImageDocument object saved using this method can be opened with the help of the IEngine::LoadImageDocument method only.

The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa.

Syntax

Visual Basic .NET

Sub SaveTo(folderName As String)

C++

HRESULT SaveTo(
BSTR folderName
);

Parameters

folderName

[in] This parameter stores the full path to the folder. For example, "C:\MyPic".

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageDocument

IEngine::LoadImageDocument


SaveToFile Method of ImageDocument Object

SaveToFile Method of the ImageDocument Object

API Reference > Objects > Image-Related Objects > ImageDocument >

SaveToFile Method of the ImageDocument Object

This method saves the contents of the ImageDocument object into a file. The file is saved in a format which cannot be viewed in any external program. The ImageDocument object saved using this method can be opened with the help of the IEngine::LoadImageDocFromFile method only.

The method can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa.

Syntax

Visual Basic .NET

Sub SaveToFile(fileName As String)

C++

HRESULT SaveToFile(
BSTR fileName
);

Parameters

fileName

[in] This parameter stores the full path to the file. For example, "C:\MyPic.imageDoc". If this file already exists, it is overwritten without prompt.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

This method is not suitable for saving images, as it saves the contents of the ImageDocument object in a format not suitable for viewing. It is designed for situations when it is not possible to use the IImageDocument::SaveTo method which saves the object's contents into a folder on disk.

To save an image in a format suitable for viewing, use the IImage::WriteToFile method.

See also

ImageDocument

IEngine::LoadImageDocFromFile


SaveToMemory Method of the ImageDocument Object

API Reference > Objects > Image-Related Objects > ImageDocument >

SaveToMemory Method of the ImageDocument Object

This method saves the contents of the ImageDocument object into the global memory. The method returns an HGLOBAL handle of the memory area allocated for the object as the Handle object. This object manages memory allocation and releases resources when they are no longer in use.

The contents of the object can be restored with the help of the IEngine::LoadImageDocFromMemory method of ABBYY FlexiCapture Engine or ABBYY FineReader Engine libraries. The methods can be used for transferring the ImageDocument object from ABBYY FlexiCapture Engine to ABBYY FineReader Engine, and vice versa.

Syntax

C++

HRESULT SaveToMemory( IHandle** Result );

C#

Handle SaveToMemory();

Visual Basic .NET

Function SaveToMemory() As Handle

Parameters

Result

[out, retval] A pointer to IHandle* pointer variable that receives interface pointer of the resulting Handle object representing the handle to the associated bitmap.

Return values

This method has no specific return values. It returns standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageDocument

IEngine::LoadImageDocFromMemory


Image Object

Image Object (IImage Interface)

API Reference > Objects > Image-Related Objects >

Image Object (IImage Interface)

This object represents a single "image plane" (black-and-white, color or preview) of an open image. It gives a user access to properties of this "image plane", such as its geometrical parameters and resolution. It allows you to get a bitmap handle corresponding to this image.

Properties

Name | Type | Description
ImageColorType | ImageColorTypeEnum, read-only | Specifies the color type for the current image plane (black-and-white, gray, color). note Note: By agreement on the ABBYY FlexiCapture Engine API, if the ImageDocument object represents black-and-white image, an image plane received from IImageDocument::ColorImage property will actually be of black-and-white color type. This property provides information about actual color type of the current image plane.
ImageDocument | ImageDocument, read-only | This property refers to the parent ImageDocument object of the current image plane. For an independent Image object, this property returns NULL.
Height | Int, read-only | Stores the height of the current image plane in pixels. The height of the black-and-white image plane of an image is equal to the height of the color image plane of the image.
Resolution | Int, read-only | Stores the resolution of the current image plane in pixels per inch. The resolution of the black-and-white image plane of an image is equal to the resolution of the color image plane of the image.
Width | Int, read-only | Stores the width of the current image plane in pixels. The width of the black-and-white image plane of an image is equal to the width of the color image plane of the image.
XResolution | Int, read-only | Stores the horizontal resolution of the current image plane in pixels per inch. The resolution of the black-and-white image plane of an image is equal to the resolution of the color image plane of the image.
YResolution | Int, read-only | Stores the vertical resolution of the current image plane in pixels per inch. The resolution of the black-and-white image plane of an image is equal to the resolution of the color image plane of the image.

Methods

Name | Description
Close | Closes the image to free up the memory.
EstimateBitmapSize | Estimates the size of the bitmap that will be returned by the GetPicture method.
GetPicture | Returns a handle of bitmap that corresponds to the current image plane.
WriteToFile | Writes the image of the current image plane into an image file.

Related objects

Output parameter

This object is the output parameter of the following methods:

·GetNextImage method of the IImageSource interface

·ApplyFrequencyTransform, Binarize, BitmapToImage, ConvertToGray, CorrectImageGeometry, CropImage, EqualizeBrightness, FillRegionWithColor, FilterColor, InvertRegion, MirrorImage, PreprocessCameraImage, RemoveGarbage, RemoveMotionBlur, RotateImage, RotateImageByRotationType, SmoothImageByGaussianKernel, SmoothImageBySquareAverage, SmoothTexture, StretchImage, StretchTrapezoidToRectangle, SuppressColorObjects methods of the ImageProcessingTools object

·OpenImagePage method of the ImageFile object

Input parameter

This object is the input parameter of the following methods:

·ApplyFrequencyTransform, Binarize, ConvertToGray, CorrectImageGeometry, CreateDenoiseFilterParamsByImage, CropImage, DetectEmpty, DetectOrientationByText, EqualizeBrightness, FillRegionWithColor, FilterColor, ImageToBitmap, InvertRegion, MirrorImage, PreprocessCameraImage, RemoveGarbage, RemoveMotionBlur, RotateImage, RotateImageByRotationType, SmoothImageBySquareAverage, SuppressColorObjects, SmoothImageByGaussianKernel, SmoothTexture, StretchImage, StretchTrapezoidToRectangle methods of the ImageProcessingTools object

·AddImage method of the FlexiCaptureProcessor object

See also

ImageDocument

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal


Close Method of the Image Object

API Reference > Objects > Image-Related Objects > Image >

Close Method of the Image Object

This method reclaims the memory occupied by the images that are no longer in use closing them. The method is used in those programming languages in which the garbage collector call may be postponed.

Syntax

Visual Basic .NET

Sub Close()

C++

HRESULT Close();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Image


EstimateBitmapSize Method of Image Object

EstimateBitmapSize Method of the Image Object

API Reference > Objects > Image-Related Objects > Image >

EstimateBitmapSize Method of the Image Object

This method estimates the size of memory that is to be allocated for the bitmap returned from the IImage::GetPicture method called with the same parameters. Thus, its input parameters are analogous to those of the IImage::GetPicture.

Syntax

Visual Basic .NET

Function EstimateBitmapSize( _
Modification As ImageModification, _
Mode As Int _
) As Int

C++

HRESULT EstimateBitmapSize(
ImageModification* Modification,
int Mode,
int* Result
);

Parameters

Modification

[in] This parameter of the ImageModification type specifies modifications that are performed upon image. This parameter may be 0, and in this case no modifications will be performed upon the image page and it will be passed "as is".

Mode

[in] This parameter may be any combination of GetPictureFlags flags or contain 0.

Result

[out, retval] A pointer to int variable that receives the return value of this method. Must not be NULL.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Image

IImage::GetPicture


GetPicture Method of Image Object

GetPicture Method of the Image Object

API Reference > Objects > Image-Related Objects > Image >

GetPicture Method of the Image Object

This method returns a part of image in the Device Independent Bitmap (DIB) format. The palette, where 0 is the black color, is used for gray and black-and-white images.

The method returns the DIB as the Handle object. This object manages memory allocation and releases resources when they are no longer in use.

Syntax

C++

HRESULT GetBitmap(
IImageModification* Modification,
int Mode,
IHandle** Result
);

C#

Handle GetBitmap(
ImageModification Modification,
int Mode
);

Visual Basic .NET

Function GetPicture( _
Modification As ImageModification, _
Mode As Int _
) As Handle

Parameters

Modification

[in] This parameter of ImageModification type defines modifications that are performed upon image. It may include clipping rectangles, in which case only specified parts of the image are passed, stretch ratio, painting rectangles for filling up parts of the image with color and so on. This parameter may be 0, and in this case no modifications will be performed upon the image page and it will be passed "as is".

Mode

[in] This parameter may be any combination of GetPictureFlags flags or contain 0.

Result

[out, retval] A pointer to IHandle* pointer variable that receives interface pointer of the resulting Handle object representing the handle to the associated bitmap.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

This method does not work if the Engine object is created using the OutprocLoader object.

See also

IImage::EstimateBitmapSize

See sample: FlexiCapture Engine Code Snippets


WriteToFile Method of Image Object

WriteToFile Method of the Image Object

API Reference > Objects > Image-Related Objects > Image >

WriteToFile Method of the Image Object

This method saves a copy of the current image plane into an image file in the specified format.

Syntax

Visual Basic .NET

Sub WriteToFile( _
FileName As String, _
Format As ImageFileFormatEnum, _
Modification As ImageModification, _
CompressionType As ImageCompressionTypeEnum, _
extendedParams As Object _
)

C++

HRESULT WriteToFile(
BSTR FileName,
ImageFileFormatEnum Format,
ImageModification* Modification,
ImageCompressionTypeEnum CompressionType,
IUnknown* extendedParams
);

Parameters

FileName

[in] This parameter contains the full path to the image file where the image is saved. For example, "C:\MyPic.bmp". If a file in this path already exists, it is overwritten without prompt.

Format

[in] A variable of the ImageFileFormatEnum type that specifies the format of the output file. Not all formats defined by this enumeration are supported for writing. Format and CompressionType parameters are related. See the list of supported combinations below.

Modification

[in] This parameter of the ImageModification type defines modifications that are performed upon image before writing it into file. This parameter is optional and may be 0, in which case no modifications are performed upon image.

CompressionType

[in] A variable of the ImageCompressionTypeEnum type that specifies the compression type of the output file. Format and CompressionType parameters are related. For all image formats except TIFF (IFF_Tif), set this parameter to ICT_Default; compression type will then be selected automatically. See the table below for information about compression types supported for TIFF images.

extendedParams

[in] This variable may refer to the JpegExtendedParams or PngExtendedParams object that defines parameters for saving the image to JPEG or PNG format. This parameter is optional and may be 0. In this case the JPEG image is saved with lossless JPEG 2000 compression, or the PNG image is saved with the default parameters.

Return values

This method returns E_INVALIDARG if the saving format is black-and-white while the format of the image is gray or color. It may also return standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The table below describes the possible values of the CompressionType parameter for TIFF images (IFF_Tif). The compression depends on the color type of the saving image (IImage::ImageColorType).

Image color type | CompressionType
Black-and-white image (ICT_BlackWhite) | ICT_Uncompressed ICT_CcittGroup4 ICT_PackBits ICT_Lzw ICT_Zip
Color image (ICT_Color), gray image (ICT_Gray) | ICT_Uncompressed ICT_PackBits ICT_Jpeg ICT_Lzw ICT_Zip

See also

Image


ImageModification Object

ImageModification Object (IImageModification Interface)

API Reference > Objects > Image-Related Objects >

ImageModification Object (IImageModification Interface)

This object is used to store parameters of image modification: image skew correction and stretch ratio. The object can be used as an input parameter of some methods of the Image object.

Properties

Name

Type

Description

ClipRegion

Region

Specifies a modification region. This region is cut from the source image, modified according to the modification settings, and used as the result of image modification. If this property contains an empty region, the entire image is modified.

note Note: The property returns a copy of the Region object but not a reference to it. To modify the value of the property, you must assign the value of this property to a Region object, change the necessary parameters, and then assign this object back to the property.

StretchRatio

Double

Specifies the stretch ratio to apply to the image. By default this property is 1.0 that corresponds to no stretch.

Output parameter

This object is the output parameter of the CreateImageModification method of the Engine object.

Input parameter

This object is the input parameter of the EstimateBitmapSize, GetPicture, WriteToFile methods of the Image object.

See also

Image

Working with Properties


JpegExtendedParams Object

JpegExtendedParams Object (IJpegExtendedParams Interface)

API Reference > Objects > Image-Related Objects >

JpegExtendedParams Object (IJpegExtendedParams Interface)

This object provides functionality for tuning the parameters of saving an image to JPEG format (color and gray IFF_Jpg format with ICT_Jpeg compression, color and gray IFF_J2k format with ICT_J2k compression, color and gray IFF_Tif format with ICT_Jpeg compression) using the IImage::WriteToFile method. A pointer to this object is passed into the IImage::WriteToFile method as an input parameter, and thus affects the size and quality of the resulting image. All properties of a newly created object of this type are set to reasonable defaults. See the description of particular property for its default value.

The JpegExtendedParams object is a persistent object. This means that the object current state, indicated by the values of its properties, can be written to persistent storage: an area in the global memory or a disk file. Later, the object can be re-created by reading the object's state from persistent storage. The following methods provide persistence of the object: SaveToFile, LoadFromFile, SaveToMemory, and LoadFromMemory.

Properties

Name | Type | Description
Quality | Int | Stores the value of the JPEG quality in percent. The default value for this property is 50.

Methods

Name | Description
CopyFrom | Initializes properties of the current object with values of similar properties of another object.
LoadFromFile | Restores the object's contents from a file on disk.
LoadFromMemory | Restores the object's contents from the global memory.
SaveToFile | Saves the object's contents into a file on disk.
SaveToMemory | Saves the object's contents into the global memory.

Output parameter

This object is the output parameter of the CreateJpegExtendedParams method of the Engine object.

Input parameter

This object is the input parameter of the WriteToFile method of the Image object.

See also

Working with Properties


LoadFromFile Method

API Reference > Objects > Image-Related Objects > JpegExtendedParams >

LoadFromFile Method

This method restores the contents of the object from a file on disk, where it should have previously been saved by the SaveToFile method.

Syntax

Visual Basic .NET

Sub LoadFromFile(Path As String)

C++

HRESULT LoadFromFile( BSTR Path );

Parameters

Path

[in] A path to the file on disk where the contents of the object is stored. If a file specified by this path was not obtained as a result of a call to the SaveToFile method of an object of the same type as the current one, some specific error code is returned.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following objects provide this method:

·ClassificationTree

·JpegExtendedParams

·Region

See also

SaveToFile

SaveToMemory

LoadFromMemory


LoadFromMemory Method

API Reference > Objects > Image-Related Objects > JpegExtendedParams >

LoadFromMemory Method

This method restores the contents of the object from the global memory. The method takes as an input parameter an HGLOBAL handle, which should be obtained from the HandleAsInt64 property of the Handle object. The Handle object is returned by the SaveToMemory method of an object of the same type as the current one.

Syntax

C++

HRESULT LoadFromMemory( __int64 HGlobal );

C#

void LoadFromMemory(Int64 HGlobal );

Visual Basic .NET

Sub LoadFromMemory(HGlobal As Int64)

Parameters

HGlobal

[in] This parameter specifies the HGLOBAL handle of the memory from where the object contents should be loaded. The handle is passed as __int64.This handle should be the one obtained from the SaveToMemory method of an object of the same type as the current one, and should be valid (not freed). .

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

·The size of the memory area that the object allocates can be obtained by calling the GlobalSize function.

·The following objects provide this method:

oJpegExtendedParams

oRegion

See also

SaveToMemory

SaveToFile

LoadFromFile


SaveToFile Method

API Reference > Objects > Image-Related Objects > JpegExtendedParams >

SaveToFile Method

This method saves the contents of the object into a file on disk.

Syntax

C++

HRESULT SaveToFile( BSTR Path );

C#

void SaveToFile( string Path );

Visual Basic .NET

Sub SaveToFile( Path As String )

Parameters

Path

[in] This parameter specifies the path to the file where the object contents should be saved. If a file with this name already exists, it is overwritten without prompt.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following objects provide this method:

·Region

·JpegExtendedParams

See also

LoadFromFile

SaveToMemory

LoadFromMemory


SaveToMemory Method

API Reference > Objects > Image-Related Objects > JpegExtendedParams >

SaveToMemory Method

This method saves the contents of the object into the global memory. The method returns an HGLOBAL handle of the memory area allocated for the object as the Handle object. This object manages memory allocation and releases resources when they are no longer in use.

Syntax

C++

HRESULT SaveToMemory( IHandle** Result );

C#

Handle SaveToMemory();

Visual Basic .NET

Function SaveToMemory() As Handle

Parameters

Result

[out, retval] A pointer to IHandle* pointer variable that receives interface pointer of the resulting Handle object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

The following objects provide this method:

·Region

·JpegExtendedParams

See also

LoadFromMemory

SaveToFile

LoadFromFile


PngExtendedParams

PngExtendedParams Object (IPngExtendedParams Interface)

API Reference > Objects > Image-Related Objects >

PngExtendedParams Object (IPngExtendedParams Interface)

This object provides functionality for tuning the parameters of saving a black-and-white image to PNG format (IFF_Png format) using the IImage::WriteToFile method. A pointer to this object is passed into the IImage::WriteToFile method as an input parameter, and thus affects the properties of the resulting image.

Properties

Name

Type

Description

TransparentColor

Int

Sets the color which must be replaced by transparent areas when saving the image in PNG format.

Only black and white colors are currently supported.

note Note: The int value is calculated from the RGB triplet using the formula: (red value) + (256 x green value) + (65536 x blue value), where red value is the first triplet component, green value is the second triplet component, blue value is the third triplet component. For example, the int value of the color white equals 16777215.

The default value of this property is -1, which means that no colors will be replaced with transparency.

Output parameter

This object is the output parameter of the CreatePngExtendedParams method of the Engine object.

Input parameter

This object is the input parameter of the WriteToFile method of the Image object.

See also

Working with Properties


ImageProcessingTools Object

ImageProcessingTools Object (IImageProcessingTools Interface)

API Reference > Objects > Image-Related Objects >

ImageProcessingTools Object (IImageProcessingTools Interface)

This object allows you to preprocess images before recognition. The methods provided by this object can be used when implementing a custom image source for the FlexiCapture processor.

The standard procedure, which uses this object, is as follows:

1.Open an image file using either the OpenImageFile or OpenImageFileFromStream method. These methods return an opened file as the ImageFile object.

2.Open a page of the image file using the OpenImagePage of the ImageFile object. This method provides access to an image page as the Image object.

3.Preprocess the image page using one of the available methods or implement your own preprocessing algorithm. The preprocessed image then can be passed to the FlexiCapture processor for recognition. With the available methods you can do the following operations:

oremove noise from color photos (RemoveNoise, CreateDenoiseFilterParamsByImage methods)

oremove motion blur from photos, equalize their brightness (RemoveMotionBlur, EqualizeBrightness methods)

oremove geometrical distortions from an image or stretch it (CorrectImageGeometry, StretchTrapezoidToRectangle, StretchImage methods)

osuppress color objects in official documents (SuppressColorObjects method)

oremove garbage (excess dots that are smaller than a certain size) from an image (RemoveGarbage method)

osmooth image (SmoothImageBySquareAverage, SmoothImageByGaussianKernel methods)

osmooth texture (SmoothTexture method)

ocreate different filters based on frequency domain transform of an image (CreateFrequencyTransformParams, CreateFrequencyTransformParamsByCharSize and ApplyFrequencyTransform methods)

odetect orientation of the text on an image and rotate an image either by a predefined angle, or by any custom angle (DetectOrientationByText, RotateImageByRotationType, RotateImage methods)

omirror or invert an image (MirrorImage, InvertRegion methods)

ocrop an image (CropImage method)

ofill with color a region on an image (FillRegionWithColor method)

oconvert image to gray or black and white (ConvertToGray, Binarize methods)

oconvert an internal image plane to a bitmap and vice versa (ImageToBitmap and BitmapToImage methods)

Methods

Name | Description
ApplyFrequencyTransform | Applies customizable frequency domain transform. This method can be used to selectively adjust contrast at different levels of detail.
Binarize | Converts an image to black and white.
BitmapToImage | Converts the specified bitmap to the Image object.
ConvertToGray | Converts an image to gray.
CorrectImageGeometry | Corrects image geometry: perspective distortions, curved text lines.
CreateDenoiseFilterParamsByImage | Measures ISO noise on the image and creates the DenoiseFilterParams object based on the measurement.
CreateFrequencyTransformParams | Creates the FrequencyTransformParams object, which has default parameters.
CreateFrequencyTransformParamsByCharSize | Creates the FrequencyTransformParams object and initializes the parameters of the created object with the values, which, when applied, change the image so that the characters of the specified size are recognized better.
CropImage | Crops an image.
DetectEmpty | Detects if the image is empty.
DetectOrientationByText | Detects orientation of an image by text lines.
EqualizeBrightness | Equalizes brightness of an image.
FillRegionWithColor | Fills the specified region with color.
FilterColor | Removes specified color objects from the entire image or its parts.
ImageToBitmap | Converts the Image object to a bitmap.
InvertRegion | Inverts either the specified region on an image or the entire image.
MirrorImage | Mirrors an image either vertically or horizontally.
OpenImageFile | Opens an image file.
OpenImageFileFromStream | Reads an image file from the specified stream.
PreprocessCameraImage | Preprocesses a photo using predefined settings specially designed for different types of photos.
RemoveGarbage | Removes isolated clusters of pixels of the specified size which are considered garbage.
RemoveMotionBlur | Removes motion blur from an image.
RemoveNoise | Removes ISO noise from color photos.
RotateImage | Rotates an image by the specified angle.
RotateImageByRotationType | Rotates an image by a predefined angle (90 degrees clockwise, 90 degrees counterclockwise, upside down).
SmoothImageByGaussianKernel | Smoothes an image by Gaussian kernel.
SmoothImageBySquareAverage | Smoothes the image by averaging over the square neighborhood.
SmoothTexture | Smoothes texture of an image by a nonlinear filter, preserving sharp edges.
StretchImage | Stretches or shrinks the image to the specified size.
StretchTrapezoidToRectangle | Transforms an image so that the specified trapezoid becomes a rectangle. Can be used to manually correct slight perspective distortion.
SuppressColorObjects | Suppresses objects with the specified color in official documents.

Output parameter

This object is the output parameter of the CreateImageProcessingTools method of the Engine object.

Samples

cicon2 C# code

// Sample implementation of a custom image source
class CustomPreprocessingImageSource : IImageSource
{
public CustomPreprocessingImageSource( IEngine engine )
{
fileNames = new Queue();
imageTools = engine.CreateImageProcessingTools();
}
...
// Implementation of the IImageSource::GetNextImage, which uses the ImageProcessingTools object
public IImage GetNextImage()
{
while( true ) {
if( imageFile == null ) {
if( fileNames.Count > 0 ) {
imageFile = imageTools.OpenImageFile( (string)fileNames.Dequeue() );
nextPageIndex = 0;
} else {
return null;
}
}
assert( imageFile != null );
if( nextPageIndex < imageFile.PagesCount ) {
IImage nextPage = imageFile.OpenImagePage( nextPageIndex++ );
// Here you can apply any preprocessing that is necessary
// ...
return nextPage;
} else {
imageFile = null;
continue;
}
}
}
IImageProcessingTools imageTools;
Queue fileNames;
IImageFile imageFile;
int nextPageIndex;
};

See also

Setting Up a Custom Image Source

Creating Filters for Special Image Preprocessing

See sample: FlexiCapture Engine Code Snippets, Color Stamps Removal, Image Preprocessing


ApplyFrequencyTransform Method of ImageProcessingTools Object

ApplyFrequencyTransform Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

ApplyFrequencyTransform Method of the ImageProcessingTools Object

This method applies customizable frequency domain transform. This method can be used to selectively adjust contrast at different levels of detail. See details in Creating Filters for Special Image Preprocessing.

warning Important! This method can be used for color and gray images only.

Syntax

Visual Basic .NET

Function ApplyFrequencyTransform( _
image As Image, _
params As FrequencyTransformParams _
) As Image

C++

HRESULT ApplyFrequencyTransform(
IImage* image,
IFrequencyTransformParams* params,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

params

[in] This parameter of the FrequencyTransformParams type specifies the parameters of frequency domain transform, which should be applied.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the preprocessed image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools

Creating Filters for Special Image Preprocessing


Binarize Method of ImageProcessingTools Object

Binarize Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

Binarize Method of the ImageProcessingTools Object

This method converts an image to black and white.

Syntax

Visual Basic .NET

Function Binarize( _
image As Image, _
mode As BinarizationModeEnum, _
isPhoto As Boolean, _
smoothTexture As Boolean, _
threshold As Int _
) As Image

C++

HRESULT Binarize(
IImage* image,
BinarizationModeEnum mode,
VARIANT_BOOL isPhoto,
VARIANT_BOOL smoothTexture,
int threshold,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be binarized.

mode

[in] Specifies the mode of binarization. See the description of the BinarizationModeEnum constants.

isPhoto

[in] Specifies whether the image is a photo. The value of this parameter can be TRUE, only if the value of the mode parameter is BM_Default or BM_Version9.

smoothTexture

[in] Specifies whether a texture should be smoothed during binarization. The value of this parameter can be TRUE, only if the value of the mode parameter is BM_Default.

threshold

[in] Specifies the threshold for binarization. The parameter is only used if the mode of binarization is BM_ByThreshold. By default, the value of this parameter is 0.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the black-and-white image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


BitmapToImage Method of ImageProcessingTools Object

BitmapToImage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

BitmapToImage Method of the ImageProcessingTools Object

This method converts the specified bitmap to the Image object.

Syntax

C++

HRESULT BitmapToImage(
__int64 hBitmap,
int resolution,
IImage** result
);

C#

Image BitmapToImage(
Int64 hBitmap ,
int resolution
);

Visual Basic .NET

Function BitmapToImage( _
hBitmap As Int64, _
resolution As Int _
) As Image

Parameters

hBitmap

[in] This variable contains the handle of the GDI object (HBITMAP). The handle is passed as __int64. This handle should be available to the process that operates ABBYY FlexiCapture Engine.

resolution

[in] Specifies resolution of the bitmap image.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the internal image plane.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


ConvertToGray Method of ImageProcessingTools Object

ConvertToGray Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

ConvertToGray Method of the ImageProcessingTools Object

This method converts an image to gray.

Syntax

Visual Basic .NET

Function ConvertToGray(image As Image) As Image

C++

HRESULT ConvertToGray(
IImage* image,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be converted.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the created gray image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


CorrectImageGeometry Method of ImageProcessingTools Object

CorrectImageGeometry Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

CorrectImageGeometry Method of the ImageProcessingTools Object

This method corrects image geometry: perspective distortions, curved text lines.

Syntax

Visual Basic .NET

Function CorrectImageGeometry( _
image As Image, _
isPhoto As Boolean, _
) As Image

C++

HRESULT CorrectImageGeometry(
IImage* image,
VARIANT_BOOL isPhoto,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

isPhoto

[in] Specifies whether the image is a photo.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


CreateDenoiseFilterParamsByImage Method of ImageProcessingTools Object

CreateDenoiseFilterParamsByImage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

CreateDenoiseFilterParamsByImage Method of the ImageProcessingTools Object

This method measures ISO noise on the image and creates the DenoiseFilterParams object based on the measurement. The method is primarily designed for the images obtained by a digital camera.

warning Important! This method can be used for color images only.

Syntax

Visual Basic .NET

Function CreateDenoiseFilterParamsByImage( _
image As Image, _
noiseType As NoiseModelTypeEnum, _
averageCharSize As Int _
) As DenoiseFilterParams

C++

HRESULT CreateDenoiseFilterParamsByImage(
IImage* image,
NoiseModelTypeEnum noiseType,
Int averageCharSize,
IDenoiseFilterParams** result
);

Parameters

image

[in] This variable refers to the Image object, which specifies the image to detect noise on.

noiseType

[in] Specifies the type of the noise. It can be either normal, or correlated. See details in the description of the NoiseModelTypeEnum constants.

averageCharSize

[in] Specifies the size of the characters on the image in pixels. For the best recognition quality, select the minimum possible size of characters. If you set this parameter to 0, FlexiCapture Engine will select the gentlest parameters.

result

[out, retval] A pointer to the IDenoiseFilterParams* pointer variable that provides access to the created parameters.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


CreateFrequencyTransformParams Method of ImageProcessingTools Object

CreateFrequencyTransformParams Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

CreateFrequencyTransformParams Method of the ImageProcessingTools Object

This method creates the FrequencyTransformParams object. The newly created object has default parameters.

Syntax

Visual Basic .NET

Function CreateFrequencyTransformParams() As FrequencyTransformParams

C++

HRESULT CreateFrequencyTransformParams( IFrequencyTransformParams** result );

Parameters

result

[out, retval] A pointer to the IFrequencyTransformParams* pointer variable that provides access to the created parameters.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools

Creating Filters for Special Image Preprocessing


CreateFrequencyTransformParamsByCharSize Method of ImageProcessingTools Object

CreateFrequencyTransformParamsByCharSize Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

CreateFrequencyTransformParamsByCharSize Method of the ImageProcessingTools Object

This method creates the FrequencyTransformParams object and initializes the parameters of the created object with the values, which, when applied, change the image so that the characters of the specified size are recognized better.

Syntax

Visual Basic .NET

Function CreateFrequencyTransformParamsByCharSize( _
averageCharSize As Int _
) As FrequencyTransformParams

C++

HRESULT CreateFrequencyTransformParamsByCharSize(
int averageCharSize,
IFrequencyTransformParams** result
);

Parameters

averageCharSize

[in] Specifies the necessary size of characters in pixels. The value of this parameter must be more than 4.

result

[out, retval] A pointer to the IFrequencyTransformParams* pointer variable that provides access to the created parameters.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools

Creating Filters for Special Image Preprocessing


CropImage Method of ImageProcessingTools Object

CropImage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

CropImage Method of the ImageProcessingTools Object

This method crops an image.

Syntax

Visual Basic .NET

Function CropImage( _
image As Image, _
left As Int, _
top As Int, _
right As Int, _
bottom As Int, _
) As Image

C++

HRESULT CropImage(
IImage* image,
int left,
int top,
int right,
int bottom,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

left

[in] Specifies the coordinate of the left border of the resulting image in pixels.

top

[in] Specifies the coordinate of the top border of the resulting image in pixels.

right

[in] Specifies the coordinate of the right border of the resulting image in pixels.

bottom

[in] Specifies the coordinate of the bottom border of the resulting image in pixels.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


DetectEmpty Method of ImageProcessingTools Object

DetectEmpty Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

DetectEmpty Method of the ImageProcessingTools Object

This method detects if the image is empty. You can use empty pages as delimiters, or delete empty pages if they are unnecessary.

Syntax

Visual Basic .NET

Function DetectEmpty( image As Image) As Boolean

C++

HRESULT DetectEmpty(
IImage* image,
VARIANT_BOOL* result
);

Parameters

image

[in] Refers to the Image object, which represents the image.

result

[out, retval] A pointer to a Boolean variable that receives the result of checking. If the value is TRUE, the image is empty.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


DetectOrientationByText Method of ImageProcessingTools Object

DetectOrientationByText Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

DetectOrientationByText Method of the ImageProcessingTools Object

This method detects orientation of an image by text lines. It returns the rotation which must be applied to the image to return it to the normal orientation.

Syntax

Visual Basic .NET

Function DetectOrientationByText( _
image As Image, _
language As Language, _
) As RotationTypeEnum

C++

HRESULT DetectOrientationByText(
IImage* image,
ILanguage* language,
RotationTypeEnum* result
);

Parameters

image

[in] Refers to the Image object which is to be preprocessed.

language

[in] Refers to the Language object which specifies the language of the text on the image.

result

[out, retval] Returns a RotationTypeEnum constant which specifies the rotation that must be applied to the image to return it to the normal orientation.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

To apply the necessary rotation, use the IImageProcessingTools::RotateImageByRotationType method.

See also

ImageProcessingTools


EqualizeBrightness Method of ImageProcessingTools Object

EqualizeBrightness Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

EqualizeBrightness Method of the ImageProcessingTools Object

This method equalizes brightness of an image. The method is primarily designed for preprocessing the images obtained by a digital camera.

warning Important! This method can be used for grey and color images only.

Syntax

Visual Basic .NET

Function EqualizeBrightness(image As Image) As Image

C++

HRESULT EqualizeBrightness(
IImage* image,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


FillRegionWithColor Method of ImageProcessingTools Object

FillRegionWithColor Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

FillRegionWithColor Method of the ImageProcessingTools Object

This method fills the specified region with color.

Syntax

Visual Basic .NET

Function FillRegionWithColor( _
image As Image, _
region As Region, _
color As Int _
) As Image

C++

HRESULT FillRegionWithColor(
IImage* image,
IRegion* region,
int color,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

region

[in] Specifies the region, which is to be filled with color. Refers to the Region object.

color

[in] Specifies the color to be used for filling the region on the image. The Int value is calculated from the RGB triplet using the formula: (red value) + (256 x green value) + (65536 x blue value), where red value is the first triplet component, green value is the second triplet component, blue value is the third triplet component.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


FilterColor Method of ImageProcessingTools Object

FilterColor Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

FilterColor Method of the ImageProcessingTools Object

This method allows you to remove color objects from the image. You can remove red, green, blue, or yellow objects from the entire image or only from some parts of the image - from a specified region, its background, or only stamps and signatures in this region.

warning Important! This method can be used for color images only.

Syntax

Visual Basic .NET

Function FilterColor( _
image As Image, _
region As Region, _
color As ColorToFilterEnum, _
mode As FilterColorModeEnum _
) As Image

C++

HRESULT FilterColor(
IImage* image,
IRegion* region,
ColorToFilterEnum color,
FilterColorModeEnum mode,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

region

[in] This parameter of the Region type specifies the set of rectangles from which to remove objects. This parameter may be 0. In this case color objects are removed from the entire image.

color

[in] This variable of the ColorToFilterEnum type defines the color of the object.

mode

[in] This variable of the FilterColorModeEnum type defines the type of the objects to be removed: objects from the entire image, only background objects, or only color stamps and signatures.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the preprocessed image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools

See sample: Color Stamps Removal


ImageToBitmap Method of ImageProcessingTools Object

ImageToBitmap Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

ImageToBitmap Method of the ImageProcessingTools Object

This method converts the Image object to a bitmap.

Syntax

C++

HRESULT ImageToBitmap(
IImage* image,
IHandle** result
);

C#

Handle ImageToBitmap(
Image image,
);

Visual Basic .NET

Function ImageToBitmap(image As Image) As Handle

Parameters

image

[in] This variable refers to the Image object which should be converted.

result

[out, retval] A pointer to IHandle* pointer variable that can be directly cast to the HBITMAP type.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


InvertRegion Method of ImageProcessingTools Object

InvertRegion Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

InvertRegion Method of the ImageProcessingTools Object

This method inverts either the specified region on an image or the entire image.

Syntax

Visual Basic .NET

Function InvertRegion( _
image As Image, _
region As Region _
) As Image

C++

HRESULT InvertRegion(
IImage* image,
IRegion* region,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

region

[in] Specifies the region, which is to be inverted. Refers to the Region object.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


MirrorImage Method of ImageProcessingTools Object

MirrorImage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

MirrorImage Method of the ImageProcessingTools Object

This method mirrors an image either vertically or horizontally.

Syntax

Visual Basic .NET

Function MirrorImage( _
image As Image, _
mirrorType As MirrorTypeEnum, _
) As Image

C++

HRESULT MirrorImage(
IImage* image,
MirrorTypeEnum mirrorType,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

mirrorType

[in] Specifies whether to mirror the image vertically or horizontally. See the description of the MirrorTypeEnum constants.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


OpenImageFile Method of ImageProcessingTools Object

OpenImageFile Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

OpenImageFile Method of the ImageProcessingTools Object

This method opens the specified image file.

Syntax

Visual Basic .NET

Function OpenImageFile(path As String) As ImageFile

C++

HRESULT OpenImageFile(
BSTR path,
IImageFile** result
);

Parameters

path

[in] This variable specifies the full path to the image file.

result

[out, retval] A pointer to the IImageFile* pointer variable that provides access to the image file.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools

ImageFile

See sample: FlexiCapture Engine Code Snippets, Color Stamps Removal


OpenImageFileFromStream Method of ImageProcessingTools Object

OpenImageFileFromStream Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

OpenImageFileFromStream Method of the ImageProcessingTools Object

This method reads an image file from the specified stream.

Syntax

Visual Basic .NET

Function OpenImageFileFromStream(stream As ReadStream) As ImageFile

C++

HRESULT OpenImageFileFromStream(
IReadStream* stream,
IImageFile** result
);

Parameters

stream

[in] This parameter refers to the IReadStream variable that provides access to a read stream.

result

[out, retval] A pointer to the IImageFile* pointer variable that provides access to the image file.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools

ImageFile


PreprocessCameraImage Method of ImageProcessingTools Object

PreprocessCameraImage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

PreprocessCameraImage Method of the ImageProcessingTools Object

This method preprocesses a photo using predefined settings specially designed for different types of photos.

warning Important! This method can be used for color images only.

Syntax

Visual Basic .NET

Function PreprocessCameraImage( _
image As Image, _
preset As PreprocessCameraImagePresetEnum, _
) As Image

C++

HRESULT PreprocessCameraImage(
IImage* image,
PreprocessCameraImagePresetEnum preset,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

preset

[in] Specifies one of available presets. See the description of the PreprocessCameraImagePresetEnum constants.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


RemoveGarbage Method of ImageProcessingTools Object

RemoveGarbage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

RemoveGarbage Method of the ImageProcessingTools Object

This method removes isolated clusters of pixels of the specified size which are considered garbage.

warning Important! This method can be used for black-and-white images only.

Syntax

Visual Basic .NET

Function RemoveGarbage( _
image As Image, _
garbageSize As Int, _
) As Image

C++

HRESULT RemoveGarbage(
IImage* image,
int garbageSize,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

garbageSize

[in] This variable specifies the maximum area of black dots that are to be considered garbage (in pixels). The default value is 0, which tells FlexiCapture Engine to calculate the size of garbage automatically.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


RemoveMotionBlur Method of ImageProcessingTools Object

RemoveMotionBlur Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

RemoveMotionBlur Method of the ImageProcessingTools Object

This method removes motion blur from an image. The method is primarily designed for preprocessing the images obtained by a digital camera.

warning Important! This method can be used for color and gray images only.

Syntax

Visual Basic .NET

Function RemoveMotionBlur(image As Image) As Image

C++

HRESULT RemoveMotionBlur(
IImage* image,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


RemoveNoise Method of ImageProcessingTools Object

RemoveNoise Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

RemoveNoise Method of the ImageProcessingTools Object

This method removes ISO noise from color photos. The method is primarily designed for preprocessing the images obtained by a digital camera.

warning Important! This method can be used for color images only.

Syntax

Visual Basic .NET

Function RemoveNoise( _
image As Image, _
params As DenoiseFilterParams _
) As Image

C++

HRESULT RemoveNoise(
IImage* image,
IDenoiseFilterParams* params,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

params

[in] This parameter of the DenoiseFilterParams type specifies the parameters of noise detection. This parameter may be 0. In this case the parameters will be detected automatically based on real noise on the image. The parameters, which are selected in automatic mode, are in most cases optimal for the best recognition quality of prepared image.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the preprocessed image. If no noise is detected on the image, the initial image is returned.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


RotateImage Method of ImageProcessingTools Object

RotateImage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

RotateImage Method of the ImageProcessingTools Object

This method rotates an image by the specified angle. The rotation angle (in degrees) is specified by a fraction. For example, fraction 90/1 specifies the angle of 90 degrees, fraction 360/6 specifies the angle of 60 degrees.

Syntax

Visual Basic .NET

Function RotateImage( _
image As Image, _
angleNumerator As Int, _
angleDenominator As Int _
) As Image

C++

HRESULT RotateImage(
IImage* image,
int angleNumerator,
int angleDenominator,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

angleNumerator

[in] Specifies the numerator of the fraction, which represents the rotation angle.

angleDenominator

[in] Specifies the denominator of the fraction, which represents the rotation angle.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


RotateImageByRotationType Method of ImageProcessingTools Object

RotateImageByRotationType Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

RotateImageByRotationType Method of the ImageProcessingTools Object

This method rotates an image by a predefined angle (90 degrees clockwise, 90 degrees counterclockwise, upside down).

Syntax

Visual Basic .NET

Function RotateImageByRotationType( _
image As Image, _
rotation As RotationTypeEnum, _
) As Image

C++

HRESULT RotateImageByRotationType(
IImage* image,
RotationTypeEnum rotation,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

rotation

[in] Specifies one of the predefined rotation angles. See the description of the RotationTypeEnum constants.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


SmoothImageByGaussianKernel Method of ImageProcessingTools Object

SmoothImageByGaussianKernel Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

SmoothImageByGaussianKernel Method of the ImageProcessingTools Object

This method smoothes an image by Gaussian kernel. Gaussian blur is used to reduce image noise and reduce details however preserving edges and boundaries.

warning Important! This method can be used for gray and color images only.

Syntax

Visual Basic .NET

Function SmoothImageByGaussianKernel( _
image As Image, _
sigma As Double, _
) As Image

C++

HRESULT SmoothImageByGaussianKernel(
IImage* image,
double sigma,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

sigma

[in] This variable specifies the standard deviation of Gaussian distribution.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


SmoothImageBySquareAverage Method of ImageProcessingTools Object

SmoothImageBySquareAverage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

SmoothImageBySquareAverage Method of the ImageProcessingTools Object

This method smoothes the image by averaging over the square neighborhood. The method removes sharp differences from the image. It can be useful, for example, if the image contains some noise, i.e. random black dots or speckles. This method should not be used if the lines of letters on the image are thin.

warning Important! This method can be used for gray and color images only.

Syntax

Visual Basic .NET

Function SmoothImageBySquareAverage( _
image As Image, _
squareSize As Int, _
) As Image

C++

HRESULT SmoothImageBySquareAverage(
IImage* image,
int squareSize,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

squareSize

[in] This variable specifies the side of the square neighborhood. Must be an odd number above or equal to 3.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


SmoothTexture Method of ImageProcessingTools Object

SmoothTexture Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

SmoothTexture Method of the ImageProcessingTools Object

This method smoothes texture of an image by a nonlinear filter, preserving sharp edges.

warning Important! This method can be used for gray and color images of not less than 3 pixels in each dimension.

Syntax

Visual Basic .NET

Function SmoothTexture(image As Image) As Image

C++

HRESULT SmoothTexture(
IImage* image,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


StretchImage Method of ImageProcessingTools Object

StretchImage Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

StretchImage Method of the ImageProcessingTools Object

This method stretches or shrinks the image to the specified size.

Syntax

Visual Basic .NET

Function StretchImage( _
image As Image, _
width As Int, _
height As Int, _
newResolution As Int _
) As Image

C++

HRESULT StretchImage(
IImage* image,
int width,
int height,
int newResolution,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

width

[in] Specifies the width of the resulting image.

height

[in] Specifies the height of the resulting image.

newResolution

[in] Specifies the resolution of the resulting image.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


StretchTrapezoidToRectangle Method of ImageProcessingTools Object

StretchTrapezoidToRectangle Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

StretchTrapezoidToRectangle Method of the ImageProcessingTools Object

This method transforms an image so that the specified trapezoid becomes a rectangle. Can be used to manually correct slight perspective distortion.

Syntax

Visual Basic .NET

Function StretchTrapezoidToRectangle( _
image As Image, _
topLeftX As Int, _
topLeftY As Int, _
topRightX As Int, _
topRightY As Int, _
bottomLeftX As Int, _
bottomLeftY As Int, _
bottomRightX As Int, _
bottomRightY As Int, _
resultWidth As Int, _
resultHeight As Int _
) As Image

C++

HRESULT StretchTrapezoidToRectangle(
IImage* image,
int topLeftX,
int topLeftY ,
int topRightX,
int topRightY ,
int bottomLeftX,
int bottomLeftY ,
int bottomRightX,
int bottomRightY ,
int resultWidth,
int resultHeight,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

topLeftX

[in] Specifies the horizontal coordinate of the left top corner of the resulting image on the input image in pixels.

topLeftY

[in] Specifies the vertical coordinate of the left top corner of the resulting image on the input image in pixels.

topRightX

[in] Specifies the horizontal coordinate of the right top corner of the resulting image on the input image in pixels.

topRightY

[in] Specifies the vertical coordinate of the right top corner of the resulting image on the input image in pixels.

bottomLeftX

[in] Specifies the horizontal coordinate of the left bottom corner of the resulting image on the input image in pixels.

bottomLeftY

[in] Specifies the vertical coordinate of the left bottom corner of the resulting image on the input image in pixels.

bottomRightX

[in] Specifies the horizontal coordinate of the right bottom corner of the resulting image on the input image in pixels.

bottomRightY

[in] Specifies the vertical coordinate of the right bottom corner of the resulting image on the input image in pixels.

resultWidth

[in] Specifies the width of the resulting image in pixels. By default, it is -1, which means that the width is detected automatically.

resultHeight

[in] Specifies the height of the resulting image in pixels. By default, it is -1, which means that the height is detected automatically.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


SuppressColorObjects Method of ImageProcessingTools Object

SuppressColorObjects Method of the ImageProcessingTools Object

API Reference > Objects > Image-Related Objects > ImageProcessingTools >

SuppressColorObjects Method of the ImageProcessingTools Object

This method suppresses objects with the specified color in official documents.

The method is primarily designed for filtering color on images of passports and certificates. Such preprocessing allows the program to pick out texts on the images.

warning Important! This method can be used for color images only.

Syntax

Visual Basic .NET

Function SuppressColorObjects( _
image As Image, _
hslHue As Int, _
saturationBoundary As Int, _
) As Image

C++

HRESULT SuppressColorObjects(
IImage* image,
int hslHue,
int saturationBoundary,
IImage** result
);

Parameters

image

[in] This variable refers to the Image object which is to be preprocessed.

hslHue

[in] This parameter specifies the hue, which is to be filtered, in HSL representation. The value of this parameter must be in range from 0 to 255. The value 0 corresponds to red color, 43 — to yellow, 85 — to green, 171 — to blue, 213 — to purple.

saturationBoundary

[in] This variable specifies saturation boundary in HSL representation. The value of this parameter must be in range from 1 to 254. If the saturation value is higher than the value of this parameter, the specified hue will be removed from the image. For example, for passports the value in range from 25 to 35 is suitable.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the resulting image.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageProcessingTools


DenoiseFilterParams Object

DenoiseFilterParams Object (IDenoiseFilterParams Interface)

API Reference > Objects > Image-Related Objects >

DenoiseFilterParams Object (IDenoiseFilterParams Interface)

This object contains parameters of the ISO noise detected on a color photo. The object provides no methods or properties for tuning these parameters. All parameters are defined during object creation on the base of the specified parameters and the image, which was used during creation. If no noise is detected, the object has the IsNoiseDetected property set to FALSE.

The scenario of the object usage:

1.Create the object using the CreateDenoiseFilterParamsByImage method of the ImageProcessingTools object based on the specified parameters.

2.Check the value of the IsNoiseDetected property of the created object. If it is FALSE, then no noise is detected and there is no need to remove it.

3.If some noise has been detected, remove it — pass the created object to the RemoveNoise method of the ImageProcessingTools object.

Properties

Name | Type | Description
IsNoiseDetected | Boolean, read-only | Specifies whether ISO noise has been detected on an image.

Output parameter

This object is the output parameter of the CreateDenoiseFilterParamsByImage method of the ImageProcessingTools object.

Input parameter

This object is the input parameter of the RemoveNoise method of the ImageProcessingTools object.

See also

ImageProcessingTools


FrequencyTransformParams Object

FrequencyTransformParams Object (IFrequencyTransformParams Interface)

API Reference > Objects > Image-Related Objects >

FrequencyTransformParams Object (IFrequencyTransformParams Interface)

This object contains parameters of frequency domain transform, which can be used for image modification. This object provides a universal instrument for image modification. It allows you to create different image filters based on frequency domain transform.

Let's see how frequency domain transform is performed:

1.An image is split on several layers of different level of detail. At the first level there are separate pixels. At each next level the size of details is doubled. The number of levels is specified in the NumberOfLevels property.

2.For each level, either the operation of multiplication on some coefficient, or the operation of autocontrast is applied. Which operation should be applied is specified in the Type property. The coefficient of multiplication or of autocontrast is specified in the CoefficientAtLevel property.

3.Then the layers are put together again.

The frequency domain transform can be used to equalize brightness of the image, extract background layer, pull out characters of specified size. See details in Creating Filters for Special Image Preprocessing.

Properties

Name | Type | Description
CoefficientAtLevel | Double | Specifies the coefficient that is applied at the given level of detail. It can be any value in range from 0.0 to 1.0. For autocontrast operation, the value 0.0 does not change the level, the value 1.0 means maximum contrast of the level. For multiplication operation, the value 0.0 removes all details of the level (maximum smoothness), the value 1.0 does not change the level. By default, the value of the property is 1.0.
NumberOfLevels | Int | Specifies the number of levels of detail that should be extracted. You can select the number of levels depending on the size of your image and the size of details you want to capture. The number of levels cannot be more than 10. By default, the value of this property is 4.
Type | FrequencyTransformTypeEnum | Specifies the transformation type. If you want to smooth out details of some size, you should select operation of multiplication. If you want to pull out some details, select operation of autocontrast. By default, the value of this property is FTT_MultiplyByCoefficient.

Output parameter

This object is the output parameter of the CreateFrequencyTransformParams, CreateFrequencyTransformParamsByCharSize methods of the ImageProcessingTools object.

Input parameter

This object is the input parameter of the ApplyFrequencyTransform method of the ImageProcessingTools object.

See also

ImageProcessingTools

Creating Filters for Special Image Preprocessing


CoefficientAtLevel Property of FrequencyTransformParams Object

CoefficientAtLevel Property of the FrequencyTransformParams Object

API Reference > Objects > Image-Related Objects > FrequencyTransformParams >

CoefficientAtLevel Property of the FrequencyTransformParams Object

This property specifies the coefficient that is applied at the given level of detail. It can be any value in range from 0.0 to 1.0. For autocontrast operation, the value 0.0 does not change the level, the value 1.0 means maximum contrast of the level. For multiplication operation, the value 0.0 removes all details of the level (maximum smoothness), the value 1.0 does not change the level.

Syntax

Visual Basic .NET

Property CoefficientAtLevel(Level As Int) As Double

C++

HRESULT get_CoefficientAtLevel(
int Level,
double* Result
);
HRESULT put_CoefficientAtLevel(
int Level,
double Value
);

Parameters

Level

[in] This parameter specifies the level of detail. The value of this parameter should be in range from 0 to the value of the IFrequencyTransformParams::NumberOfLevels property minus 1.

Result

[out, retval] A pointer to double variable that receives the value of this property.

Value

[in] A double variable that contains the new value for the property.

Return values

This property has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

FrequencyTransformParams


ImageFile Object

ImageFile Object (IImageFile Interface)

API Reference > Objects > Image-Related Objects >

ImageFile Object (IImageFile Interface)

This object represents an image file. It contains information on the number of pages in the image file and provides access to the page with the specified index. The methods provided by this object can be used when implementing a custom image source for the FlexiCapture processor.

Properties

Name | Type | Description
PagesCount | Int, read-only | Specifies the number of pages in the image file. The value of this property can be more than 1 for multi-page file formats.

Methods

Name | Description
Close | Releases the image file.
OpenImagePage | Opens a page of the image by the page index.

Output parameter

This object is the output parameter of the OpenImageFile and OpenImageFileFromStream methods of the ImageProcessingTools object.

See also

ImageProcessingTools

Setting Up a Custom Image Source

See sample: FlexiCapture Engine Code Snippets, Color Stamps Removal


Close Method of the ImageFile Object

API Reference > Objects > Image-Related Objects > ImageFile >

Close Method of the ImageFile Object

This method reclaims the memory occupied by the images releasing the image files and their possession. The method is used in those programming languages in which the garbage collector call may be postponed.

Syntax

Visual Basic .NET

Sub Close()

C++

HRESULT Close();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageFile


OpenImagePage Method of ImageFile Object

OpenImagePage Method of the ImageFile Object

API Reference > Objects > Image-Related Objects > ImageFile >

OpenImagePage Method of the ImageFile Object

This method opens the specified page of the image file.

Syntax

Visual Basic .NET

Function OpenImagePage(pageIndex As Int) As Image

C++

HRESULT OpenImagePage(
int pageIndex,
IImage** result
);

Parameters

pageIndex

[in] This variable specifies the index of an image page in the file.

result

[out, retval] A pointer to the IImage* pointer variable that provides access to the image page.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ImageFile

See sample: FlexiCapture Engine Code Snippets, Color Stamps Removal


Errors Objects

API Reference > Objects >

Errors Objects

When a Document Definition is matched, pages are assembled into documents, then the document is recognized and rules, imposed on data by the document definition, are applied to the fields, found in the document. The errors, which appear during assembling pages into documents are called assembling errors and represented by the AssemblingError objects. The errors, which appear when rules are applied to the document fields, called rule errors and are represented by the RuleError objects.

This section describes the following objects which provide access to errors occurred during document processing:

·AssemblingErrors

·AssemblingError

·RuleErrors

·RuleError

·Rule

The hierarchy of the objects


AssemblingErrors Object

AssemblingErrors Object (IAssemblingErrors Interface)

API Reference > Objects > Errors Objects >

AssemblingErrors Object (IAssemblingErrors Interface)

This object represents a collection of assembling errors. To access the assembly errors of the certain document, use the AssemblingErrors property of the corresponding Document object.

The AssemblingErrors object is a so-called "connectable object". The methods of the AssemblingErrors object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | AssemblingError, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

See also

AssemblingError

Document

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties


AssemblingError Object

AssemblingError Object (IAssemblingError Interface)

API Reference > Objects > Errors Objects >

AssemblingError Object (IAssemblingError Interface)

This object corresponds to an assembly error. The document assembly rule is configured when creating a Document Definition: it defines the sequence and number of recurring document sections. Assembly verification based on the values of key fields can also be required: in this case the values of key fields must be identical on all pages of the document.

Assembly errors can be caused by the following reasons:

·Incorrect page sequence in a document

There may be too few or too many pages, or document pages are not arranged in the correct sequence. To receive a tip, use the Text property. To correct such error you can use the MoveByID, Merge, and Disassemble methods of the Documents object.
note Note: The Documents object is deprecated and will be removed in future versions.

·Key values are not identical on all pages of the document

If the Document Definition requires verification of key fields for correct assembly of pages, the values of key fields will be placed in the IPage::KeyValue property of each page. Key fields may not match if they have been recognized or filled in incorrectly. Check the values of key fields. If the values of key fields still do not match, it is likely that such pages do not belong to the same document. If the page sequence is wrong, find pages with identical key fields and assemble them into documents as described above.

Properties

Name | Type | Description
MissingPageDefinitionID | Int, read-only | Specifies the identifier of the Document Definition for which the page was not found in the document.
PageIndex | Int, read-only | Returns the index of the missed or excess page.
Text | String, read-only | Stores the error description.
Type | AssemblingErrorTypeEnum, read-only | Specifies the type of assembly error.

Related objects

Output parameter

This object is the output parameter of the Item method of the AssemblingErrors object.

See also

AssemblingErrors

Working with Properties


RuleErrors Object

RuleErrors Object (IRuleErrors Interface)

API Reference > Objects > Errors Objects >

RuleErrors Object (IRuleErrors Interface)

This object represents a collection of rule errors. To access the errors of the certain document, use the RuleErrors property of the corresponding Document object.

The RuleErrors object is a so-called "connectable object". The methods of the RuleErrors object report information about the collection modification through special outgoing interfaces. These interfaces are ICollectionEvents (for C++) and the dispinterface DICollectionEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | RuleError, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

See also

RuleError

Working with Collections

ICollectionEvents

Working with Connectable Objects

Working with Properties


RuleError Object

RuleError Object (IRuleError Interface)

API Reference > Objects > Errors Objects >

RuleError Object (IRuleError Interface)

This object corresponds to a rule error. Rules are certain conditions imposed on data in fields. If the values in documents do not meet these conditions, rule errors appear. The main purpose of rule application is to check the integrity of document data. All rule errors of a document are represented by the RuleErrors object.

Properties

Name | Type | Description
Context | Field, read-only | Specifies the field which was used as the context of the rule during rule checking.
Fields | Fields | Returns a collection of checked fields.
FieldToFocus | Field, read-only | Specifies the field to put focus on.
IsFormatError | Boolean, read-only | Specifies whether the error is a format error. Data entry fields usually require data in special format as their input values. If during document processing the recognized field value does not match the set data type, the rule error is generated, and this property for corresponding rule error returns TRUE.
Rule | Rule, read-only | Specifies the rule which produced the error. The value of this property may be 0, if the value of the IsFormatError property is TRUE.
Severity | RuleErrorSeverityEnum, read-only | Specifies the severity of the error.
Text | String, read-only | Stores the text description of the error.

Related objects

Output parameter

This object is the output parameter of the Item method of the RuleErrors object.

See also

RuleErrors

Working with Properties


Rule Object

Rule Object (IRule Interface)

API Reference > Objects > Errors Objects >

Rule Object (IRule Interface)

This object corresponds to a rule. Rules are certain conditions imposed on data in fields. If the values in documents do not meet these conditions, rule errors appear. The main purpose of rule application is to check the integrity of document data.

Properties

Name | Type | Description
Name | String, read-only | Returns the rule name.

Related objects

See also

RuleError

Working with Properties


Import Parameters Objects

API Reference > Objects >

Import Parameters Objects

Parameters of image import are defined in FlexiCapture project and can be set unique for all images or different for images from different folders (hot folders).

This section describes the following objects which provide access to parameters of image import:

·HotFolderProfiles (deprecated)

·HotFolderProfile (deprecated)

·ScanningProfiles (deprecated)

·ScanningProfile (deprecated)

·ImageImportParams (deprecated)

·ImageLoadingParams

·ImageGroupingParams (deprecated)

The hierarchy of the objects


HotFolderProfiles Object

HotFolderProfiles Object (IHotFolderProfiles Interface)

API Reference > Objects > Import Parameters Objects >

HotFolderProfiles Object (IHotFolderProfiles Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object represents a collection of hot folder profiles. When editing the project in ABBYY FlexiCapture, you can create a number of hot folder profiles of the project and then switch easily between them during image import. To access the hot folder profiles of the certain project, use the HotFolderProfiles property of the corresponding ProjectProperties object.

warning Important! The collection is read-only. Project import settings can be edited in ABBYY FlexiCapture but are read-only in ABBYY FlexiCapture Engine.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | HotFolderProfile, read-only | Provides access to a single element of the collection.

Methods

Name | Description
AddNew | Adds a new element at the end of the collection. warning Important! The method is deprecated and will be removed in future versions. This is due to the fact that it does not work properly: the project import settings can be edited in ABBYY FlexiCapture but are read-only in ABBYY FlexiCapture Engine.
DeleteAt | Removes an element from the collection. warning Important! The method is deprecated and will be removed in future versions. This is due to the fact that it does not work properly: the project import settings can be edited in ABBYY FlexiCapture but are read-only in ABBYY FlexiCapture Engine.
Item | Provides access to a single element of the collection.

Related objects

See also

HotFolderProfile

ProjectProperties

Working with Properties

Working with Collections


AddNew Method of the HotFolderProfiles Object

API Reference > Objects > Import Parameters Objects > HotFolderProfiles >

AddNew Method of the HotFolderProfiles Object

warning Important! The method is deprecated and will be removed in future versions. This is due to the fact that it does not work properly: the project import settings can be edited in ABBYY FlexiCapture but are read-only in ABBYY FlexiCapture Engine.

This method adds a hot folder profile with the specified name at the end of the collection.

Syntax

Visual Basic .NET

Function AddNew( _
Name As String, _
Folder As String _
) As HotFolderProfile

C++

HRESULT AddNew(
BSTR Name,
BSTR Folder,
IHotFolderProfile** Result
);

Parameters

Name

[in] This variable contains the name of the profile.

Folder

[in] This variable specifies the path to the hot folder.

Result

[out, retval] A pointer to the IHotFolderProfile* variable that receives the interface pointer for the added profile.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

HotFolderProfiles


HotFolderProfile Object

HotFolderProfile Object (IHotFolderProfile Interface)

API Reference > Objects > Import Parameters Objects >

HotFolderProfile Object (IHotFolderProfile Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object represents a hot folder import profile. Import profiles are created for convenience and to streamline the work. They allow you to select the import source and configure settings easily.

Properties

Name | Type | Description
CheckPeriod | Int | Specifies the time interval in seconds for checking the hot folder for new images.
CreateNewBatches | Boolean | Specifies if new batches for the images should be created. If the value of this property is FALSE, the images will be added to an existing batch.
DeleteProcessedImages | Boolean | Specifies if the processed images should be deleted. If the value of this property is FALSE, the images are moved to the folder specified by the ProcessedImagesFolder property.
ExceptionsFolder | String | Specifies the path to the folder for invalid images (for example, images in unsupported format).
InputFolder | String | Specifies the path to the hot folder.
ImageImportParams | ImageImportParams, read-only | Specifies the parameters of images import.
MaximumImagesPerBatch | Int | Specifies the maximum number of images in the newly created batch. The property is only available if the CreateNewBatches property is set to TRUE.
MaximumWaitPeriod | Int | Specifies the maximum time interval in seconds after which a new batch will be created.
MinimumImagesPerBatch | Int | Specifies the minimum number of images in the newly created batch. The property is only available if the CreateNewBatches property is set to TRUE.
ProcessedImagesFolder | String | Specifies the path to the folder for processed images.

Related objects

Output parameter

This object is the output parameter of the Item, AddNew methods of the HotFolderProfiles object.

See also

HotFolderProfiles

Working with Properties


ScanningProfiles Object

ScanningProfiles Object (IScanningProfiles Interface)

API Reference > Objects > Import Parameters Objects >

ScanningProfiles Object (IScanningProfiles Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object represents a collection of scanning profiles. You can create a number of scanning profiles and then switch easily between them during scanning.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | ScanningProfile, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

Output parameter

The object is the output parameter of the CreateScanningProfiles method of the Engine object.

See also

ScanningProfile


ScanningProfile Object

ScanningProfile Object (IScanningProfile Interface)

API Reference > Objects > Import Parameters Objects >

ScanningProfile Object (IScanningProfile Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object represents a scanning import profile. Import profiles are created for convenience and to streamline the work. They allow you to select the import source and configure settings easily.

Properties

Name | Type | Description
ImageImportParams | ImageImportParams, read-only | Specifies the parameters of images import.

Related objects

Output parameter

The object is the output parameter of the IScanningProfiles::Item method.

Input parameter

The object is the input parameter of the IBatch::Scan method.

See also

ScanningProfiles


ImageImportParams Object

ImageImportParams Object (IImageImportParams Interface)

API Reference > Objects > Import Parameters Objects >

ImageImportParams Object (IImageImportParams Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object allows you to tune the parameters of images import: image loading and grouping parameters. A pointer to this object can be passed to the IProject::ImportImages method as an input parameter, and thus affects the results of import. The parameters are also used in import profiles.

Properties

Name | Type | Description
ImageGroupingParams | ImageGroupingParams | Specifies the parameters of grouping images into documents.
ImageLoadingParams | ImageLoadingParams | Specifies the parameters of image preprocessing.

Related objects

Input parameter

This object is the input parameter of the ImportImages method of the Project object.

See also

HotFolderProfile

Working with Properties


ImageLoadingParams Object

ImageLoadingParams Object (IImageLoadingParams Interface)

API Reference > Objects > Import Parameters Objects >

ImageLoadingParams Object (IImageLoadingParams Interface)

This object contains different attributes specifying how an image will be prepared for recognition. Images can be prepared before processing via the FlexiCapture processor. The following transformations can be performed upon the prepared image with the help of the ImageLoadingParams object: image rotation, image mirroring, cleaning up from noise, resolution correction, skew correction, etc.

Properties

Name

Type

Description

CorrectSkewByBlackSeparators

Boolean

Specifies if the image skew angle is to be corrected based on black separators. Black separator is either a horizontal or a vertical black line on image.

The default value of this property is TRUE.

CorrectSkewByBlackSquares

Boolean

Specifies if the image skew angle is to be corrected based on so-called "black squares". Black squares are often placed on forms. It is recommended to set this property to TRUE only when working with images of forms, otherwise you may obtain incorrect results.

The default value of this property is TRUE.

CorrectSkewByText

Boolean

Specifies if the image skew angle is to be corrected based on text lines.

The default value of this property is TRUE.

DiscardImageColor

Boolean

Specifies whether color and gray images should be converted to black and white.

The default value of this property is FALSE.

ImageRotation

RotationTypeEnum

Specifies the rotation type to be applied to an image during loading.

By default the value of this property is RT_NoRotation.

InvertImage

Boolean

Specifies if image colors should be inverted.

The default value of this property is FALSE.

MirrorImage

Boolean

Specifies if an image should be mirrored.

The default value of this property is FALSE.

OverwriteResolution

Boolean

Allows you to overwrite resolution of the prepared image. The resolution is overwritten depending on the values of the XResolutionToOverwrite and YResolutionToOverwrite properties. In this case the new resolution will be used for image preprocessing (i.e. for binarization, deskewing, etc.). See also IImageDocument::ChangeResolution.

By default, this property is set to FALSE.

ReduceISONoise

Boolean

Specifies if noise in high-ISO images should be reduced.

By default, this property is set to FALSE.

RemoveColorMarks

Boolean

Specifies if the color marks, such as stamps or signatures made with colored ink, should be removed from the image.

By default, this property is set to FALSE.

RemoveGarbage

Boolean

Specifies if small garbage (excess dots that are smaller than a certain size) should be removed from a loading image.

By default, this property is set to FALSE.

SourceContentReuseMode

SourceContentReuseModeEnum

Specifies the mode of source PDF file contents reusing.

By default, this property is set to CRM_Auto.

TreatImageAsPhoto

Boolean

Specifies whether the processing image should be treated as a photo.

By default, this property is set to FALSE.

UseAutocrop

Boolean

Specifies if the image should be automatically cropped. If this property is set to TRUE:

·image boundaries will be found

·the area that contains data for extraction will be cropped

·skews and distortions will be corrected.

By default, this property is set to FALSE.

UsePdfTextLayerOnly

Boolean

For input PDF files, specifies if the text layer should be used as is without recognizing the page image.

The default value of this property is FALSE, which means that the text layer is taken into account where it exists, but some pages or areas may be re-recognized for better result quality.

note Note:

·The property is deprecated. Use the SourceContentReuseMode property to set the mode of source PDF file contents reusing.

WhitenBackground

Boolean

Specifies if the background of the image should be whitened.

By default, this property is set to FALSE.

XResolutionToOverwrite

Int

Specifies the horizontal resolution of the original image in dpi. This value is used to overwrite resolution of the prepared image when resolution of the original image is not specified or incorrect and only if the OverwriteResolution property is TRUE. ABBYY FlexiCapture Engine works with the prepared image which horizontal and vertical resolutions are equal, therefore the program stretches the image so that the horizontal and vertical resolutions of the prepared image are identical and equal to the maximum of XResolutionToOverwrite and YResolutionToOverwrite.

By default, this property is set to 300.

YResolutionToOverwrite

Int

Specifies the vertical resolution of the original image in dpi. This value is used to overwrite resolution of the prepared image when resolution of the original image is not specified or incorrect and only if the OverwriteResolution property is TRUE. ABBYY FlexiCapture Engine works with the prepared image which horizontal and vertical resolutions are equal, therefore the program stretches the image so that the horizontal and vertical resolutions of the prepared image are identical and equal to the maximum of XResolutionToOverwrite and YResolutionToOverwrite.

By default, this property is set to 300.

Methods

Name | Description
CopyFrom | Initializes properties of the current object with values of similar properties of another object.

Related objects

Output parameter

This object is the output parameter of the CreateImageLoadingParams method of the Engine object.

Input parameter

This object is the input parameter of the following methods:

·SetImageLoadingParams method of the FlexiCaptureProcessor object

·AddImages method of the Batch object (deprecated)

See also

Working with Properties


ImageGroupingParams Object

ImageGroupingParams Object (IImageGroupingParams Interface)

API Reference > Objects > Import Parameters Objects >

ImageGroupingParams Object (IImageGroupingParams Interface)

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This object allows you to tune the parameters that determine the principles of adding images to documents. To configure image grouping parameters, set the GroupingRule property. Subsequent settings depend on the value selected for this property. By default every image page is added to separate document.

Properties

Name | Type | Description
BarcodeType | BarcodeTypeEnum | Specifies the barcode type which should be used for image grouping. The value of this property is used only if the GroupingRule property is set to PG_GroupPagesByBarcode. By default the value of this property is BT_UnknownType.
BarcodeValue | String | Specifies the value of the barcode which should be used for image grouping. The value of this property is used only if the GroupingRule property is set to PG_GroupPagesByBarcode. The default value of this property is an empty string.
DeleteDelimiters | Boolean | Specifies whether delimiters (blank pages or barcode pages) should be deleted after image grouping. The value of this property is used only if the GroupingRule property is set to PG_GroupPagesByEmptyPageDelimiters or PG_GroupPagesByBarcode. By default the value of this property is FALSE.
GroupingRule | PagesGroupingEnum | Specifies the rule of grouping images into documents. By default the value of this property is PG_GroupPagesByPagesCount.
PagesCount | Int | Specifies the number of pages in a document. The value of this property is used only if the GroupingRule property is set to PG_GroupPagesByPagesCount. By default the value of this property is 1.

Methods

Name | Description
CopyFrom | Initializes properties of the current object with values of similar properties of another object.

Related objects

Remarks

Here are some tips on how to use a barcode page to separate the image flow into documents:

1.When adding your images for processing, make sure that between every two documents is inserted a special page containing barcodes only and no relevant information. You can see an example of such page in SampleImages folder (located in the Code Samples Folder).

2.Set the GroupingRule property of this object to PG_GroupPagesByBarcode and specify the type of the barcode you use in the BarcodeType property or the value of the barcode you use in the BarcodeValue property.

3.To delete the separator pages after the grouping set the DeleteDelimiters property to TRUE.

The notes above describe just one of the possible uses of this object.

Output parameter

This object is the output parameter of the CreateImageGroupingParams method of the Engine object.

Input parameter

This object is the input parameter of the AddImages method of the Batch object.

See also

ImageImportParams

Working with Properties


Export Parameters Objects

API Reference > Objects >

Export Parameters Objects

Parameters of export of a recognized document are defined in the document definition or directly in the function, which is used for export. The object, which provides access to the parameters of export, is the ExportParams object. It contains a set of child object, which allows you to tune the parameters of export to different file formats.

This section describes the following objects which provide access to parameters of export:

·ExportParams

·FileExportParams

·DBFExportParams

·ExcelExportParams

·ImageExportParams

·TextExportParams

·XMLExportParams

You can find additional information in the Tuning Export Parameters section.

The hierarchy of the objects


ExportParams Object

ExportParams Object (IExportParams Interface)

API Reference > Objects > Export Parameters Objects >

ExportParams Object (IExportParams Interface)

This object provides functionality for tuning the parameters of export. Currently only export to file is supported (only the EDT_File value of the DestinationType property can be used). Subsequent settings of export to file are available through the FileExportParams property.

A pointer to this object can be passed to the IBatch::Export or IProject::Export method as an input parameter, and thus affects the results of export. Besides you can configure export for the project using the ExportParams property of the ProjectProperties object, or set export parameters for documents to which certain document definition is applied with the help of the IDocumentDefinition::ExportParams property.

warning Important! Please take into account that Batch and Project objects are deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Properties

Name | Type | Description
DestinationType | ExportDestinationTypeEnum, read-only | Specifies the destination of the output documents.
FileExportParams | FileExportParams, read-only | Specifies the parameters of export to file.
IgnoreRuleErrors | Boolean | Specifies whether critical rule errors should be ignored. If the value of this property is FALSE, export will not be performed if there are any rule errors with the RES_CriticalError value of the Severity property. By default, this property is set to FALSE.

Methods

Name | Description
CopyFrom | Initializes properties of the current object with values of similar properties of another object.

Related objects

Output parameter

This object is the output parameter of the CreateExportParams method of the Engine object.

Input parameter

This object is the input parameter of the following methods:

·Export method of the Batch object

·Export method of the Project object

Remarks

The properties of the object can not be edited after creation. To edit the property create a new ExportParams object, set the values of the properties using the ExportParams::CopyFrom method and modify the necessary value.

See also

Tuning Export Parameters

ProjectProperties

DocumentDefinition

Working with Properties

See sample: Redaction


FileExportParams Object

FileExportParams Object (IFileExportParams Interface)

API Reference > Objects > Export Parameters Objects >

FileExportParams Object (IFileExportParams Interface)

This object provides functionality for tuning the parameters of export to file.

You can set general export properties:

·the path to the folder for output files (the RootPath property),

·the file naming rule (the FileNamePattern property).

For selected export file format (the FileFormat property) you can tune parameters of saving files in this format, use the TextParams, ImageExportParams, DBFParams, ExcelParams, and XMLParams properties.

Properties

Name

Type

Description

ColumnSeparator

String

Specifies the symbol which should be used for splitting recognized text into columns when exporting tables. By default the comma "," is used.

CreateSeparateFilesForRepeatableItems

Boolean

If this property is set to TRUE, repeating fields (i.e. fields with multiple instances and tables) are exported into separate files for which a new folder is created. The name of the folder consists of the name of the export file. To disable export of repeating fields into separate files, set this property to FALSE. In this case, ABBYY FlexiCapture Engine will export all repeating fields to one export file and will add a new line for each element instance. The value of this property is TRUE by default.

DBFParams

DBFExportParams, read-only

Specifies parameters of export to DBF format. The property is used only if the value of the FileFormat property is FEF_DBF.

ExcelParams

ExcelExportParams, read-only

Specifies parameters of export to XLS format. The property is used only if the value of the FileFormat property is FEF_XLS.

ExportFieldNames

Boolean

Specifies if field names should be exported. The value of this property is TRUE by default.

ExportOriginalImages

Boolean

Specifies if original images should be exported. To set the parameters of image export use the ImageExportParams property. The default value of this property is FALSE.

FileFormat

FileExportFormatEnum

Specifies the output file format. By default the value of this property is FEF_XLS.

FileNamePattern

String

Specifies the output file name. You can include the following items into the resulting file name:

·<Project> — the project name (IProject::Title)(deprecated)

·<Batch> — the batch name (IBatch::Title)(deprecated)

·<DocumentDefinition> — the Document Definition name (IDocumentDefinition::Name)

·<SourceFile> — the name of the source file (IPage::OriginalImagePath)

·<Identifier> — the identifier of the document (IDocument::ID)

·<BatchType> — the type of the batch (batch types are defined in ABBYY FlexiCapture for the most commonly used sets of processing settings)(deprecated)

·<Time> — the time of export

·<Index:FieldName> — the value of the index field (fields whose values are used for sorting and search purposes, such fields have "Index field" property in the ABBYY FlexiCapture project). Replace FieldName with the name of the suitable field.

·<RegParam:ParameterName> — the value of the registration parameter (registration parameters are textual properties allowing to identify a specific batch or document, they are set in ABBYY FlexiCapture). Replace ParameterName with the name of the suitable registration parameter.(deprecated)

The elements in angle brackets will be changed to corresponding values. The elements without angle brackets will be passed as is. By default the following pattern is used: "<Batch>".

FileOverwriteRule

FileOverwriteRuleEnum

Specifies the rule to be used for overwriting files. By default the value of this property is FOR_Append.

ImageExportParams

ImageExportParams, read-only

Specifies parameters of image export to PDF, TIFF, JPEG, and other image formats. The property is used only if the value of the ExportOriginalImages property is TRUE.

RootPath

String

Specifies the root folder for output files. The property may contain the full path to the folder or the relative path from the FlexiCapture project folder. If you are working with FlexiCaptureProcessor, you must specify the full path in this property.

warning Important! Working with projects in ABBYY FlexiCapture Engine 12 is deprecated and will be removed in future versions. It is strongly recommended that you use FlexiCapture Processor and its functionality in your scenarios.

By default the value of this property is "Export".

RowSeparator

String

Specifies the symbol which should be used for splitting recognized text into rows when exporting tables. By default the value of this property is "\r\n".

TextParams

TextExportParams, read-only

Specifies parameters of text export.

XMLParams

XMLExportParams, read-only

Specifies parameters of export to XML format. The property is used only if the value of the FileFormat property is FEF_XML.

Output parameter

This object is the output parameter of the CreateFileExportParams method of the Engine object.

Input parameter

This object is the input parameter of the ExportDocumentEx and ExportDocumentToMemory method of the FlexiCaptureProcessor object.

Related objects

See also

ExportParams

Tuning Export Parameters

Working with Properties

See sample: FlexiCapture Engine Code Snippets, Redaction


DBFExportParams Object

DBFExportParams Object (IDBFExportParams Interface)

API Reference > Objects > Export Parameters Objects >

DBFExportParams Object (IDBFExportParams Interface)

This object provides functionality for tuning the parameters of recognized text export to DBF format. These parameters are set in the DBFParams property of the FileExportParams object.

Properties

Name | Type | Description
CodePage | CodePageEnum | Specifies the code page to which the recognized text is exported. The code page type which is used for DBF format is OEM. If this property does not specify any code page (CP_Null), the code page is selected automatically. By default the value of this property is CP_Null.
DBFVersion | DBFVersionEnum | Specifies the DBF format version. The value of this property is DBFV_Version3 by default.
PreserveValueTypes | Boolean | Specifies whether types of values are to be preserved. If the value of this property is FALSE, all data will be exported as General. By default the value of this property is TRUE.

Related objects

See also

FileExportParams

Tuning Export Parameters

Working with Properties


ExcelExportParams Object

ExcelExportParams Object (IExcelExportParams Interface)

API Reference > Objects > Export Parameters Objects >

ExcelExportParams Object (IExcelExportParams Interface)

This object provides functionality for tuning parameters of recognized text export to XLS format. These parameters are set in the ExcelExportParams property of the FileExportParams object.

Properties

Name | Type | Description
XLFileFormat | XLFileFormatEnum | Determines how recognized text will be exported to XLS format. It may be set to MS Excel 5, MS Excel 8, or both. By default the value of this property is XLFF_BIFF8.
PreserveValueTypes | Boolean | Specifies whether types of values are to be preserved. If the value of this property is FALSE, all data will be exported as General. By default the value of this property is TRUE.

Related objects

See also

FileExportParams

Tuning Export Parameters

Working with Properties


ImageExportParams Object

ImageExportParams Object (IImageExportParams Interface)

API Reference > Objects > Export Parameters Objects >

ImageExportParams Object (IImageExportParams Interface)

This object provides functionality for tuning parameters of original images export. These parameters are set in the ImageExportParams property of the FileExportParams object.

Properties

Name

Type

Description

ColorType

ImageColorTypeEnum

Specifies the color type of images (color, gray, or black-and-white).

note Note: Format, ColorType and CompressionType properties are related. See the list of supported combinations below.

By default the value of this property is ICT_BlackWhite.

CompressionRatio

Int

Specifies the compression ratio for images in JPEG format. The value of this property is in range from 1 to 100.

The default value of this property is 75.

CompressionType

ImageCompressionTypeEnum

Specifies the image compression type.

note Note: This property is useful only when the Format property is set to IFF_Tif. For other export formats it is recommended to keep CompressionType default. See the list of supported Format, ColorType and CompressionType combinations below.

The default value of this property is ICT_Default.

CreatePDFA

Boolean

Specifies if a PDF/A file is to be created. PDF/A mode can be defined using the PdfAMode property.

The property is valid only if the Format property is set to IFF_Pdf.

The default value of this property is FALSE.

CreateSearchablePDF

Boolean

Specifies if a searchable PDF file is to be created. The entire image is saved as a picture. The recognized text is put under it. This option is useful if you export your text to document archives: the full page layout is retained and the full-text search is available if you save in this mode.

The property is valid only if the Format property is set to IFF_Pdf.

The default value of this property is FALSE.

EnableFastWebView

Boolean

Specifies if the Fast Web View should be enabled.

note Note: Fast Web View setting provides a page-at-a-time downloading of the PDF document from web servers. This can be especially important when loading large documents because otherwise it can take a long time to download them from a server.

The property is valid only if the Format property is set to IFF_Pdf.

The default value of this property is FALSE.

FileAssemblingRule

ImageFileAssemblingRuleEnum

Specifies the assembling rules for saving images.

The default value of this property is IFAR_FilePerDocument.

Format

ImageFileFormatEnum

Specifies the file format to save images in.

note Note: Format, ColorType and CompressionType properties are related. See the list of supported combinations below.

By default the value of this property is IFF_Tif.

MRCPicturesInBackground

Boolean

Specifies if the pictures should be saved as a part of the background when using MRC compression.

The property is valid only if the UseMRCCompression property is set to TRUE.

The default value of the property is FALSE.

OverwriteFiles

Boolean

This property is not used and will be removed in future versions. Overwriting of the original image can be tuned with the FileOverwriteRule property of the FileExportParams.

If the value of this property is TRUE, the original image files will be overwritten.

The default value of this property is FALSE.

Path

String

Specifies the folder for saved image files.

By default the value of this property is an empty string.

PdfAMode

PdfAModeEnum

Specifies the mode for the exported PDF/A file: PDF/A-1a, PDF/A-1b, PDF/A-2a, PDF/A-2b, PDF/A-2u, PDF/A-3a, PDF/A-3b, or PDF/A-3u.

The property is valid only if the CreatePDFA property is set to TRUE.

By default, the value is PDFAM_1a.

PDFRecognitionLanguage

String

Specifies recognition languages for a searchable PDF file. Additional text recognition is performed during searchable PDF file creation. As text of document fields may be written in one language, while the whole document may contain several languages, you can select recognition languages different from the languages specified in the Document Definition with the help of this property. This property may contain several language names divided by commas, for example "English,French,German".

The value of this property is taken into account only if the value of the CreateSearchablePDF property is TRUE.

By default languages of the Document Definition are used.

Prefix

String

Specifies the prefix of saved image files names. To include project, batch, or Document Definition name into the image file name, use the <Project>, <Batch>, or <Template> elements respectively. The elements in angle brackets will be changed to corresponding values. The elements without angle brackets will be passed as is.

By default the value of this property is "<Batch>".

warning Important! Working with projects in ABBYY FlexiCapture Engine 12 is deprecated and will be removed in future versions. It is strongly recommended that you use FlexiCapture Processor and its functionality in your scenarios.

Resolution

Int

Specifies the resolution of images in dots per inch. The value of this property is in range from 0 to 1200.

By default the value of this property is 0, which means that the original resolution must be preserved.

UseMRCCompression

Boolean

Specifies if Mixed Raster Content (MRC) compression technology should be used for PDF files.

The property is valid only if the Format property is set to IFF_Pdf.

The default value of the property is FALSE.

WriteTaggedPdf

Boolean

Specifies if image should be exported to tagged PDF.

note Note: Tagged PDF is a particular use of structured PDF that allows page content to be extracted and used for various purposes such as reflow of text and graphics, conversion to file formats such as HTML and XML, and accessibility to the visually impaired.

Some constraints are imposed on the value of this property:

·The property is valid only if the Format property is set to IFF_Pdf.

·PDF/A-1a, PDF/A-2a, and PDF/A-3a are always tagged, so this property cannot be set to FALSE if the PdfAMode property is set to PDFAM_1a, PDFAM_2a, or PDFAM_3a.

·Other PDF/A formats are always untagged, so this property cannot be set to TRUE if the PdfAMode property is set is set to PDFAM_1b, PDFAM_2b, PDFAM_2u, PDFAM_3b, or PDFAM_3u.

This property is FALSE by default.

The list of supported combinations of the Format, ColorType and CompressionType properties

Format | ColorType | CompressionType
IFF_Bmp | ICT_BlackWhite | ICT_Default (no compression)
 | ICT_Gray
 | ICT_Color
IFF_Dcx | ICT_BlackWhite | ICT_Default (PackBits compression)
 | ICT_Gray
 | ICT_Color
IFF_Jpg | ICT_Gray | ICT_Default (JPEG compression)
 | ICT_Color
IFF_J2k | ICT_Gray | ICT_Default (JPEG 2000 compression)
 | ICT_Color
IFF_Pcx | ICT_BlackWhite | ICT_Default (PackBits compression)
 | ICT_Gray
 | ICT_Color
IFF_Pdf | ICT_BlackWhite | ICT_Default (JBIG2 compression)
 | ICT_Gray | ICT_Default (JPEG 2000 compression)
 | ICT_Color
IFF_Png | ICT_BlackWhite | ICT_Default (PNG compression)
 | ICT_Gray
 | ICT_Color
IFF_Tif | ICT_BlackWhite | ICT_Uncompressed
 |  | ICT_CcittGroup4
 |  | ICT_PackBits
 |  | ICT_Lzw
 |  | ICT_Zip
 |  | ICT_Default (no compression)
 | ICT_Gray | ICT_Uncompressed
 |  | ICT_PackBits
 |  | ICT_Jpeg
 |  | ICT_Lzw
 |  | ICT_Zip
 |  | ICT_Default (no compression)
 | ICT_Color | ICT_Uncompressed
 |  | ICT_PackBits
 |  | ICT_Jpeg
 |  | ICT_Lzw
 |  | ICT_Zip
 |  | ICT_Default (no compression)

Related objects

See also

FileExportParams

Tuning Export Parameters

Working with Properties

See sample: FlexiCapture Engine Code Snippets


TextExportParams Object

TextExportParams Object (ITextExportParams Interface)

API Reference > Objects > Export Parameters Objects >

TextExportParams Object (ITextExportParams Interface)

This object provides functionality for tuning parameters of recognized text export. These parameters are set in the TextParams property of the FileExportParams object.

Properties

Name | Type | Description
CodePage | CodePageEnum | Specifies the code page to which the recognized text is exported. The value of this property is taken into account only when the CodePageType property has value CPT_OEM or CPT_ANSI (exported text is not Unicode). If this property does not specify any code page (CP_Null), the code page is selected automatically using the CodePageType property value. By default the value of this property is CP_Null.
CodePageType | CodePageTypeEnum | Specifies the code page type (OEM, ANSI, or Unicode). The value of this property is CPT_Unicode by default.
EncodingType | TextEncodingTypeEnum | Specifies the encoding type of the Unicode file. The value of this property is taken into account only when the CodePageType property has value CPT_Unicode. The value of this property is TET_UTF8 by default.

Related objects

See also

FileExportParams

Tuning Export Parameters

Working with Properties


XMLExportParams Object

XMLExportParams Object (IXMLExportParams Interface)

API Reference > Objects > Export Parameters Objects >

XMLExportParams Object (IXMLExportParams Interface)

This object provides functionality for tuning parameters of recognized text export to XML format. These parameters are set in the XMLParams property of the FileExportParams object.

An XML schemes of an XML document are available by the references provided in the resulting XML.

Properties

Name | Type | Description
EncodingType | TextEncodingTypeEnum | Specifies the encoding type. The value of this property is TET_UTF8 by default.
ExportFieldTypes | Boolean | Specifies if field types are to be written in files in XML format. The value of this property is FALSE by default.
ExportErrors | Boolean | Specifies if errors occurred during document processing should be written in files in XML format. The value of this property is FALSE by default.
ExportFieldPosition | Boolean | Specifies if the coordinates of field blocks are written in files in XML format. The value of this property is FALSE by default.
MarkSuspiciousSymbols | Boolean | Specifies if uncertainly recognized symbols are to be marked in files in XML format. If the value of this property is TRUE, recognized characters in output XML file are marked with 0 or 1, where 1 corresponds to uncertainly recognized character. The value of this property is FALSE by default.

Related objects

See also

FileExportParams

Tuning Export Parameters

Working with Properties


Scanning-Related Objects

API Reference > Objects >

Scanning-Related Objects

Scanning in ABBYY FlexiCapture Engine 12 is performed via the special ScanManager object.

This section describes the following objects which are used for scanning:

·ScanManager

·ScanSources

·ScanSource

·ScanSourceCapabilities

·ScanSourceSettings

·IScanManagerEvents

·IScanCallback

See the description of typical scanning procedure in Scanning.

The hierarchy of the objects


ScanManager Object

ScanManager Object (IScanManager Interface)

API Reference > Objects > Scanning-Related Objects >

ScanManager Object (IScanManager Interface)

This object exposes a set of properties and methods required to perform scanning.

The ScanManager object is a so-called "connectable object." The methods of the ScanManager object report information about scanning through special outgoing interfaces. These interfaces are IScanManagerEvents (for C++) and the dispinterface DIScanManagerEvents (for Visual Basic). It should be noted that Visual Basic users should not care for details of implementing event interfaces, as this development platform provides easy means for handling them.

It is worth noting that this object requires a special implementation of the IScanManagerEvents interface methods which should process Windows messages. This issue is described in detail in the IScanManagerEvents Interface article.

Properties

Name | Type | Description
ScanOptionsInterfaceType | ScanOptionsInterfaceTypeEnum | Specifies the interface type for the scanning options. By default, this property is set to SOIT_Twain.
ScanSources | StringsCollection, read-only | This property is obsolete and provided only for compatibility with previous versions. We recommend using the ScanSourcesEx property instead, which provides not only the names of the scanners but lets you access the options and start an asynchronous scanning operation on one of them. Returns a list of scan sources available on the current workstation.
ScanSourcesEx | ScanSources, read-only | Returns a list of scan sources available on the current workstation as a collection of ScanSource objects.
ScanSourceSettings | ScanSourceSettings | This property is obsolete and provided only for compatibility with previous versions. Use the IScanSource::ScanSettings property for one of the scanners obtained via the ScanSourcesEx property. Provides access to the scanning options of a source (scanner).

Methods

Name | Description
FindScanSources | Returns a list of scanning sources filtered according to API type and user interface to be supported.
PumpMessages | Retrieves the messages from queue.
Scan | This method is obsolete and provided only for compatibility with previous versions. Use the Scan or BeginScan methods of a particular ScanSource. Scans one or several images with the specified scan source into the specified folder on the disk.

Related objects

Object Diagram

Output parameter

The object is the output parameter of the CreateScanManager method of the Engine object.

See also

Scanning

Working with Connectable Objects

IScanManagerEvents

Working with Properties

See sample: FlexiCapture Engine Code Snippets


ScanSourceSettings Property of ScanManager Object

ScanSourceSettings Property of the ScanManager Object

API Reference > Objects > Scanning-Related Objects > ScanManager >

ScanSourceSettings Property of the ScanManager Object

This property is obsolete and provided only for compatibility with previous versions. Use the IScanSource::ScanSettings property for one of the scanners obtained via the ScanSourcesEx property.

This property of the ScanManager object provides access to the scanning options of a source (scanner). The name of the source is passed as the parameter.

Syntax

Visual Basic .NET

Property ScanSourceSettings(source As String) As ScanSourceSettings

C++

HRESULT get_ScanSourceSettings(
BSTR source,
IScanSourceSettings** settings

);
HRESULT put_ScanSourceSettings(
BSTR source
IScanSourceSettings* newSet
);

Parameters

source

[in] This variable contains available scan source.

settings

[out, retval] A pointer to the IScanSourceSettings* pointer variable that receives the interface pointer of the ScanSourceSettings object that contains the scan settings.

newSet

[in] This variable refers to the ScanSourceSettings object that contains the scan settings.

Return values

This function has no specific return values. It returns standard return values.

See also

ScanManager

ScanSourceSettings

Scanning

Working with Properties

See sample: FlexiCapture Engine Code Snippets


FindScanSources Method of the ScanManager Object

API Reference > Objects > Scanning-Related Objects > ScanManager >

FindScanSources Method of the ScanManager Object

This method enables you to receive a list of available scanning sources filtered by user interface type and API type that the scanner provides.

Syntax

Visual Basic .NET

Function FindScanSources( _
OptionsInterfaceType As ScanOptionsInterfaceTypeEnum, _
ApiType As ScanSourceApiTypeEnum _
) As ScanSources

C++

HRESULT FindScanSources(
ScanOptionsInterfaceTypeEnum OptionsInterfaceType,
ScanSourceApiTypeEnum ApiType,
IScanSources** Result
);

Parameters

OptionsInterfaceType

[in] This variable specifies the interface type which is to be used for setting the scanning options as ScanOptionsInterfaceTypeEnum.

ApiType

[in] This variable specifies the API type that must be supported by the scanning source. It is defined as one of the ScanSourceApiTypeEnum constants.

Result

[out, retval] A pointer to the IScanSources* pointer variable that receives the interface pointer of the ScanSources object.

Return values

This method may return the standard return values of ABBYY FlexiCapture Engine functions.

See also

ScanManager


PumpMessages Method of ScanManager Object

PumpMessages Method of the ScanManager Object

API Reference > Objects > Scanning-Related Objects > ScanManager >

PumpMessages Method of the ScanManager Object

This method pumps queued messages. It may be necessary for the applications that do not implement a standard Windows message loop, in which case you need to call this method when you want to receive queued messages and notifications from scanning methods. When scanning notifications are received, the corresponding methods of the IScanCallback interface are called.

Syntax

Visual Basic .NET

Sub PumpMessages()

C++

HRESULT PumpMessages();

Return values

This method may return the standard return values of ABBYY FlexiCapture Engine functions.

See also

ScanManager

IScanCallback


ExportPages Method of Exporter Object

Scan Method of the ScanManager Object

API Reference > Objects > Scanning-Related Objects > ScanManager >

Scan Method of the ScanManager Object

This method is obsolete and provided only for compatibility with previous versions. Use the Scan or BeginScan methods of a particular ScanSource.

This method performs scanning of one or several images with the specified scanning source into the specified folder on the disk. The IScanManagerEvents interface methods may be called for this method, if there are any listeners attached to the IConnectionPointContainer interface supported by the ScanManager object.

Syntax

Visual Basic .NET

Function Scan( _
scanSource As String, _
destinationFolder As String, _
scanMultiplePages As Boolean _
) As StringsCollection

C++

HRESULT Scan(
BSTR scanSource,
BSTR destinationFolder,
VARIANT_BOOL scanMultiplePages,
IStringsCollection** result
);

Parameters

scanSource

[in] This variable specifies the name of scanning source with which to perform scanning. This name should be one of the collection returned by the IScanManager::ScanSources property.

destinationFolder

[in] This variable contains the full path to the output folder, where scanned images should be stored. If this folder does not exist, it will be created.

scanMultiplePages

[in] This variable of the Boolean type specifies whether multiple pages should be scanned at a time.

result

[out, retval] A pointer to the IStringsCollection* pointer variable that receives the interface pointer of the StringsCollection object. *result should not refer to any valid object. The StringsCollection is created internally by this method. This object contains the list of full paths to the image files that were received from the scanner.

Return values

This method may return standard return values.

Remarks

·If no listeners are attached to the IConnectionPointContainer interface supported by the ScanManager object, Windows messages are processed internally by ABBYY FlexiCapture Engine. This is needed to avoid an effect that the application "is not responding" during scanning. It is recommended to use ABBYY FlexiCapture Engine internal Windows message processing, if an ability to break scanning is needed.

·The image files created by this method after scanning are saved in one of the formats which is supported both by the scanner and ABBYY FlexiCapture Engine (commonly it is BMP format).

·The Scan Manager may show message boxes if an error occurs (no paper in the scanner, wrong resolution, bad TWAIN dll version, etc).

See also

ScanManager

IScanManagerEvents

See sample: FlexiCapture Engine Code Snippets


ScanSource Object

ScanSource Object (IScanSource Interface)

API Reference > Objects > Scanning-Related Objects >

ScanSource Object (IScanSource Interface)

This object exposes a set of properties and methods concerned with scanning source.

Properties

Name | Type | Description
ApiType | ScanSourceApiTypeEnum, read-only | Returns the API type used by the scanning source (TWAIN or WIA).
AvailableOptionsInterfaceTypes | int, read-only | Describes the possible types of user interface for setting scanning options as a bitwise OR of ScanOptionsInterfaceTypeEnum constants.
Capabilities | ScanSourceCapabilities, read-only | Returns the settings that are supported by the scanning source.
Name | BSTR, read-only | Returns the name of the scanning source.
ScanSettings | ScanSourceSettings, read-only | Returns the current settings of the scanning source.
Status | ScanSourceStatusEnum, read-only | Returns the current status of the scanning source.

Methods

Name | Description
BeginScan | Starts an asynchronous scanning operation.
CancelScan | Allows you to cancel an asynchronous scanning operation.
ResetSettings | Resets scanning source settings to default values.
Scan | Performs scanning of one or several images.

Related objects

Object Diagram

See also

Scanning

Working with Properties


BeginScan Method of the ScanSource Object

API Reference > Objects > Scanning-Related Objects > ScanSource >

BeginScan Method of the ScanSource Object

This method starts an asynchronous scanning operation and returns immediately. Scanning can take a lot of time, and this method can be useful when you do not want the program to wait for the completion of a long scanning operation. It takes a pointer to the IScanCallback scanning management interface as an input parameter.

warning Important! You cannot start another scanning operation until the current one is completed, even if you select some other scanning source. Its completion will be signalled by OnScanComplete notification.

Syntax

Visual Basic .NET

Sub BeginScan( _
OptionsInterfaceType As ScanOptionsInterfaceTypeEnum, _
Folder As String, _
ByRef Callback As IScanCallback _
)

C++

HRESULT BeginScan(
ScanOptionsInterfaceTypeEnum OptionsInterfaceType,
BSTR Folder,
IScanCallback* Callback
);

Parameters

OptionsInterfaceType

[in] This variable specifies the interface type which is to be used for setting the scanning options as ScanOptionsInterfaceTypeEnum.

Folder

[in] This variable determines the path to the folder where the scans should be saved. Please note that this folder must already exist.

Callback

[in] This variable is used to pass the pointer to the IScanCallback callback interface. This interface is used for scanning progress and completion notifications, or for errors that may occur during scanning. This parameter is optional. If you do not want to receive the notifications, pass the null pointer.

Return values

This method may return the standard return values of ABBYY FlexiCapture Engine functions.

See also

ScanSource


CancelScan Method of the ScanSource Object

API Reference > Objects > Scanning-Related Objects > ScanSource >

CancelScan Method of the ScanSource Object

This method cancels the asynchronous scanning operation.

Syntax

Visual Basic .NET

Sub CancelScan()

C++

HRESULT CancelScan();

Return values

This method may return the standard return values of ABBYY FlexiCapture Engine functions.

See also

ScanSource


ResetSettings Method of the ScanSource Object

API Reference > Objects > Scanning-Related Objects > ScanSource >

ResetSettings Method of the ScanSource Object

This method resets all settings of the ScanSource object to their default values.

Syntax

Visual Basic .NET

Sub ResetSettings()

C++

HRESULT ResetSettings();

Return values

This method may return the standard return values of ABBYY FlexiCapture Engine functions.

See also

ScanSource


Scan Method of the ScanSource Object

API Reference > Objects > Scanning-Related Objects > ScanSource >

Scan Method of the ScanSource Object

This method performs scanning of one or more images. It returns a collection of the names of the resulting image files.

One of the input parameters of this method receives a pointer to the IScanCallback scanning management interface.

This method does not return until scanning is completed. If you want to scan asynchronously, i.e. without blocking the execution of your program, use the BeginScan method of the same object.

Syntax

Visual Basic .NET

Function Scan( _
OptionsInterfaceType As ScanOptionsInterfaceTypeEnum, _
Folder As String, _
callback As IScanCallback _
) As StringsCollection

C++

HRESULT Scan(
ScanOptionsInterfaceTypeEnum OptionsInterfaceType,
BSTR Folder,
IScanCallback* callback,
IStringsCollection** Result
);

Parameters

OptionsInterfaceType

[in] This variable specifies the interface type which is to be used for setting the scanning options as ScanOptionsInterfaceTypeEnum.

Folder

[in] This variable determines the path to the folder where the scans should be saved. Please note that this folder must already exist.

callback

[in] This variable is used to pass the pointer to the IScanCallback callback interface. This interface is used for scanning progress and completion notifications, or for errors that may occur during scanning. This parameter is optional. If you do not want to receive the notifications, pass the null pointer.

Result

[out, retval] A pointer to the IStringsCollection* pointer variable that receives the interface pointer of the StringsCollection object which will contain the file names of the scanned images.

Return values

This method may return the standard return values of ABBYY FlexiCapture Engine functions.

See also

ScanSource


ScanSources Object

ScanSources Object (IScanSources Interface)

API Reference > Objects > Scanning-Related Objects >

ScanSources Object (IScanSources Interface)

This object represents a collection of scanning sources. This object provides the standard properties and methods of the ABBYY FlexiCapture Engine collections.

note Notes:

·The indexing of ABBYY FlexiCapture Engine collections starts with 0.

·The foreach statement in C# (for each in Visual Basic .NET) can be used to manipulate the collection.

·For TWAIN API type, the ScanSources collection contains all the registered scanning sources, connected or not. If you try to use an unconnected scanner, an error will occur. However, in some cases TWAIN scanning API can make an attempt to scan with unconnected source and return the connection error only after that.

Properties

Name | Type | Description
Count | int, read-only | Stores the number of elements in the collection.
Element | ScanSource, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Output parameter

This object is the output parameter of the following methods:

·FindScanSources method of the ScanManager object.

Related objects

Object Diagram

See also

Scanning

Working with Collections


ScanSourceCapabilities Object

ScanSourceCapabilities Object (IScanSourceCapabilities Interface)

API Reference > Objects > Scanning-Related Objects >

ScanSourceCapabilities Object (IScanSourceCapabilities Interface)

This object provides access to possible settings of the scanning source. The properties cannot be changed because they correspond to actual capabilities of the scanner.

Properties

Name | Type | Description
BrightnessControls | int, read-only | Describes possible brightness control modes of the scanning source as bitwise OR of ScanBrightnessControlEnum constants.
Compressions | int, read-only | Returns the possible compression mode for the specified color mode. The result is a bitwise OR of ScanCompressionTypeEnum constants.
HasDuplexMode | VARIANT_BOOL, read-only | Specifies whether the scanner is capable of scanning duplex, that is, automatically scanning both sides of the page being processed.
MaxPaperHeight | int, read-only | Specifies the maximum height of the page possible for scanning in milli-inches.
MaxPaperWidth | int, read-only | Specifies the maximum width of the page possible for scanning in milli-inches.
PaperFeedModes | int, read-only | Describes the possible paper source as bitwise OR of ScanPaperFeedModeEnum constants.
PaperSizes | IntsCollection, read-only | Returns a list of possible page sizes for the scanner. The values in this list correspond to the constants of ScanPaperSizeEnum.
PictureModes | int, read-only | Describes possible color modes of the scanning source as bitwise OR of ScanPictureModeEnum constants.
Resolutions | IntsCollection, read-only | A collection of possible resolutions for this scanning source.
RotationAngles | int, read-only | Describes possible rotation angles as bitwise OR of ScanPageRotationAngleEnum constants.
RotationEnabled | VARIANT_BOOL, read-only | Specifies whether the scanner supports automatic rotation of scanned pages.

Related objects

Object Diagram

See also

Working with Properties


Compressions Property of ScanSourceCapabilities Object

Compressions Property of the ScanSourceCapabilities Object

API Reference > Objects > Scanning-Related Objects > ScanSourceCapabilities >

Compressions Property of the ScanSourceCapabilities Object

The ScanSourceCapabilities object provides access to possible settings of scanning source, but available modes of compression depend on the chosen color mode.

This property describes possible compression modes for the specified color mode in terms of combination of ScanCompressionTypeEnum flags. This property is read-only.

Syntax

Visual Basic .NET

Property Compressions(PictureMode As ScanPictureModeEnum) As Int

C++

HRESULT get_Compressions(
ScanPictureModeEnum PictureMode,
int* Result
);

Parameters

PictureMode

[in] A variable of ScanPictureModeEnum type that describes the color type for which you wish to get the possible compressions.

Result

[out, retval] Returns the possible compression modes as a bitwise OR of ScanCompressionTypeEnum constants.

Return values

This function has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ScanSourceCapabilities

Working with Properties


IScanCallback Interface

API Reference > Objects > Scanning-Related Objects >

IScanCallback Interface

This is a callback interface that is used for managing scanning operations. This interface is implemented on the client side.

An object receiving notifications through this interface's methods may do the following inside the methods' implementation:

·Process any Windows messages, which is useful in applications having User Interface, to avoid the effect that the application “is not responding” during long operations.

·Report errors which occurred during scanning to the user.

·Cancel processing.

Methods

Name | Description
OnError | Delivers to the client information about the errors that occurred during scanning.
OnImageScanned | Delivers information about the course of the scanning operation and allows it to be stopped if necessary.
OnScanComplete | Gives notification that the scanning operation has been completed.

Input parameter

This object is passed as an input parameter to the following methods:

·Scan and BeginScan methods of the ScanSource object.

See also

ScanManager


OnError Method of the IScanCallback Interface

API Reference > Objects > Scanning-Related Objects > IScanCallback >

OnError Method of the IScanCallback Interface

This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine each time an image is scanned. It delivers information about the course of scanning operation and allows it to be terminated if necessary.

Syntax

Visual Basic .NET

HRESULT OnImageScanned(
BSTR SourceName,
BSTR Message
);

C++

Sub OnImageScanned( _
SourceName As String, _
Message As String _
)

Parameters

SourceName

[in] This parameter specifies the name of the scanning source from which the scanned image has been received.

Message

[in] This parameter specifies the path to the resultant image file.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IScanCallback


OnImageScanned Method of the IScanCallback Interface

API Reference > Objects > Scanning-Related Objects > IScanCallback >

OnImageScanned Method of the IScanCallback Interface

This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine each time an image is scanned. It delivers information about the course of scanning operation and allows scanning to be terminated if necessary.

Syntax

Visual Basic .NET

Sub OnImageScanned( _
SourceName As String, _
path As String, _
ByRef Cancel As Boolean _
)

C++

HRESULT OnImageScanned(
BSTR SourceName,
BSTR path,
VARIANT_BOOL* Cancel
);

Parameters

SourceName

[in] This parameter specifies the name of the scanning source from which the scanned image has been received.

path

[in] This parameter specifies the path to the resultant image file.

Cancel

[in, out] You may set this variable to TRUE to indicate that scanning should be terminated.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IScanCallback


OnScanComplete Method of the IScanCallback Interface

API Reference > Objects > Scanning-Related Objects > IScanCallback >

OnScanComplete Method of the IScanCallback Interface

This method notifies the client that the scanning operation is completed. It has to be implemented on the client side.

Syntax

Visual Basic .NET

Sub OnScanComplete()

C++

HRESULT OnScanComplete();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IScanCallback


ScanSourceSettings Object

ScanSourceSettings Object (IScanSourceSettings Interface)

API Reference > Objects > Scanning-Related Objects >

ScanSourceSettings Object (IScanSourceSettings Interface)

This object provides access to the scanning settings of a source. Default values of the properties depend on the source scanner.

Properties

Name | Type | Description
Brightness | Int | Specifies the brightness of the scanned image (0-100). It is only valid when the BrightnessControl property is set to SBC_Manual.
BrightnessControl | ScanBrightnessControlEnum | Sets brightness control mode.
CompressionType | ScanCompressionTypeEnum | Specifies whether compression must be used.
Delay | Int | Sets the pause between pages in seconds. It is only valid if the PauseBetweenPages property is set to TRUE.
DuplexMode | Boolean | Specifies whether duplex scanning must be used.
PaperBottom | Int | Sets the coordinate of the bottom border of the scanning area rectangle (in milli-inch). It is only valid if the PaperSize property is SPS_Custom.
PaperLeft | Int | Sets the coordinate of the left border of the scanning area rectangle (in milli-inch). It is only valid if the PaperSize property is SPS_Custom.
PaperRight | Int | Sets the coordinate of the right border of the scanning area rectangle (in milli-inch). It is only valid if the PaperSize property is SPS_Custom.
PaperSize | ScanPaperSizeEnum | Sets paper size.
PaperTop | Int | Sets the coordinate of the top border of the scanning area rectangle (in milli-inch). It is only valid if PaperSize property is SPS_Custom.
PauseBetweenPages | Boolean | Specifies whether the program must pause between pages during scanning. The length of the pause can be specified in the Delay property.
PictureMode | ScanPictureModeEnum | Sets image type (black-and-white, gray, color).
Resolution | Int | Sets image resolution (from 200 to 600). Please note that not all scanners support all resolution values.
RotationAngle | ScanPageRotationAngleEnum | Sets image rotation angle (once the image has been scanned).
StopBetweenPages | Boolean | Specifies whether the program must stop between pages during scanning.
UseFeeder | Boolean | Specifies whether an automatic document feeder must be used.

Related objects

Object Diagram

See also

ScanManager

Scanning

Working with Properties

See sample: FlexiCapture Engine Code Snippets


IScanManagerEvents Interface

API Reference > Objects > Scanning-Related Objects >

IScanManagerEvents Interface

note Note: This interface is provided for compatibility with previous versions. It reports any events only when you use the outdated IScanManager::Scan method. However, now we recommend working with fthe methods of the ScanSource object, which use the IScanCallback interface to handle errors and receive notifications about scanning completion, in which case IScanManagerEvents interface needn't be implemented.

This is a callback interface that is used for interaction of the ScanManager object with its listeners.

This interface is designed primarily for the user to have an ability to break multipage scanning and does not report any information about scanning progress. This interface is implemented on the client side. See the detailed implementation advice for your development tool in Working with Connectable Objects. Below you can find a short summary.

In C++ you need to implement the IScanManagerEvents interface, obtain a connection point, and "advise" object implementing the interface to the ScanManager object. As it derives from the IUnknown interface, the client object should also implement the IUnknown methods.

Visual Basic users that want to implement listeners for the ScanManager object should declare it WithEvents and implement the Sub similar to the following:

Private Sub scanManager_NewImage(ByVal scannedImage As String, _
ByRef cancelScanning As Boolean)
DoEvents
...
End Sub
Private Sub scanManager_ScanStopped()
DoEvents
...
End Sub

An object connected to this callback interface should process Windows messages. This is absolutely necessary, or the scanning will not function. When no listeners are connected to the IScanManagerEvents interface, the Windows messages are processed internally by ABBYY FlexiCapture Engine. When any listeners are attached, they should process Windows messages themselves. In Visual Basic it is done by the DoEvents statement. For C++ users the following special kind of message loop is recommended:

MSG msg;
while(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE | PM_NOYIELD)) {
if(WM_MOUSEFIRST <= msg.message && msg.message <= WM_MOUSELAST) {
continue;
}
if(WM_NCMOUSEMOVE <= msg.message && msg.message <= WM_NCMBUTTONDBLCLK) {
continue;
}
if(WM_KEYFIRST <= msg.message && msg.message <= WM_KEYLAST) {
continue;
}
::DispatchMessage(&msg);
}

Note that all messages are removed from the message queue, but not all of them are processed. In particular, all user input (both from keyboard and from the mouse) is not processed. This eliminates the possibility that user may do something wrong with this window during the scanning (close it or choose something from the menu for example).

Methods

Name | Description
NewImage | Provides information about the name of the file with the scanned image. Allows you to stop multipage scanning.
ScanStopped | Provides information about whether the scanning was stopped.

See also

ScanManager

Working with Connectable Objects


NewImage Method of the IScanManagerEvents Interface

API Reference > Objects > Scanning-Related Objects > IScanManagerEvents >

NewImage Method of the IScanManagerEvents Interface

This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for the IScanManager::Scan method. Its implementation should process Windows messages or the scanning will not function correctly. This method allows a user to receive a name of the file with the scanned image and to break multipage scanning.

Syntax

Visual Basic .NET

Sub NewImage( _
ByVal scannedImage As String, _
ByRef cancelScanning As Boolean _
)

C++

HRESULT NewImage(
BSTR scannedImage,
VARIANT_BOOL* cancelScanning
);

Parameters

scannedImage

[in] This parameter contains the name of the file with the scanned image.

cancelScanning

[in, out] You may set this variable to TRUE (VARIANT_TRUE) to indicate that the scanning process should be terminated. In this case the scanning function, that reports the tip, returns E_ABORT.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that no exceptions are thrown inside it, as it may lead to unpredictable results. The client implementation should process Windows messages. In Visual Basic this is done via the DoEvents statement, while for C++ users it is recommended to use the special form of message loop described on the IScanManagerEvents page.

See also

ScanManager

IScanManagerEvents


ScanStopped Method of the IScanManagerEvents Interface

API Reference > Objects > Scanning-Related Objects > IScanManagerEvents >

ScanStopped Method of the IScanManagerEvents Interface

This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for the IScanManager::Scan method. Its implementation should process Windows messages or the scanning will not function correctly. This method provides to the client information about whether the scanning was stopped.

Syntax

Visual Basic .NET

Sub ScanStopped()

C++

HRESULT ScanStopped();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that no exceptions are thrown inside it, as it may lead to unpredictable results. The client implementation should process Windows messages. In Visual Basic this is done via the DoEvents statement, while for C++ users it is recommended to use the special form of message loop described on the IScanManagerEvents page.

See also

ScanManager

IScanManagerEvents


Verification-Related Objects

API Reference > Objects >

Verification-Related Objects

Verification is a process of checking recognized data. Verification in ABBYY FlexiCapture Engine is represented by several objects, which represent different verification stages. The main verification-related object is the VerificationSession object. Each verification session is separated on several work sets. And there are several groups in each work set. See Verifying Recognized Data for details.

This section describes the objects which allow you to perform verification of recognized text:

·VerificationSession

·VerificationWorkSet

·VerificationOptions

·VerificationGroup

·VerificationObject

·GroupVerificationObject

·ContextVerificationObject

The hierarchy of the objects


VerificationSession Object

VerificationSession Object (IVerificationSession Interface)

API Reference > Objects > Verification-Related Objects >

VerificationSession Object (IVerificationSession Interface)

This object corresponds to a verification session. Verification is a process of checking recognized data. It is performed by comparing recognition results with the original image of any document part. When the program does not have absolute certainty about the accuracy of recognition of certain characters, it marks them as uncertainly recognized. The purpose of the verification process is to verify such characters, make sure that they have been recognized correctly, and correct them if necessary.

To run the verification process, call the CreateVerificationSession method of the Engine object. This method provides access to the VerificationSession object which contains all the verification settings and allows you to receive the data to verify. Before starting the verification you should set the verification options using the Options property. When the verification parameters are set call the NextWorkSet method to receive a part of data that need verification (a work set). Each verification session contains one or several work sets. Documents are combined into work sets depending on the available resources, thereby work sets enable several verifiers to process one big batch. See Verifying Recognized Data for details.

warning Important! You cannot run two verification sessions in one process simultaneously using ABBYY FlexiCapture Engine.

Properties

Name | Type | Description
Errors | StringsCollection, read-only | Returns all the errors for the verification session.
Options | VerificationOptions, read-only | Returns verification session options. The options should be adjusted before calling NextWorkSet method.
TotalProgressEstimation | Int, read-only | Returns the estimate percent of verification currently done.
Warnings | StringsCollection, read-only | Returns all the warnings for the verification session.

Methods

Name | Description
Close | Closes the verification session.
NextWorkSet | Receives the next work set of the verification session.

Related objects

Output parameter

This object is the output parameter of the following methods:

·CreateVerificationSession method of the Engine object

·StartVerification method of the Batch object (deprecated)

·StartVerification method of the Project object (deprecated)

See also

Verifying Recognized Data

VerificationWorkSet

Working with Properties

See sample: FlexiCapture Engine Code Snippets


Close Method of the VerificationSession Object

API Reference > Objects > Verification-Related Objects > VerificationSession >

Close Method of the VerificationSession Object

This method closes the verification session.

Release all the references to the VerificationSession object, and then call this method. An open verification session uses more resources than a closed one. So if you have finished verification and need to free some resources, call this method to close the verification session. We recommend using this method in finally blocks.

Syntax

Visual Basic .NET

Sub Close()

C++

HRESULT Close();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

VerificationSession

IBatch::StartVerification

See sample: FlexiCapture Engine Code Snippets


NextWorkSet Method of the VerificationSession Object

API Reference > Objects > Verification-Related Objects > VerificationSession >

NextWorkSet Method of the VerificationSession Object

This method allows you to receive the next work set of the verification session.

Syntax

Visual Basic .NET

Function NextWorkSet() As VerificationWorkSet

C++

HRESULT NextWorkSet(
IVerificationWorkSet** result
);

Parameters

result

[out, retval] A pointer to the IVerificationWorkSet* variable that receives the interface pointer for the verification work set.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

VerificationSession

See sample: FlexiCapture Engine Code Snippets


VerificationWorkSet Object

VerificationWorkSet Object (IVerificationWorkSet Interface)

API Reference > Objects > Verification-Related Objects >

VerificationWorkSet Object (IVerificationWorkSet Interface)

This object represents a verification work set. Work set is a part of data that need verification. Each verification session contains one or several work sets. Documents are combined into work sets depending on the available resources, thereby work sets enable several verifiers to process one big batch.

To receive the next part of data to verify, call the NextWorkSet method of the VerificationSession object. Each work set consists of several groups of objects to verify. To receive the next group, call the NextGroup method. When you finished verification of the data in the current work set, you must call the Commit method to save the changes.

Methods

Name | Description
NextGroup | Gets next group of objects to verify.
Commit | Fixes the changes made while verification.

Output parameter

This object is the output parameter of the NextWorkSet method of the VerificationSession object.

See also

Verifying Recognized Data

VerificationSession

VerificationGroup

Working with Properties

See sample: FlexiCapture Engine Code Snippets


NextGroup Method of the VerificationWorkSet Object

API Reference > Objects > Verification-Related Objects > VerificationWorkSet >

NextGroup Method of the VerificationWorkSet Object

This method allows you to receive the next part of job.

Syntax

Visual Basic .NET

Function NextGroup() As VerificationGroup

C++

HRESULT NextGroup(
IVerificationGroup** result
);

Parameters

result

[out, retval] A pointer to the IVerificationGroup* variable that receives the interface pointer for the verification group.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

VerificationWorkSet

See sample: FlexiCapture Engine Code Snippets


Commit Method of the VerificationWorkSet Object

API Reference > Objects > Verification-Related Objects > VerificationWorkSet >

Commit Method of the VerificationWorkSet Object

This method allows to fix the changes made while the verification.

Syntax

Visual Basic .NET

Sub Commit()

C++

HRESULT Commit();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

VerificationWorkSet

See sample: FlexiCapture Engine Code Snippets


VerificationOptions Object

VerificationOptions Object (IVerificationOptions Interface)

API Reference > Objects > Verification-Related Objects >

VerificationOptions Object (IVerificationOptions Interface)

This object represents verification parameters. These parameters are set in the Options property of the VerificationSession object.

note Note: Verification options can be set only before starting the verification (before the first IVerificationSession::NextWorkSet method call). After beginning the verification, all these settings become read-only.

If you set both VerifyBaseSymbols and VerifyExtraSymbols properties to FALSE, group verification will not be performed. To exclude context verification, set the VerifyFields property to FALSE.

Properties

Name | Type | Description
ExcludedSymbols | String | Specifies the symbols which should be excluded from the verification process. By default no symbols are excluded.
VerifyBaseSymbols | Boolean | Specifies if the base symbols should be verified during group verification. Base symbols are digits. By default the value of this property is TRUE.
VerifyExtraSymbols | Boolean | Specifies if the extra symbols should be verified during group verification. Extra symbols include all symbols except digits. By default the value of this property is FALSE.
VerifyFields | Boolean | Specifies whether context verification should be performed or not. By default the value of this property is TRUE.

Related objects

See also

Verifying Recognized Data

VerificationSession

Working with Properties

See sample: FlexiCapture Engine Code Snippets


VerificationGroup Object

VerificationGroup Object (IVerificationGroup Interface)

API Reference > Objects > Verification-Related Objects >

VerificationGroup Object (IVerificationGroup Interface)

This object represents a verification group. The verification group consists of several verification objects. It can include the objects which are to be verified in one group during group verification, or the objects which have the same meaning during context verification (e.g. "Name" fields from all verified documents).

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the group.
Description | String, read-only | Contains the description of objects in the verification group.
Element | VerificationObject, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single verification object.

Output parameter

This object is the output parameter of the NextGroup method of the VerificationWorkSet object.

See also

Verifying Recognized Data

VerificationObject

VerificationWorkSet

Working with Properties

See sample: FlexiCapture Engine Code Snippets


VerificationObject Object

VerificationObject Object (IVerificationObject Interface)

API Reference > Objects > Verification-Related Objects >

VerificationObject Object (IVerificationObject Interface)

This object represents a verification object. Verification is a two-stage process – group and context verification. Therefore the verification object can be submitted for group or context verification. This defines the type of the object (the Type property). Subsequent parameters depend on the type of the object (use the AsContextVerificationObject or AsGroupVerificationObject methods depending on the type of the object).

Properties

Name | Type | Description
BatchName | String, read-only | Returns the name of the batch which owns the verification object (the IBatch::Title property). warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
ContextImage | __int64, read-only | Allows you to view the context of the object being verified. Contains the HBITMAP handle cast to the __int64 type.
ContextRect | Rectangle, read-only | Returns the coordinates of the context image on the page.
DocumentName | String, read-only | Returns the name of the document which owns the verification object (the IDocument::Title property).
FieldName | String, read-only | Returns the name of the document field which owns the verification object.
PageName | String, read-only | Returns the name of the page which owns the verification object (the IPage::Name property).
State | VerificationObjectStateEnum | Specifies the state of the verification object.
Type | VerificationObjectTypeEnum, read-only | Returns the type of the verification object.

Methods

Name | Description
AsContextVerificationObject | Returns the verification object as the ContextVerificationObject object. If the object is not a context verification object, NULL is returned.
AsGroupVerificationObject | Returns the verification object as the GroupVerificationObject object. If the object is not a context verification object, NULL is returned.

Output parameter

This object is the output parameter of the Item method of the VerificationGroup object.

See also

Verifying Recognized Data

VerificationGroup

Working with Properties

See sample: FlexiCapture Engine Code Snippets


AsContextVerificationObject Method of the VerificationObject Object

API Reference > Objects > Verification-Related Objects > VerificationObject >

AsContextVerificationObject Method of the VerificationObject Object

This method reterns the verification object as the ContextVerificationObject object. If the object is not a context verification object, NULL is returned.

Syntax

Visual Basic .NET

Function AsContextVerificationObject() As ContextVerificationObject

C++

HRESULT AsContextVerificationObject(
IContextVerificationObject** result
);

Parameters

result

[out, retval] A pointer to the IContextVerificationObject* pointer variable that receives the interface pointer to the returned ContextVerificationObject object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

VerificationObject

ContextVerificationObject

See sample: FlexiCapture Engine Code Snippets


AsGroupVerificationObject Method of the VerificationObject Object

API Reference > Objects > Verification-Related Objects > VerificationObject >

AsGroupVerificationObject Method of the VerificationObject Object

This method returns the verification object as the GroupVerificationObject object. If the object is not a context verification object, NULL is returned.

Syntax

Visual Basic .NET

Function AsGroupVerificationObject() As GroupVerificationObject

C++

HRESULT AsGroupVerificationObject(
IGroupVerificationObject** result
);

Parameters

result

[out, retval] A pointer to the IGroupVerificationObject* pointer variable that receives the interface pointer to the returned GroupVerificationObject object.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

VerificationObject

GroupVerificationObject

See sample: FlexiCapture Engine Code Snippets


GroupVerificationObject Object

GroupVerificationObject Object (IGroupVerificationObject Interface)

API Reference > Objects > Verification-Related Objects >

GroupVerificationObject Object (IGroupVerificationObject Interface)

This object represents the properties of the group verification object. Group verification is a verification mode whereby identically recognized characters are submitted for verification in groups. Group verification involves grouping character images recognized as having identical values and displaying them on the verifier screen, enabling the operator to easily identify and correct characters that deviate from the group.

The GroupVerificationObject object provides access to the symbol submitted for group verification and its image. To obtain the object, use the AsGroupVerificationObject property of the VerificationObject object.

Properties

Name | Type | Description
Image | __int64, read-only | Allows you to view the image of the character being verified. Contains the HBITMAP handle cast to the __int64 type.
ObjectRect | Rectangle, read-only | Returns the coordinates of the object on the image returned by the Image property.
ObjectRectOnContextImage | Rectangle, read-only | Returns the coordinates of the object on the image returned by the IVerificationObject::ContextImage property.
Symbol | String | Specifies the value of the verification object in a form of Unicode string. The value of this property can be one of the following: one character, “checked”, or “not checked”. The latest two values appear if the verification object is a checkmark.

Related objects

Output parameter

This object is the output parameter of the AsGroupVerificationObject method of the VerificationObject object.

See also

Verifying Recognized Data

VerificationObject

Working with Properties

See sample: FlexiCapture Engine Code Snippets


ContextVerificationObject Object

ContextVerificationObject Object (IContextVerificationObject Interface)

API Reference > Objects > Verification-Related Objects >

ContextVerificationObject Object (IContextVerificationObject Interface)

This object represents the properties of the context verification object. Context verification is a verification mode intended for effective correction of errors of "well-recognized" fields, i.e. fields whose range of values is known or can be easily identified. An example of such a field is the country or city name.

The ContextVerificationObject object provides access to the field containing error and the rules put on this field. To obtain the object, use the AsContextVerificationObject method of the VerificationObject object.

Properties

Name | Type | Description
Field | Field, read-only | Provides access to the field corresponding to the verification object.
RuleErrors | RuleErrors, read-only | Returns a collection of errors for unfulfilled rules.

Methods

Name | Description
CheckRules | Checks all rules imposed on data in the field corresponding to the verification object.

Related objects

Output parameter

This object is the output parameter of the AsContextVerificationObject method of the VerificationObject object.

See also

Verifying Recognized Data

VerificationObject

Working with Properties

See sample: FlexiCapture Engine Code Snippets


CheckRules Method of the ContextVerificationObject Object

API Reference > Objects > Verification-Related Objects > ContextVerificationObject >

CheckRules Method of the ContextVerificationObject Object

This method allows you to check all rules imposed on data in the field corresponding to the verification object.

Syntax

Visual Basic .NET

Sub CheckRules()

C++

HRESULT CheckRules();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

ContextVerificationObject

See sample: FlexiCapture Engine Code Snippets


License-Related Objects

API Reference > Objects >

License-Related Objects

This section contains descriptions of the following license-related objects:

·License

·LicenseCollection

The license-related objects hierarchy

For more information about the hierarchy of the ABBYY FlexiCapture Engine objects, please see the Object Diagram.


LicenseCollection Object

LicenseCollection Object (ILicenseCollection Interface)

API Reference > Objects > License-Related Objects >

LicenseCollection Object (ILicenseCollection Interface)

This object is a collection of available (activated) licenses.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | License, read-only | Provides access to a single element of the collection.

Methods

Name | Description
Item | Provides access to a single element of the collection.

Related objects

See also

License

IEngine::SetCurrentLicense

Working with Collections


License Object

License Object (ILicense Interface)

API Reference > Objects > License-Related Objects >

License Object (ILicense Interface)

This object stores information about the current license.

Properties

Name | Type | Description
AllowedCoresCount | Int, read-only | Returns the number of CPU cores that can be used simultaneously. If the value of this property is 0, the number of CPU cores is unlimited.
AvailableEngineModules | Int, read-only | Describes the set of the ABBYY FineReader Engine modules available in the license as a bitwise OR combination of the AEM_ prefixed flags.
AvailableExportFormats | Int, read-only | Describes the set of the export formats available in the license as a bitwise OR combination of the AEF_ prefixed flags.
AvailableFlexiCaptureEngineModules | Int, read-only | Describes the set of the ABBYY FlexiCapture Engine modules available in the license as a bitwise OR combination of the AFCEM_ prefixed flags.
AvailableTextTypes | Int, read-only | Describes the set of the text types available in the license as a bitwise OR combination of the ATT_ prefixed flags.
AvailableVisualComponents | Int, read-only | Describes the set of the ABBYY FineReader Engine Visual Components modules available in the license as a bitwise OR combination of the AVC_ prefixed flags. ABBYY FineReader Engine Visual Components are not provided with the ABBYY FlexiCapture Engine distribution.
CounterMeasureUnit | LicenseCounterMeasuringUnitEnum, read-only | Returns information about the counter measuring unit if the license limits the number of processed pages/characters during a period. See also LimitationPeriod and UnitsPerPeriod properties.
LimitationPeriod | LicenseLimitationPeriodEnum, read-only | Returns information about the limitation period if the license limits the number of processed pages/characters during this period. See also CounterMeasureUnit and UnitsPerPeriod properties.
RemainingUnits | Int, read-only | Returns information about the remaining number of pages/characters which can be processed till the end of the current period if the license has such a limitation. When this property value reaches 0, analysis, recognition and export operations will not be possible. See also CounterMeasureUnit and LimitationPeriod properties.
SerialNumber | String, read-only | Returns the serial number of the license.
UnitsPerPeriod | Int, read-only | Returns information about the total number of pages/characters which can be processed during a period if the license has such a limitation. See also CounterMeasureUnit and LimitationPeriod properties.

Methods

Name | Description
ExpirationDate | Returns the flag indicating whether the license has an absolute or relative time limitation as well as the date at which the license will stop working.

Output parameter

This object is the output parameter of the Item method of the LicenseCollection object.

Input parameter

This object is the input parameter of the SetCurrentLicense method of the Engine object.

Related objects

See also

LicenseCollection

IEngine::SetCurrentLicense


ExpirationDate Method of License Object

ExpirationDate Method of the License Object

API Reference > Objects > License-Related Objects > License >

ExpirationDate Method of the License Object

This method returns the date at which the license will stop working if the license has an absolute or relative time limitation.

Syntax

Visual Basic .NET

Method ExpirationDate(
year As Int,
month As Int,
day As Int
) As Boolean

C++

HRESULT ExpirationDate(
int* year,
int* month,
int* day,
VARIANT_BOOL* hasTimeLimitation
);

Parameters

year

[out] Receives the year of the expiration or 0 if no time limitation is used.

month

[out] Receives the month of the expiration or 0 if no time limitation is used.

day

[out] Receives the day of the expiration or 0 if no time limitation is used.

hasTimeLimitation

[out, retval] Specifies whether a time limitation is used.

Return values

This method has no specific return values. It returns standard return values of ABBYY FlexiCapture Engine functions.

See also

License

IEngine::SetCurrentLicense


Supplementary Objects

API Reference > Objects >

Supplementary Objects

This section describes the following supplementary objects and interfaces:

·IntsCollection

·StringsCollection

·Rectangle

·Region

·MultiProcessingParams

·IUndoable

·Handle

·CollectionEvents

·SourceImageInfo


IntsCollection Object

IntsCollection Object (IIntsCollection Interface)

API Reference > Objects > Supplementary Objects >

IntsCollection Object (IIntsCollection Interface)

This object represents a collection of Int type variables. It exposes the standard collection functionality. This object serves as a storage to pass parameters to those ABBYY FlexiCapture Engine functions that require them. It may also be return value of ABBYY FlexiCapture Engine methods.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | Int | Provides access to a single element of the collection.

Methods

Name | Description
Add | Adds a new element at the end of the collection.
CopyFrom | Initializes properties of the current object with values of similar properties of another object.
DeleteAt | Removes an element from the collection.
DeleteAll | Removes all the elements from the collection.
InsertAt | Inserts a new element into the specified position in the collection.
Item | Provides access to a single element of the collection.

Output parameter

This object is the output parameter of the following methods:

·CreateIntsCollection method of the Engine object

·AddImages method of the Batch object (deprecated)

·PossibleTextTypes property of the TrainingDefinition object

·HSeparators property of the TableBlock object

Input parameter

This object is the input parameter of the following methods:

·ApplyDocumentDefinitions, ForceApplyDocumentDefinition, Recognize, StartVerification, CheckRules, Export of the Batch object (deprecated)

·Merge, Disassemble of the Documents object (deprecated)

·ApplyDocumentDefinitions, Recognize, Export, StartVerification of the Project object (deprecated)

·PossibleTextTypes property of the TrainingDefinition object

·CreateDocumentDefinitionFromImageFile method of the Engine object

·DetectBlocks method of the PageDefinition object

See also

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets


InsertAt Method of the Collection Objects

API Reference > Objects > Supplementary Objects > IntsCollection >

InsertAt Method of the Collection Objects

This method inserts a new element at the specified position in the collection.

Syntax

Visual Basic .NET

Sub InsertAt( _
Value As <CollectionType>, _
Index As Int _
)

C++

HRESULT InsertAt(
<CollectionType> Value,
int Index
);

Parameters

Value

[in] This parameter contains the newly inserted element. Its type depends on the type of collection and is described in the following table:

Collection type | Element type (Visual basic/C++)
StringsCollection | String/BSTR
IntsCollection | Int/int

Index

[in] This parameter specifies the index of the newly inserted element. If the element is inserted in place of the existing element, the elements of the collection are shifted to the right. The element may also be inserted at the end of collection, in which case the value of this parameter must be equal to the value of the Count property.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Working with Collections


StringsCollection Object

StringsCollection Object (IStringsCollection Interface)

API Reference > Objects > Supplementary Objects >

StringsCollection Object (IStringsCollection Interface)

This object represents a collection of strings. It exposes the standard collection functionality. This object serves as a storage to pass parameters to those ABBYY FlexiCapture Engine functions that require them. It may also be return value of ABBYY FlexiCapture Engine methods.

Properties

Name | Type | Description
Count | Int, read-only | Stores the number of elements in the collection.
Element | String | Provides access to a single element of the collection.

Methods

Name | Description
Add | Adds a new element at the end of the collection.
CopyFrom | Initializes properties of the current object with values of similar properties of another object.
DeleteAt | Removes an element from the collection.
DeleteAll | Removes all the elements from the collection.
InsertAt | Inserts a new element into the specified position in the collection.
Item | Provides access to a single element of the collection.

Output parameter

This object is the output parameter of the following methods:

·AddImages method and Errors, Warnings properties of the Batch object (deprecated)

·CreateStringsCollection method of the Engine object

·Errors and Warnings properties of the Project object (deprecated)

·Errors and Warnings properties of the DocumentDefinition object

·Errors and Warnings properties of the SectionDefinition object

·Errors and Warnings properties of the FieldValue object

·Errors and Warnings properties of the VerificationSession object

·GetClassNames method of the ClassificationResult object

·GetClassNames method of the ClassificationTree object

·Suggests property of the Field object

·ScanSources property of the ScanManager object

Input parameter

This object is the input parameter of the AddImages method of the Batch object. (deprecated)

Samples

cicon2 C++ (COM) code (deprecated)

// Global ABBYY FlexiCapture Engine object.
FCEngine::IEnginePtr Engine;
...
// Create the collection and add strings
FCEngine::IStringsCollectionPtr fileList = Engine->CreateStringsCollection();
fileList->Add( L"D:\\SampleImages\\0001.tif" );
fileList->Add( L"D:\\SampleImages\\0002.tif" );
fileList->Add( L"D:\\SampleImages\\0003.tif" );
...
// Use the collection as the input parameter of some method.
// Suppose we already have a pointer to the Batch object.
FCEngine::IStringsCollectionPtr passwordProtected;
FCEngine::IIntsCollectionPtr docIdList = batch->AddImages( fileList, -1, 0, 0, &passwordProtected );

See also

Working with Collections

Working with Properties

See sample: FlexiCapture Engine Code Snippets


Rectangle Object

Rectangle Object (IRectangle Interface)

API Reference > Objects > Supplementary Objects >

Rectangle Object (IRectangle Interface)

This object represents the coordinates of a rectangle.

Properties

Name | Type | Description
Bottom | Int | Specifies the coordinate of the bottom border of the rectangle.
Left | Int | Specifies the coordinate of the left border of the rectangle.
Right | Int | Specifies the coordinate of the right border of the rectangle.
Top | Int | Specifies the coordinate of the top border of the rectangle.

Output parameter

This object is the output parameter of the following methods and properties:

·CreateRectangle method of the Engine object

·Rectangle property of the CheckmarkBlock object

·Rectangle property of the CharParams object

·BoundingRectangle property of the Region object

·ContextRect property of the VerificationObject object

·ObjectRect, ObjectRectOnContextImage properties of the GroupVerificationObject object

Input parameter

This object is the input parameter of the Rectangle property of the CharParams object.

See also

Working with Properties


Region Object

Region Object (IRegion Interface)

API Reference > Objects > Supplementary Objects >

Region Object (IRegion Interface)

This is a supplementary object. It is designed to store the information about the region of an ABBYY FlexiCapture Engine block.

A region is represented as a set of rectangles positioned one under another in such a way that the top line of the lower rectangle is the bottom line of the upper one (so that the rectangles do not overlap). Some examples of correct and incorrect ABBYY FlexiCapture Engine regions are shown on the following figure:

An empty Region object can be created by calling the IEngine::CreateRegion method, and then rectangles can be added to it one-by-one by calling the AddRect method. We recommend that you add rectangles in top to bottom order, because the Region object is optimized for it, and this is the fastest way to add rectangles to it.

Properties

Name | Type | Description
Bottom | Int, read-only | Returns the coordinate of the bottom border of the specified rectangle.
BoundingRectangle | Rectangle, read-only | Returns the minimum bounding rectangle of the region.
Count | Int, read-only | Stores the number of rectangles in the region.
IsEmpty | Boolean, read-only | Checks if the region is empty.
Left | Int, read-only | Returns the coordinate of the left border of the specified rectangle.
Right | Int, read-only | Returns the coordinate of the right border of the specified rectangle.
Top | Int, read-only | Returns the coordinate of the top border of the specified rectangle.

Methods

Name | Description
AddRect | Adds an area to the region.
CopyFrom | Initializes properties of the current object with values of similar properties of another object.
HasIntersectionWithRect | Checks if the supplied rectangle has intersection with the current region.
HasIntersectionWithRegion | Checks if the supplied region has intersection with the current region.
IsEqual | Checks if the regions are equal.
IsPointInRegion | Checks if the supplied point is inside the current region.
IsRectInRegion | Checks if the supplied rectangle is inside the current region.
IsRegionInRegion | Checks if the supplied region is inside the current region.
LoadFromFile | Restores the object contents from a file on disk.
LoadFromMemory | Restores the object contents from the global memory.
MakeEmpty | Removes all rectangles from the region.
SaveToFile | Saves the object contents into a file on disk.
SaveToMemory | Saves the object contents into the global memory.

Output parameter

This object is the output parameter of the following methods and properties:

·CreateRegion method of the Engine object

·Region property of the Block object

·Region property of the BlockDefinition object

·Region property of the RecognizedCharacterInfo object

·MarkingRegion property of the TextRecognitionParams object

·ClipRegion property of the ImageModification object

·Region property of the TrainingImageObject object

·Region property of the TrainingBlock object

·Region property of the TextRegion object

Input parameter

This object is the input parameter of the following methods:

·MatchBlock method and Region property of the Block object

·AddNew method of the BlockDefinitions object

·FilterColor, FillRegionWithColor, InvertRegion methods of the ImageProcessingTools object

·ClipRegion property of the ImageModification object

·SetFieldBlock method of the TrainingPage object

·DetectBlocks method of the PageDefinition object

See also

Working with Properties

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


Bottom Property of Region Object

Bottom Property of the Region Object

API Reference > Objects > Supplementary Objects > Region >

Bottom Property of the Region Object

This property returns the coordinate of the right border of the specified rectangle.

Syntax

Visual Basic .NET

Property Bottom(Index As Int) As Int
read-only

C++

HRESULT get_Bottom(
int Index,
int* Result
);

Parameters

Index

[in] This parameter specifies the rectangle inside the region. It should be in the range from 0 to the value of the IRegion::Count property - 1.

Result

[out, retval] A pointer to int variable that receives the value of this property. Must not be NULL.

Return values

This property has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


Left Property of Region Object

Left Property of the Region Object

API Reference > Objects > Supplementary Objects > Region >

Left Property of the Region Object

This property returns the coordinate of the left border of the specified rectangle.

Syntax

Visual Basic .NET

Property Left(Index As Int) As Int
read-only

C++

HRESULT get_Left(
int Index,
int* Result
);

Parameters

Index

[in] This parameter specifies the rectangle in the region. It should be in the range from 0 to the value of the IRegion::Count property - 1.

Result

[out, retval] A pointer to int variable that receives the value of this property. Must not be NULL.

Return values

This property has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


Right Property of Region Object

Right Property of the Region Object

API Reference > Objects > Supplementary Objects > Region >

Right Property of the Region Object

This property returns the coordinate of the right border of the specified rectangle.

Syntax

Visual Basic .NET

Property Right(Index As Int) As Int
read-only

C++

HRESULT get_Right(
int Index,
int* Result
);

Parameters

Index

[in] This parameter specifies the rectangle inside the region. It should be in the range from 0 to the value of the IRegion::Count property - 1.

Result

[out, retval] A pointer to Int variable that receives the value of this property. Must not be NULL.

Return values

This property has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


Top Property of Region Object

Top Property of the Region Object

API Reference > Objects > Supplementary Objects > Region >

Top Property of the Region Object

This property returns the coordinate of the top border of the specified rectangle.

Syntax

Visual Basic .NET

Property Top(Index As Int) As Int
read-only

C++

HRESULT get_Top(
int Index,
int* Result
);

Parameters

Index

[in] This parameter specifies the rectangle inside the region. It should be in the range from 0 to the value of the IRegion::Count property - 1.

Result

[out, retval] A pointer to int variable that receives the value of this property. Must not be NULL.

Return values

This property has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


AddRect Method of Region Object

AddRect Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

AddRect Method of the Region Object

This method adds an area to the region.

Syntax

Visual Basic .NET

Sub AddRect( _
left As Int, _
top As Int, _
right As Int, _
bottom As Int _
)

C++

HRESULT AddRect(
int left,
int top,
int right,
int bottom
);

Parameters

left

[in] Specifies coordinate of the left border of the area.

top

[in] Specifies coordinate of the top border of the area.

right

[in] Specifies coordinate of the right border of the area.

bottom

[in] Specifies coordinate of the bottom border of the area.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

We recommend you to add rectangles of the region in top to bottom order, because if a rectangle is inserted between the existing ones, it may change the region structure unpredictably.

See also

Region


HasIntersectionWithRect Method of Region Object

HasIntersectionWithRect Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

HasIntersectionWithRect Method of the Region Object

This method checks if the supplied rectangle has intersection with the current region.

Syntax

Visual Basic .NET

Function HasIntersectionWithRect( _
left As Int, _
top As Int, _
right As Int, _
bottom As Int, _
) As Boolean

C++

HRESULT HasIntersectionWithRect(
int left,
int top,
int right,
int bottom,
VARIANT_BOOL* result
);

Parameters

left

[in] Specifies the coordinate of the left border of the rectangle, for which FlexiCapture Engine should check whether it has intersection with the current region.

top

[in] Specifies the coordinate of the top border of the rectangle, for which FlexiCapture Engine should check whether it has intersection with the current region.

right

[in] Specifies the coordinate of the right border of the rectangle, for which FlexiCapture Engine should check whether it has intersection with the current region.

bottom

[in] Specifies the coordinate of the bottom border of the rectangle, for which FlexiCapture Engine should check whether it has intersection with the current region.

result

[out, retval] A pointer to a Boolean variable that receives the result of checking. If the value is TRUE, the supplied rectangle has intersection with the current region.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region


HasIntersectionWithRegion Method of Region Object

HasIntersectionWithRegion Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

HasIntersectionWithRegion Method of the Region Object

This method checks if the supplied region has intersection with the current region.

Syntax

Visual Basic .NET

Function HasIntersectionWithRegion(region As Region) As Boolean

C++

HRESULT HasIntersectionWithRegion(
IRegion* region,
VARIANT_BOOL* result
);

Parameters

region

[in] Specifies the region, for which FlexiCapture Engine should check whether it has intersection with the current region.

result

[out, retval] A pointer to a Boolean variable that receives the result of checking. If the value is TRUE, the supplied region has intersection with the current region.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region


IsEqual Method of Region Object

IsEqual Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

IsEqual Method of the Region Object

This method checks if the regions are equal.

Syntax

Visual Basic .NET

Function IsEqual(region As Region) As Boolean

C++

HRESULT IsEqual(
IRegion* region,
VARIANT_BOOL* result
);

Parameters

region

[in] Specifies the region which should be compared with the current region.

result

[out, retval] A pointer to a Boolean variable that receives the result of checking. If the value is TRUE, the regions are equal.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region


IsPointInRegion Method of Region Object

IsPointInRegion Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

IsPointInRegion Method of the Region Object

This method checks if the supplied point is inside the current region.

Syntax

Visual Basic .NET

Function IsPointInRegion( _
x As Int, _
y As Int, _
) As Boolean

C++

HRESULT IsPointInRegion(
int x,
int y,
VARIANT_BOOL* result
);

Parameters

x

[in] Specifies the horizontal coordinate of the point, for which FlexiCapture Engine should check whether it is inside the current region.

y

[in] Specifies the vertical coordinate of the point, for which FlexiCapture Engine should check whether it is inside the current region.

result

[out, retval] A pointer to a Boolean variable that receives the result of checking. If the value is TRUE, the supplied point is inside the current region.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region


IsRectInRegion Method of Region Object

IsRectInRegion Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

IsRectInRegion Method of the Region Object

This method checks if the supplied rectangle is inside the current region.

Syntax

Visual Basic .NET

Function IsRectInRegion( _
left As Int, _
top As Int, _
right As Int, _
bottom As Int, _
) As Boolean

C++

HRESULT IsRectInRegion(
int left,
int top,
int right,
int bottom,
VARIANT_BOOL* result
);

Parameters

left

[in] Specifies the coordinate of the left border of the rectangle, for which FlexiCapture Engine should check whether it is inside the current region.

top

[in] Specifies the coordinate of the top border of the rectangle, for which FlexiCapture Engine should check whether it is inside the current region.

right

[in] Specifies the coordinate of the right border of the rectangle, for which FlexiCapture Engine should check whether it is inside the current region.

bottom

[in] Specifies the coordinate of the bottom border of the rectangle, for which FlexiCapture Engine should check whether it is inside the current region.

result

[out, retval] A pointer to a Boolean variable that receives the result of checking. If the value is TRUE, the supplied rectangle is inside the current region.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region


IsRegionInRegion Method of Region Object

IsRegionInRegion Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

IsRegionInRegion Method of the Region Object

This method checks if the supplied region is inside the current region.

Syntax

Visual Basic .NET

Function IsRegionInRegion(region As Region) As Boolean

C++

HRESULT IsRegionInRegion(
IRegion* region,
VARIANT_BOOL* result
);

Parameters

region

[in] Specifies the region, for which FlexiCapture Engine should check whether it is inside the current region.

result

[out, retval] A pointer to a Boolean variable that receives the result of checking. If the value is TRUE, the supplied region is inside the current region.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Region


MakeEmpty Method of Region Object

MakeEmpty Method of the Region Object

API Reference > Objects > Supplementary Objects > Region >

MakeEmpty Method of the Region Object

This method removes all rectangles from the region.

Syntax

Visual Basic .NET

Sub MakeEmpty()

C++

HRESULT MakeEmpty();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

After a call to this method, the value of the IRegion::Count property equals to 0.

See also

Region


MultiProcessingParams Object

MultiProcessingParams Object (IMultiProcessingParams Interface)

API Reference > Objects > Supplementary Objects >

MultiProcessingParams Object (IMultiProcessingParams Interface)

This object provides access to the parameters of multiple CPU cores usage.

Name

Type

Description

SharedCPUCoresMask

Int

Specifies the physical CPU cores, which can be used in shared mode of CPU cores usage, as an affinity mask. Note that only physical CPU cores are masked, but not logical. The property makes sense only if the value of the SharedCPUCoresMode property is TRUE.

By default all detected CPU cores are used.

SharedCPUCoresMode

Boolean

Specifies whether the CPU cores are used in shared mode. There are two modes of CPU cores usage: separate and shared. In separate mode ABBYY FlexiCapture Engine uses no more processes than is allowed by the license. In shared mode any number of processes can be run, but all these processes will use only the CPU cores specified by the SharedCPUCoresMask property.

To work with CPU cores in shared mode, use the following procedure for loading FlexiCapture Engine:

1.Call the InitializeEngine (InitializeEngineEx) function (or IEngineLoader::Load method) with NULL as the DeveloperSN parameter.

2.Set the SharedCPUCoresMode property to TRUE. This property should be set before the current license is specified.

3.Specify the correct license using the IEngine::SetCurrentLicense method.

By default the property is set to FALSE, which means that the separate mode is used.

Related objects

See also

Engine

Working with Properties


Handle Object

Handle Object (IHandle Interface)

API Reference > Objects > Supplementary Objects >

Handle Object (IHandle Interface)

This object provides access to the handle of a resource in memory. It is returned by some methods which provide access to a bitmap image or a memory block. The object manages memory allocation and allows you to avoid memory leaks while working with these resources.

warning Important! This interface does not support automation. This means that it does not work if FlexiCapture Engine is loaded as an out-of-process server.

The object is used in the following situations:

·If you plan to work with the resource outside FlexiCapture Engine

You can get the handle of the resource via the Handle property and work with it. In this case, if you release the Handle object, the resource is released too. Or you can get the handle and detach Handle object from it (use the Detach method). In this case, you are responsible for releasing the resource.

·If you plan to pass the resource to other methods of FlexiCapture Engine

You can get the handle of the resource as __int64 via the HandleAsInt64 property. Later you can pass the value of this property to a method of FlexiCapture Engine that requires it. This procedure can also be used when a FlexiCapture Engine method requires as an input parameter a Handle created in FineReader Engine library.

If you release the Handle object, the resource is released too. You can release the resource manually by calling CloseHandle method.

Properties

Name | Type | Description
Handle | HANDLE*, read-only | Returns the handle of the resource. You can obtain the handle via this property and work with the resource.
HandleAsInt64 | __int64, read-only | Returns the handle of the resource as __int64. You can pass the return value of this property to a method of FlexiCapture Engine as an input parameter.

Methods

Name | Description
CloseHandle | Releases the resource.
Detach | Returns the handle and detaches the object from it.

Output parameter

This object is the output parameter of the following methods:

·GetPicture method of the Image object

·SaveToMemory method of a number of objects

Samples

cicon2 C# code

FCEngine.IEngine engine;
FCEngine.IDocument doc;
// We presume that the document have been opened and images have been added to it
// Get bitmap handle of a color image plane of a document page
FCEngine.IPage page = doc.Pages[0];
FCEngine.IImageDocument imageDoc = page.Image;
FCEngine.IImage image = imageDoc.ColorImage;
FCEngine.IHandle hBitmap = image.GetPicture( null, 0 );
// Work with the bitmap
System.Drawing.Image preprocessedImage = System.Drawing.Image.FromHbitmap( hBitmap.Handle );
...
Gdi32.DeleteObject( hBitmap );

The object is used in the demo tool Code Snippets.

See also

Working with Properties


CloseHandle Method of the Handle Object

API Reference > Objects > Supplementary Objects > Handle >

CloseHandle Method of the Handle Object

This method releases the resource. This is a supplementary method, there is no need to call it before releasing the Handle object. If you release the Handle object, the resource is released automatically.

Syntax

C++

HRESULT CloseHandle();

C#

void CloseHandle();

Visual Basic .NET

Sub CloseHandle();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Handle


Detach Method of the Handle Object

API Reference > Objects > Supplementary Objects > Handle >

Detach Method of the Handle Object

This method returns the handle as void* and detaches the object from it. After this method is called, the developer is responsible for releasing the resource.

Syntax

C++

HRESULT Detach( void* Result );

C#

IntPtr Detach();

Visual Basic .NET

Function Detach() As IntPtr

Parameters

Result

[out, retval] Returns the handle of the resource as HANDLE*.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

Handle


IUndoable Interface

API Reference > Objects > Supplementary Objects >

IUndoable Interface

This is a supplementary interface. It provides the ability to undo and redo the latest operations performed on an object. If an object enables undo and redo operations, it implements IUndoable interface. This interface is useful when creating different editors.

The Document object supports this interface.

Properties

Name | Type | Description
CanRedo | Boolean, read-only | Specifies whether the Redo method can be executed for the latest undone operation which was called with the help of methods of the corresponding object.
CanUndo | Boolean, read-only | Specifies whether the Undo method can be executed for the latest operation which was called with the help of methods of the corresponding object.
IsObjectModified | Boolean, read-only | Specifies if the object has been changed since it was saved last time.
IsUndoRedoEnabled | Boolean, read-only | Specifies if undo and redo operations are enabled for the object. To change the value of this property, use the EnableUndoRedo method.

Methods

Name | Description
BeginUndoGroup | Starts forming a group of operations, which will be undone as a single operation.
EnableUndoRedo | Enables or disables undo and redo operations for the object.
EndUndoGroup | Ends forming a group of operations, which will be undone as a single operation.
Redo | Redoes the latest undone command which was called with the help of methods of the corresponding object.
Undo | Undoes the latest command which was called with the help of methods of the corresponding object.

See also

Document

See sample: FlexiCapture Engine Code Snippets


BeginUndoGroup Method of the IUndoable Interface

API Reference > Objects > Supplementary Objects > IUndoable >

BeginUndoGroup Method of the IUndoable Interface

This method starts forming a group of operations, which will be undone as a single operation. To end forming of such group, use the EndUndoGroup method.

Syntax

Visual Basic .NET

Sub BeginUndoGroup()

C++

HRESULT BeginUndoGroup();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IUndoable


EnableUndoRedo Method of the IUndoable Interface

API Reference > Objects > Supplementary Objects > IUndoable >

EnableUndoRedo Method of the IUndoable Interface

This method enables or disables undo and redo operations for the object. This method changes the value of the IUndoable::IsUndoRedoEnabled property.

Syntax

Visual Basic .NET

Sub EnableUndoRedo()

C++

HRESULT EnableUndoRedo();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IUndoable


EndUndoGroup Method of the IUndoable Interface

API Reference > Objects > Supplementary Objects > IUndoable >

EndUndoGroup Method of the IUndoable Interface

This method ends forming a group of operations, which will be undone as a single operation. Forming of such group is started with the help of the BeginUndoGroup method.

Syntax

Visual Basic .NET

Sub EndUndoGroup()

C++

HRESULT EndUndoGroup();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IUndoable


Redo Method of the IUndoable Interface

API Reference > Objects > Supplementary Objects > IUndoable >

Redo Method of the IUndoable Interface

This method redoes the latest undone command which was called with the help of methods of the corresponding object. The method can be executed only if the value of the IUndoable::CanRedo property is TRUE.

Syntax

Visual Basic .NET

Sub Redo()

C++

HRESULT Redo();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IUndoable

See sample: FlexiCapture Engine Code Snippets


Undo Method of the IUndoable Interface

API Reference > Objects > Supplementary Objects > IUndoable >

Undo Method of the IUndoable Interface

This method undoes the latest command which was called with the help of methods of the corresponding object. The method can be executed only if the value of the IUndoable::CanUndo property is TRUE.

Syntax

Visual Basic .NET

Sub Undo()

C++

HRESULT Undo();

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

See also

IUndoable

See sample: FlexiCapture Engine Code Snippets


ICollectionEvents Interface

API Reference > Objects > Supplementary Objects >

ICollectionEvents Interface

This is a callback interface that is used for reporting events from the following collection objects to the listeners:

·AssemblingErrors

·Batches

·BatchTypes

·Blocks

·Documents

·FieldInstances

·Fields

·Pages

·RuleErrors

·TableColumns

This interface is implemented on the client side. See the detailed implementation advice for your development tool in Working with Connectable Objects. Below you can find a short summary.

In C++ you need to implement the ICollectionEvents interface, obtain a connection point, and "advise" object implementing the interface to the necessary connectable object. As the interface is derived from the IUnknown interface, the client object should also implement the IUnknown methods.

Visual Basic users that want to receive notifications from one of these objects should declare the event source object of the CollectionEventsSource type WithEvents, initialize it with the required collection object and implement the Sub's similar to the following:

Private Sub eventsSource_OnCollectionChanged(ByVal Reloaded As Boolean, _
ByVal AddedItems As IntsCollection, _
ByVal DeletedItems As IntsCollection, _
ByVal ModifiedItems As IntsCollection)
...
End Sub

An object receiving notifications through this interface methods may do the following inside the methods implementation:

·Process any Windows messages, which is useful in applications having User Interface, to avoid an effect that the application "is not responding" during long recognition operations.

·Report information about adding, deleting and modifying of collection elements to the user.

Methods

Name | Description
OnCollectionChanged | Delivers to the client information about adding, deleting and modifying of collection elements.

See also

Working with Connectable Objects

Working with Collections

See sample: FlexiCapture Engine Code Snippets


OnCollectionChanged Method of the ICollectionEvents Interface

API Reference > Objects > Supplementary Objects > ICollectionEvents >

OnCollectionChanged Method of the ICollectionEvents Interface

This method is implemented on the client side. It is called by ABBYY FlexiCapture Engine for some of the methods of the collection objects. It delivers to the client information about adding, deleting and modifying of collection elements.

Syntax

Visual Basic .NET

Sub OnCollectionChanged( _
ByVal Reloaded As Boolean, _
ByVal AddedItems As IntsCollection, _
ByVal DeletedItems As IntsCollection, _
ByVal ModifiedItems As IntsCollection _
)

C++

HRESULT OnCollectionChanged(
VARIANT_BOOL Reloaded,
IIntsCollection* AddedItems,
IIntsCollection* DeletedItems,
IIntsCollection* ModifiedItems
);

Parameters

Reloaded

[in] This parameter specifies whether the collection has been reloaded.

AddedItems

[in] This parameter refers to the collection of identifiers of the elements which have been added.

DeletedItems

[in] This parameter contains the collection of identifiers of the elements which have been deleted.

ModifiedItems

[in] This parameter contains the collection of identifiers of the elements which have been modified.

Return values

This method has no specific return values. It returns the standard return values of ABBYY FlexiCapture Engine functions.

Remarks

A client implementation of this method must assure that all exceptions thrown inside the method are caught and handled and no exceptions are propagated outside the method. Propagation of an exception outside the method may lead to unpredictable results (such as program termination).

See also

ICollectionEvents

Working with Connectable Objects

Working with Collections

See sample: FlexiCapture Engine Code Snippets


SourceImageInfo Object

SourceImageInfo Object (ISourceImageInfo Interface)

API Reference > Objects > Supplementary Objects >

SourceImageInfo Object (ISourceImageInfo Interface)

This object contains extended information about the source of the image. The meaning of its properties can vary depending on your image source settings.

The PageIndex property allows you to keep record of the page numbers in multipage documents.

In the most standard situation of importing an image from file the Source and SourceDependentReference properties will contain the full path to the file.

Properties

Name

Type

Description

PageIndex

Int, read-only

Returns the index of the page within the multipage image file.

Source

String, read-only

Returns the image source name. If the image was loaded from file, this is the full path to the file.

If the hot folder was used, this property returns the name of the hot folder. (deprecated)

If you are using a custom image source, this property will return its name.

SourceDependentReference

String, read-only

Returns the reference to the image within the context of the source. If the image was loaded from file, this property will return the path to the file.

If the hot folder was used, this is the relative path to the image file from the hot folder. (deprecated)

If a custom image source was used, this property will contain the file reference which was used.

Related objects

Remarks

The semantics of the Source and SourceDependentReference properties depends strongly on the way you configure the image source. In case of custom image source, the SourceDependentReference property is completely user-defined. The file reference in the custom image source can be of any kind that the user specifies and knows how to interpret.

See also

Adding images for FlexiCapture Processor

Setting up a Custom Image Source


Alphabetical List of ABBYY FlexiCapture Engine 12 Objects

Alphabetical List of ABBYY FlexiCapture Engine 12 Objects and Interfaces

API Reference > Objects >

Alphabetical List of ABBYY FlexiCapture Engine 12 Objects and Interfaces

Below you can find the alphabetical list of the ABBYY FlexiCapture Engine 12 objects and interfaces.

Name

Description

AnchorRecognitionParams

Provides functionality for tuning parameters of anchor recognition.

AssemblingError

Corresponds to an assembly error.

AssemblingErrors

Represents a collection of assembling errors (AssemblingError objects).

BarcodeBlock

Provides access to specific properties of the recognized barcode block.

BarcodeParams

Allows you to tune type and orientation of the barcode which can be found in the document.

BarcodeRecognitionParams

Provides functionality for tuning parameters of barcode recognition.

Batch

Represents a document batch.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Batches

Represents a collection of document batches (Batch objects).

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

BatchType

Represents to a batch type.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

BatchTypes

Represents a collection of batch types (BatchType objects).

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Block

Represents a single block on the page.

BlockDefinition

Corresponds to a block of a Document Definition.

BlockDefinitions

Represents a collection of blocks of a Document Definition page (BlockDefinition objects).

Blocks

Represents a collection of blocks (Block objects). It serves as a storage of page blocks or a storage of child blocks of the block.

BlocksCollection

Represents a collection of blocks. This is a collection of references to Block objects.

CharParams

Allows you to access the parameters of a single character in recognized text.

CheckmarkBlock

Provides access to specific properties of a checkmark block.

CheckmarkGroupBlock

Represents a block which contains a group of checkmarks.

CheckmarkGroupRecognitionParams

Provides functionality for tuning parameters of checkmark group recognition.

CheckmarkRecognitionParams

Provides functionality for tuning parameters of checkmark recognition.

ClassConfidence

Represents a class to which the page can correspond and the confidence level of the match.

ClassConfidences

Contains a collection of all classes assigned by classifier to the page with corresponding confidence values.

ClassificationResult

Provides access to the result of page classification.

ClassificationTree

Represents a classifier tree.

ContextVerificationObject

Provides access to the properties of the context verification object.

DBFExportParams

Provides functionality for tuning the parameters of recognized text export to DBF format.

DenoiseFilterParams

Contains parameters of the ISO noise detected on a color photo.

Dictionary

This object is designed for working with user dictionaries

Document

Corresponds to a processing document.

DocumentDefinition

Corresponds to a Document Definition.

DocumentDefinitions

Represents a collection of Document Definitions (DocumentDefinition objects).

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Documents

Represents a collection of batch documents (Document objects).

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

DocumentsCollection

Represents a collection of document. This is a collection of references to Document objects.

Engine

This is the main ABBYY FlexiCapture Engine object.

EnumDictionaryWords

Serves for iterating words included in a user-defined dictionary.

ExcelExportParams

Provides functionality for tuning parameters of recognized text export to XLS format.

ExportParams

Provides functionality for tuning the parameters of export.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Field

Corresponds to a field of a document.

FieldChoiceValue

Corresponds to a recognized value of a choice field.

FieldDefinition

Corresponds to a field of a Document Definition.

FieldDefinitions

Represents a collection of fields of a Document Definition section (FieldDefinition objects).

FieldInstances

Represents a collection of field instances (Field objects).

FieldPictureValue

Corresponds to a value of a picture field.

Fields

Represents a collection of recognized fields (Field objects).

FieldValue

Corresponds to a recognized value of a field.

FieldValuesCollection

Represents a collection of field values (FieldValue objects).

FileExportParams

Provides functionality for tuning the parameters of export to file.

FlexibleDescription

Corresponds to a flexible description.

FlexiCaptureProcessor

This is a processor object which converts input images into the FlexiCapture documents (Document objects).

FrequencyTransformParams

Contains parameters of frequency domain transform, which can be used for image modification.

GroupLanguage

Represents a language composed of several simple languages.

GroupVerificationObject

Provides access to the properties of the group verification object.

HotFolderProfile

Represents a hot folder import profile.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

HotFolderProfiles

Represents a collection of hot folder profiles (HotFolderProfile objects).

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

Image

Represents a single "image plane" (black-and-white, color or preview) of an open image.

ImageDocument

Corresponds to an image page.

ImageExportParams

Provides functionality for tuning parameters of original images export.

ImageFile

Represents an image file.

ImageGroupingParams

Allows tuning the parameters that determine the principles of adding images to documents.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

ImageImportParams

Allows you to tune the parameters of images import.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

ImageLoadingParams

Contains different attributes specifying how an image will be prepared during adding to a batch.

ImageModification

Stores parameters of image modification.

ImageProcessingParams

Specifies how a block image is to be preprocessed before recognition.

ImageProcessingTools

Allows you to preprocess images before recognition with the FlexiCapture processor.

InprocLoader

Allows you to load ABBYY FlexiCapture Engine as an in-process server into the current process.

Language

Represents a recognition language.

License

Stores information about the current license.

LicenseCollection

Represents a collection of available (activated) licenses (License objects).

IntsCollection

Represents a collection of Int type variables.

MultiProcessingParams

Provides access to the parameters of multiprocessing and multiple CPU cores usage.

OutprocLoader

Allows you to load ABBYY FlexiCapture Engine as an out-of-process server into a separate process.

Page

Corresponds to a page of a document.

PageAnalysisParams

Provides access to parameters used for tuning the page layout analysis process.

PageDefinition

Corresponds to a page of a Document Definition.

PageDefinitions

Represents a collection of Document Definition pages (PageDefinition objects).

Pages

Represents a collection of document pages (Page objects).

PictureRecognitionParams

Provides functionality for tuning parameters of pictures recognition.

PredefinedLanguages

Represents a collection of project languages (Language objects).

Project

Corresponds to a project.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

ProjectProperties

Provides access to the properties of a project.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

RecognitionParams

Allows you to tune the recognition parameters for the block.

RecognizedCharacterInfo

Represents a variant of a character recognition.

RecognizedWordInfo

Represents a variant of a word recognition.

Rectangle

Represents the coordinates of a rectangle.

Region

Stores the information about the region of a block.

Rule

Corresponds to a rule.

RuleError

Corresponds to a rule error.

RuleErrors

Represents a collection of rule errors (RuleError objects).

ScanManager

This object exposes a set of properties and methods required to perform scanning.

ScanningProfile

Represents a scanning import profile.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

ScanningProfiles

Represents a collection of scanning profiles (ScanningProfile objects).

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

ScanSource

Exposes a set of properties and methods concerned with scanning source.

ScanSources

Represents a collection of scanning sources.

ScanSourceCapabilities

Provides access to possible settings of the scanning source.

ScanSourceSettings

This object provides access to the scanning settings of a source.

SectionDefinition

Corresponds to a section of a Document Definition.

SectionDefinitions

This object is a collection of sections of a Document Definition (SectionDefinition objects).

SectionDefinitionsCollection

This object is a collection of section definitions. This collection is a collection of references to SectionDefinition objects.

SeparatorRecognitionParams

Provides functionality for tuning parameters of separators recognition.

SimpleLanguage

Represents a simple recognition language.

SourceImageInfo

Provides information about the source of the image processed.

StaticTextRecognitionParams

Provides functionality for tuning parameters of static text recognition.

StringsCollection

Represents a collection of strings.

TableBlock

Provides access to specific properties of a table block.

TableColumn

Provides access to specific properties of a table column.

TableColumns

Represents a collection of columns (TableColumn objects).

Text

Represents recognized text.

TextBlock

Provides access to the specific properties of the text block.

TextExportParams

Provides functionality for tuning parameters of recognized text export to TXT or CSV format.

TextRecognitionParams

Allows you to tune the recognition parameters of the text.

TextRegion

Represents a background text region on the recognized page.

TextRegions

This object is a collection of text regions on the page (TextRegion objects).

TrainingBatch

Corresponds to a batch of images, which is used for training a Document Definition during creation.

TrainingBlock

Corresponds to the block on a page in a training batch.

TrainingBlocks

Represents a collection of blocks of a page in a training batch (TrainingBlock objects).

TrainingClassifier

Corresponds to a training classifier.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

TrainingDefinitions

Represents a collection of Document Definition obtained during training (TrainingDefinition objects).

TrainingDefinition

Corresponds to a Document Definition obtained during training.

TrainingField

Corresponds to a field of a Document Definition obtained during training.

TrainingFields

Represents a collection of fields of a Document Definition obtained during training (TrainingField objects).

TrainingImageObject

Corresponds to an object found on the image during preliminary recognition.

TrainingImageObjects

Represents a collection of training image objects (TrainingImageObject objects).

TrainingPage

Corresponds to a page of a training batch.

TrainingPages

Represents a collection of pages of a training batch (TrainingPage objects).

VerificationGroup

Represents a verification group.

VerificationObject

Represents a verification object.

VerificationOptions

Represents verification parameters.

VerificationSession

Corresponds to a verification session.

VerificationWorkSet

Represents a verification work set.

XMLExportParams

Provides functionality for tuning parameters of recognized text export to XML format.

IBatchEvents

This is a callback interface that is used for reporting events from the Batch object to the listeners. This interface is implemented on the client side.

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

ICollectionEvents

This is a callback interface that is used for reporting events from some collection objects to the listeners. This interface is implemented on the client side.

ICustomStorage

This interface may be supported by the objects which allow saving their state in a custom storage.

IEngineLoader

This interface is used specifically to load and unload the Engine object.

IFileAdapter

This is the interface for a file adapter. This interface and all its methods are implemented on the client side.

IImageSource

This is the interface for a custom source of images. This interface and all its methods are implemented on the client side.

IProcessingError

This is the interface for an error occurred during processing with FlexiCapture processor.

IReadStream

This is the interface for a read stream. This interface and all its methods are implemented on the client side.

IReferenceManager

This interface provides means for resolving string references. This interface and all its methods are implemented on the client side.

IScanManagerEvents

This is a callback interface that is used for interaction of the ScanManager object with its listeners. This interface is implemented on the client side.

IWorkProcessControl

This interface is used by a work process to control whether its parent process is alive.

IWriteStream

This is the interface for a write stream. This interface and all its methods are implemented on the client side.


Enumerations

API Reference >

Enumerations

This section describes ABBYY FlexiCapture Engine enumerations and flags. Below is the alphabetical list:

·AEF Flags

·AEM Flags

·AFCEM Flags

·AnchorTypeEnum

·AssemblingErrorTypeEnum

·AssemblingModeEnum

·ATT Flags

·AVC Flags

·BarcodeOrientationEnum

·BarcodeTypeEnum

·BinarizationModeEnum

·BlackSeparatorDirectionEnum

·BlackSeparatorTypeEnum

·BlockTypeEnum

·CaseRecognitionModeEnum

·CharParamsFlags

·CheckmarkTypeEnum

·CodePageEnum

·CodePageTypeEnum

·ColorToFilterEnum

·DatatypeCategoryEnum

·DBFVersionEnum

·ErrorHighlightLevelEnum

·ExportDestinationTypeEnum

·FieldMarkingTypeEnum

·FieldTypeEnum

·FieldValueTypeEnum

·FieldValueVerificationEnum

·FileExportFormatEnum

·FileMarshallingTypeEnum

·FileOverwriteRuleEnum

·FilterColorModeEnum

·FrequencyTransformTypeEnum

·GetPictureFlags

·ImageColorTypeEnum

·ImageCompressionTypeEnum

·ImageFileAssemblingRuleEnum

·ImageFileFormatEnum

·ImageTransformationEnum

·ImageTypeEnum

·LanguageCategoryEnum

·LanguageIdEnum

·LanguageLetterSetEnum

·LanguageTypeEnum

·LicenseCounterMeasuringUnitEnum

·LicenseLimitationPeriodEnum

·LockTypeEnum

·MessagesLanguageEnum

·MirrorTypeEnum

·NoiseModelTypeEnum

·PagesGroupingEnum

·PageTypeEnum

·PdfAModeEnum

·PreprocessCameraImagePresetEnum

·ProcessingErrorTypeEnum

·RecognitionModeEnum(deprecated)

·RotationTypeEnum

·RuleErrorSeverityEnum

·ScanBrightnessControlEnum

·ScanCompressionTypeEnum

·ScanOptionsInterfaceTypeEnum

·ScanPageRotationAngleEnum

·ScanPaperFeedModeEnum

·ScanPaperSizeEnum

·ScanPictureModeEnum

·ScanSourceApiTypeEnum

·ScanSourceStatusEnum

·SourceContentReuseModeEnum

·TextEncodingTypeEnum

·TextTypeEnum

·TrainingFieldTypeEnum

·VerificationObjectStateEnum

·VerificationObjectTypeEnum

·WordModelTypeEnum

·XLFileFormatEnum


AEF_ Prefixed Flags

API Reference > Enumerations >

AEF_ Prefixed Flags

The AEF_ prefixed flags are used to denote the possible export formats whose availability depends on the license. The ILicense::AvailableExportFormats property returns a bitwise OR combination of zero or more of these flags values, where each set bit indicates that the corresponding export format is available in the license.

const int AEF_RTF = 0x00000001;
const int AEF_HTML = 0x00000002;
const int AEF_XLS = 0x00000004;
const int AEF_PDF = 0x00000008;
const int AEF_DBF = 0x00000010;
const int AEF_Text = 0x00000020;
const int AEF_PDFImageOnly = 0x00000040;
const int AEF_XML = 0x00000080;
const int AEF_PPT = 0x00000100;
const int AEF_PDFA = 0x00000200;
const int AEF_PDFMRC = 0x00000400;

Elements

Flag name | Description
AEF_RTF | RTF export format. Available only in ABBYY FineReader Engine.
AEF_HTML | HTML export format. Available only in ABBYY FineReader Engine.
AEF_XLS | MS Excel export format.
AEF_PDF | PDF export format.
AEF_DBF | DBF export format.
AEF_Text | Text export format.
AEF_PDFImageOnly | PDF Image Only export format.
AEF_XML | XML export format.
AEF_PPT | PPT export format. Available only in ABBYY FineReader Engine.
AEF_PDFA | PDF/A export format.
AEF_PDFMRC | PDF MRC export format.

Used in

ILicense::AvailableExportFormats

See also

Export File Formats


AEM_ Prefixed Flags

API Reference > Enumerations >

AEM_ Prefixed Flags

The AEM_ prefixed flags are used to denote the possible ABBYY FineReader Engine modules whose availability depends on the license. The ILicense::AvailableEngineModules property returns a bitwise OR combination of zero or more of these flags values, where each set bit indicates that the corresponding ABBYY FineReader Engine module is available in the license.

const int AEM_1DBarcode = 0x00000001;
const int AEM_2DBarcodePDF417 = 0x00000002;
const int AEM_Analyze = 0x00000008;
const int AEM_CJK = 0x00000010;
const int AEM_FullTextSearchDA = 0x00000020;
const int AEM_FlexiFormsDA = 0x00000040;
const int AEM_CyrillicHandprint = 0x00000080;
const int AEM_LanguageDatabase = 0x00000100;
const int AEM_OMR = 0x00000200;
const int AEM_OpenPDF = 0x00000400;
const int AEM_UserPatterns = 0x00000800;
const int AEM_BarcodeAutolocation = 0x00002000;
const int AEM_FineReaderXIX = 0x00004000;
const int AEM_FastMode = 0x00020000;
const int AEM_ExtendedCharacterInfo = 0x00040000;
const int AEM_BalancedMode = 0x00080000;
const int AEM_Thai = 0x00100000;
const int AEM_Hebrew = 0x00200000;
const int AEM_Arabic = 0x00400000;
const int AEM_Aztec = 0x00800000;
const int AEM_QRCode = 0x01000000;
const int AEM_DataMatrix = 0x02000000;
const int AEM_Vietnamese = 0x04000000;

Elements

Name | Description
AEM_1DBarcode | 1D Barcode module.
AEM_2DBarcodePDF417 | PDF 417 module.
AEM_Analyze | Automatic Document Analysis module.
AEM_CJK | Chinese, Japanese, Korean module.
AEM_FullTextSearchDA | DA for Full-Text Indexing module.
AEM_CyrillicHandprint | Cyrillic ICR module.
AEM_LanguageDatabase | User languages module.
AEM_OMR | OMR module.
AEM_OpenPDF | PDF Opening module.
AEM_UserPatterns | User Patterns module.
AEM_BarcodeAutolocation | Barcode Autolocation module.
AEM_FineReaderXIX | FineReader XIX module.
AEM_FastMode | Fast Mode module.
AEM_ExtendedCharacterInfo | Extended Character Info module.
AEM_BalancedMode | Balanced Mode module.
AEM_Thai | Thai module.
AEM_Hebrew | Hebrew module.
AEM_Arabic | Arabic module.
AEM_Aztec | Aztec module.
AEM_QRCode | QR Code module.
AEM_DataMatrix | DataMatrix module.
AEM_Vietnamese | Vietnamese module.

Used in

ILicense::AvailableEngineModules


AFCEM_ Prefixed Flags

API Reference > Enumerations >

AFCEM_ Prefixed Flags

The AFCEM_ prefixed flags are used to denote the possible ABBYY FlexiCapture Engine modules whose availability depends on the license. The ILicense::AvailableFlexiCaptureEngineModules property returns a bitwise OR combination of zero or more of these flags values, where each set bit indicates that the corresponding ABBYY FlexiCapture Engine module is available in the license.

module AFCEM
{
const int AFCEM_FlexiCaptureEngineAPI = 0x00000001;
const int AFCEM_FlexibleLayouts = 0x00000002;
const int AFCEM_SearchablePDF = 0x00000008;
const int AFCEM_ISIS = 0x00000010;
const int AFCEM_Verification = 0x00000020;
const int AFCEM_CJK = 0x00000040;
const int AFCEM_Thai = 0x00000080;
const int AFCEM_Vietnamese = 0x00000100;
const int AFCEM_CyrillicICR = 0x00000200;
const int AFCEM_AllowUnprotectedCustomModules = 0x00000400;
const int AFCEM_Arabic = 0x00000800;
const int AFCEM_Classification = 0x00001000;
}

Elements

Name | Description
AFCEM_FlexiCaptureEngineAPI | Flexi Capture Engine API module.
AFCEM_FlexibleLayouts | FlexibleLayouts module.
AFCEM_SearchablePDF | Searchable PDF module.
AFCEM_ISIS | ISIS module. note Note: This module is deprecated and no longer available in ABBYY FlexiCapture Engine. However, ABBYY FlexiCapture supports it. This enumeration constant is retained for compatibility with ABBYY FlexiCapture.
AFCEM_CJK | Chinese, Japanese, Korean module.
AFCEM_Thai | Thai module.
AFCEM_Vietnamese | Vietnamese module.
AFCEM_CyrillicICR | Cyrillic ICR module.
AFCEM_AllowUnprotectedCustomModules | Unprotected module in Document Description limitations.
AFCEM_Arabic | Arabic module
AFCEM_Classification | Classification module

Used in

ILicense::AvailableFlexiCaptureEngineModules

See also

ABBYY FlexiCapture Engine 12 Modules


AnchorTypeEnum

API Reference > Enumerations >

AnchorTypeEnum

AnchorTypeEnum enumeration constants are used to designate the type of anchor.

typedef enum {
AT_BlackSquare,
AT_Cross,
AT_LeftTopCorner,
AT_LeftBottomCorner,
AT_RightTopCorner,
AT_RightBottomCorner,
AT_LeftTopTriangle,
AT_LeftBottomTriangle,
AT_RightTopTriangle,
AT_RightBottomTriangle,
AT_TimingMark
} AnchorTypeEnum;

Elements

Name | Description
AT_BlackSquare | Black square.
AT_Cross | Cross.
AT_LeftTopCorner | Left top corner.
AT_LeftBottomCorner | Left bottom corner.
AT_RightTopCorner | Right top corner.
AT_RightBottomCorner | Right bottom corner.
AT_LeftTopTriangle | Left top triangle.
AT_LeftBottomTriangle | Left bottom triangle.
AT_RightTopTriangle | Right top triangle.
AT_RightBottomTriangle | Right bottom triangle.
AT_TimingMark | Timing mark.

Used in

IAnchorRecognitionParams::Type


AssemblingErrorTypeEnum

API Reference > Enumerations >

AssemblingErrorTypeEnum

AssemblingErrorTypeEnum enumeration constants define types of assembly errors.

typedef enum {
AET_Unknown,
AET_ObligatoryItemOmitted,
AET_RubbishItem,
AET_AssemblingRuleError,
AET_KeyValuesMismatch,
} AssemblingErrorTypeEnum;

Elements

Name | Description
AET_Unknown | Unknown assembly error.
AET_ObligatoryItemOmitted | An obligatory element of the Document Definition is omitted in the document.
AET_RubbishItem | There is an excess or invalid element in the document.
AET_AssemblingRuleError | An assembly rule error.
AET_KeyValuesMismatch | Key values are not identical on all pages of the document.

Used in

IAssemblingError::Type


AssemblingModeEnum

API Reference > Enumerations >

AssemblingModeEnum

AssemblingModeEnum enumeration constants designate rules for assembling image pages into documents.

typedef enum {
AM_Auto,
AM_SingleDocument,
AM_DocumentPerImageFile,
AM_DocumentPerImagePage,
AM_SeparateDocumentsByEmptyPageDelimiters
} AssemblingModeEnum;

Elements

Name | Description
AM_Auto | Automatically determine document boundaries using Document Definitions.
AM_SingleDocument | Put all available page images in a single document.
AM_DocumentPerImageFile | Create a separate document for each image file.
AM_DocumentPerImagePage | Create a separate document for each image page.
AM_SeparateDocumentsByEmptyPageDelimiters | Group pages into documents by empty-page delimiters. note Note: This separation mode will not always work in the same way as when using FlexiCapture project, but will depend on the document definition and whether it is a fixed form or a flexible document. The flexible description may accept empty pages inside the document section, if the page immediately before it and the page next to it fit the description. You can use the DetectEmpty method of the ImageProcessingTools object to check if a page is empty.

Used in

IFlexiCaptureProcessor::SetAssemblingMode

See sample: FlexiCapture Processors Pool, Multi-Core Processing


ATT_ Prefixed Flags

API Reference > Enumerations >

ATT_ Prefixed Flags

The ATT_ prefixed flags are used to denote the possible text types whose availability depends on the license. The ILicense::AvailableTextTypes property returns a bitwise OR combination of zero or more of these flags values, where each set bit indicates that the corresponding text type is available in the license.

const int ATT_Normal = 0x00000001;
const int ATT_Typewriter = 0x00000002;
const int ATT_Matrix = 0x00000004;
const int ATT_Index = 0x00000008;
const int ATT_Handprinted = 0x00000010;
const int ATT_OCR_A = 0x00000020;
const int ATT_OCR_B = 0x00000040;
const int ATT_MICR_E13B = 0x00000080;
const int ATT_MICR_CMC7 = 0x00000100;
const int ATT_Fax = 0x00000200;

Elements

Flag name | Description
ATT_Normal | Normal text type (TextTypeEnum::TT_Normal)
ATT_Typewriter | Typewriter text type (TextTypeEnum::TT_Typewriter)
ATT_Matrix | Matrix text type (TextTypeEnum::TT_Matrix)
ATT_Index | Index text type (TextTypeEnum::TT_Index)
ATT_Handprinted | Handprinted text type (TextTypeEnum::TT_Handprinted)
ATT_OCR_A | OCR-A text type (TextTypeEnum::TT_OCR_A)
ATT_OCR_B | OCR-B text type (TextTypeEnum::TT_OCR_B)
ATT_MICR_E13B | E13B text type (TextTypeEnum::TT_MICR_E13B)
ATT_MICR_CMC7 | CMC-7 text type (TextTypeEnum::TT_MICR_CMC7)
ATT_Fax | Fax text type (TextTypeEnum::TT_Fax)

Used in

ILicense::AvailableTextTypes

See also

Text Types


AVC_ Prefixed Flags

API Reference > Enumerations >

AVC_ Prefixed Flags

ABBYY FineReader Engine Visual Components are not provided with the ABBYY FlexiCapture Engine distribution.

The AVC_ prefixed flags are used to denote the possible ABBYY FineReader Engine modules for Visual Components whose availability depends on the license. The ILicense::AvailableVisualComponents property returns a bitwise OR combination of zero or more of these flags values, where each set bit indicates that the corresponding Visual Component module is available in the license.

const int AVC_ImageViewer = 0x00000001;
const int AVC_DocumentViewer = 0x00000002;
const int AVC_TextEditor = 0x00000004;
const int AVC_TextValidator = 0x00000008;
const int AVC_Scanning = 0x00000010;

Elements

Flag name | Description
AVC_ImageViewer | Image viewing and blocks drawing module.
AVC_DocumentViewer | Document batch managing module.
AVC_TextEditor | Text viewing and editing module.
AVC_TextValidator | Full-text verification module.
AVC_Scanning | Scanning module.

Used in

ILicense::AvailableVisualComponents


BarcodeOrientationEnum

API Reference > Enumerations >

BarcodeOrientationEnum

BarcodeOrientationEnum enumeration constants are used to denote the types of barcode orientation.

typedef enum {
BO_Unknown = 0,
BO_Left_To_Right = 0x00000001,
BO_Down_To_Top = 0x00000002,
BO_Right_To_Left = 0x00000004,
BO_Top_To_Down = 0x00000008,
BO_Autodetect = BO_Left_To_Right | BO_Down_To_Top | BO_Right_To_Left | BO_Top_To_Down
} BarcodeOrientationEnum;

Elements

Name | Description
BO_Unknown | Denotes unknown type of barcode orientation. It may be used as the return value, if ABBYY FlexiCapture Engine has failed to detect barcode orientation.
BO_Left_To_Right | Barcode is oriented from left to right.
BO_Down_To_Top | Barcode is oriented from down to top.
BO_Right_To_Left | Barcode is oriented from right to left.
BO_Top_To_Down | Barcode is oriented from top to down.
BO_Autodetect | Detect the barcode orientation automatically.

Used in

IBarcodeBlock::Orientation

IBarcodeParams::AllowedOrientations


BarcodeTypeEnum

API Reference > Enumerations >

BarcodeTypeEnum

BarcodeTypeEnum enumeration constants are used to denote the types of barcode. Barcode of these types can be recognized in ABBYY FlexiCapture Engine or used for batches separation.

typedef enum {
BT_UnknownType = 0,
BT_Code39 = 0x00000001,
BT_Check_Code39 = 0x00000002,
BT_Interleaved25 = 0x00000004,
BT_Check_Interleaved25 = 0x00000008,
BT_EAN13 = 0x00000010,
BT_Code128 = 0x00000020,
BT_EAN8 = 0x00000040,
BT_PDF417 = 0x00000080,
BT_Codabar = 0x00000100,
BT_Check_Codabar = 0x00000200,
BT_UPCA = 0x00000400,
BT_UPCE = 0x00000800,
BT_Industrial25 = 0x00001000,
BT_IATA25 = 0x00002000,
BT_Matrix25 = 0x00004000,
BT_Code93 = 0x00008000,
BT_PostNet = 0x00010000,
BT_UCC128 = 0x00020000,
BT_Patch = 0x00040000,
BT_Code39_without_Asterisk = 0x00080000,
BT_Aztec = 0x00200000,
BT_DataMatrix = 0x00400000,
BT_QRCode = 0x00800000,
BT_AustraliaPost = 0x01000000,
BT_Code32 = 0x02000000,
BT_IntelligentMail = 0x04000000,
BT_MaxiCode = 0x08000000,
BT_Autodetect = BT_Code39 | BT_Interleaved25 | BT_EAN13 | BT_Code128 | BT_EAN8
| BT_PDF417 | BT_Codabar | BT_UPCE | BT_Industrial25 | BT_IATA25 | BT_Matrix25
| BT_Code93 | BT_PostNet | BT_UCC128 | BT_Patch | BT_Aztec | BT_DataMatrix | BT_QRCode
| BT_AustraliaPost | BT_Code32 | BT_IntelligentMail | BT_MaxiCode
} BarcodeTypeEnum;

Elements

Name | Description
BT_UnknownType | Denotes unknown type of barcode.
BT_Code39 | Barcode in Code 39 standard.
BT_Check_Code39 | Barcode in Code 39 standard with a check sum.
BT_Interleaved25 | Barcode in Interleaved 2 of 5 standard.
BT_Check_Interleaved25 | Barcode in Interleaved 2 of 5 standard with a check sum.
BT_EAN13 | Barcode in EAN 13 standard.
BT_Code128 | Barcode in Code 128 standard.
BT_EAN8 | Barcode in EAN 8 standard.
BT_PDF417 | Barcode in PDF417 standard.
BT_Codabar | Barcode in Codabar standard.
BT_Check_Codabar | Barcode in Codabar standard with a check sum.
BT_UPCA | Barcode in UPC-A standard.
BT_UPCE | Barcode in UPC-E standard.
BT_Industrial25 | Barcode in Industrial 2 of 5 standard.
BT_IATA25 | Barcode in IATA 2 of 5 standard.
BT_Matrix25 | Barcode in Matrix 2 of 5 standard.
BT_Code93 | Barcode in Code 93 standard.
BT_PostNet | Barcode in PostNet standard.
BT_UCC128 | Barcode in GS1-128 standard. Former correct name UCC-128.
BT_Patch | Barcode in Patch standard.
BT_Code39_without_Asterisk | Barcode in Code 39 standard without asterisk.
BT_Aztec | Barcode in Aztec standard.
BT_DataMatrix | Barcode in Data Matrix standard.
BT_QRCode | Barcode in QR Code standard.
BT_Autodetect | Forces ABBYY FlexiCapture Engine to automatically detect the barcode type. This constant can be used as the value of the IBarcodeParams::AllowedTypes property only.
BT_AustraliaPost | Barcode in AustraliaPost standard.
BT_Code32 | Barcode in Code 32 (Pharmacode) standard.
BT_IntelligentMail | Barcode in IntelligentMail standard.
BT_MaxiCode | Barcode in MaxiCode standard.

Used in

IImageGroupingParams::BarcodeType

IBarcodeParams::AllowedTypes

IBarcodeBlock::Type

See also

Barcode Types


BinarizationModeEnum

API Reference > Enumerations >

BinarizationModeEnum

BinarizationModeEnum enumeration constants define the modes of image binarization.

typedef enum {
BM_Default,
BM_Fast,
BM_ByThreshold,
BM_Version9
} BinarizationModeEnum;

Elements

Name | Description
BM_Default | Binarization that is used internally by default.
BM_Fast | Fast binarization. note Note: This mode is not available for photos. Texture cannot be smoothed.
BM_ByThreshold | Binarization by threshold. The threshold value is specified as a parameter in the ImageProcessingTools::Binarize method. note Note: This mode is not available for photos. Texture cannot be smoothed.
BM_Version9 | Binarization that was used in ABBYY FlexiCapture Engine 9.0. note Note: Texture cannot be smoothed in this mode.

Used in

ImageProcessingTools::Binarize


BlackSeparatorDirectionEnum

API Reference > Enumerations >

BlackSeparatorDirectionEnum

BlackSeparatorDirectionEnum enumeration constants specify the available types of direction for a black separator.

typedef enum {
BSD_Vertical,
BSD_Horizontal
} BlackSeparatorDirectionEnum;

Elements

Name | Description
BSD_Vertical | Vertical separator.
BSD_Horizontal | Horizontal separator.

Used in

ISeparatorRecognitionParams::Direction


BlackSeparatorTypeEnum

API Reference > Enumerations >

BlackSeparatorTypeEnum

BlackSeparatorTypeEnum enumeration constants are used to designate the type of separator.

typedef enum {
BST_Solid,
BST_Dotted,
BST_White
} BlackSeparatorTypeEnum;

Elements

Name | Description
BST_Solid | Solid separator.
BST_Dotted | Dotted separator.
BST_White | White separator.

Used in

ISeparatorRecognitionParams::Type


BlockTypeEnum

API Reference > Enumerations >

BlockTypeEnum

BlockTypeEnum enumeration constants are used to designate the type of a block.

typedef enum {
BT_Separator,
BT_Anchor,
BT_StaticText,
BT_Text,
BT_Barcode,
BT_Checkmark,
BT_CheckmarkGroup,
BT_Table,
BT_Picture,
BT_Section,
BT_Page,
BT_StaticBarcode,
BT_Exclusion,
BT_Unknown
} BlockTypeEnum;

Elements

Name | Description
BT_Separator | Designates a separator block. The separator is either a horizontal or a vertical line on the image.
BT_Anchor | Designates an anchor block. The anchors are special elements of form design, which are used to match Document Definitions. A black square, rectangle, cross or corner may be an anchor. Anchors are normally located in the corners of a form.
BT_StaticText | Designates a static text block. It corresponds to any static text on the image – headers, explanatory signatures.
BT_Text | Designates a text block. It corresponds to an image zone which is recognized as text.
BT_Barcode | Designates a barcode block. It corresponds to an image zone which is recognized as barcode.
BT_Checkmark | Designates a checkmark block. It corresponds to an image zone which is recognized as checkmark.
BT_CheckmarkGroup | Designates a checkmarks group block. It corresponds to an image zone which is recognized as checkmarks group. A checkmark group block unites several checkmark blocks.
BT_Table | Designates a table block. It corresponds to an image zone which is recognized as table.
BT_Picture | Designates a picture block. It corresponds to an image zone which is treated as a picture.
BT_Section | Designates the block of a section (a logically complete part of a document).
BT_Page | Designates the block of a page. The whole page can be considered as the top-level block which contains all the blocks of the page.
BT_StaticBarcode | Designates the block of a static barcode. This is a barcode which is used for Document Definition matching or identification. No data is extracted from it.
BT_Exclusion | Designates the block of an exclusion. The exclusion is a region which is excluded from recognition, for example, a region with explanatory text that complicates data extraction from the field.
BT_Unknown | Unknown block type.

Used in

IBlock::Type

IRecognitionParams::Type

IBlockDefinition::Type

IBlockDefinition::AddNew

IEngine::CreateDocumentDefinitionFromImageFile

IPageDefinition::DetectBlocks


CaseRecognitionModeEnum

API Reference > Enumerations >

CaseRecognitionModeEnum

CaseRecognitionModeEnum enumeration constants denote the modes of recognition for letter case.

typedef enum {
CRM_AutoCase,
CRM_SmallCase,
CRM_CapitalCase
} CaseRecognitionModeEnum;

Elements

Name | Description
CRM_AutoCase | This value tells ABBYY FlexiCapture Engine to automatically detect the case of letters and to keep it in the output text.
CRM_SmallCase | The recognized text will be set in lowercase letters.
CRM_CapitalCase | The recognized text will be set in capitals.

Used in

ITextRecognitionParams::CaseRecognitionMode


CharParamsFlags flags

API Reference > Enumerations >

CharParamsFlags flags

The CharParamsFlags flags are used as a mask in some methods of the Text object. The mask is an OR combination of these flags values and define what properties of the CharParams object should be taken into account in these methods. For the IText::SetCharParams method they define what character properties should be set, and for the IText::NextGroup method they define parameters separating a group of symbols.

module CharParamsFlags
{
const int CFL_EditedByUser = 0x00000002;
const int CFL_EditedByRules = 0x00000004;
const int CFL_Suspicious = 0x00000008;
const int CFL_NeedsVerification = 0x00000010;
const int CFL_NeedsGroupVerification = 0x00000020;
const int CFL_Rectangle = 0x00000040;
const int CFL_LanguageId = 0x00000080;
const int CFL_PageID = 0x00000400;
};

Elements

Flag name | Description
CFL_EditedByUser | The ICharParams::IsEditedByUser property should be taken into account.
CFL_EditedByRules | The ICharParams::IsEditedByRules property should be taken into account.
CFL_Suspicious | The ICharParams::IsSuspicious property should be taken into account.
CFL_NeedsVerification | The ICharParams::NeedsVerification property should be taken into account.
CFL_NeedsGroupVerification | The ICharParams::NeedsGroupVerification property should be taken into account.
CFL_Rectangle | The ICharParams::Rectangle property should be taken into account.
CFL_LanguageId | The ICharParams::LanguageId property should be taken into account.
CFL_PageID | The ICharParams::PageID property should be taken into account.

Used in

IText::SetCharParams

IText::NextGroup


CheckmarkTypeEnum

API Reference > Enumerations >

CheckmarkTypeEnum

CheckmarkTypeEnum enumeration constants are used to designate the type of checkmark.

typedef enum {
CMT_Square,
CMT_Empty,
CMT_Custom
} CheckmarkTypeEnum;

Elements

Name | Description
CMT_Square | Checkmarks in squares.
CMT_Empty | Checkmarks against an empty background.
CMT_Custom | The checkmark has a non-standard form.

Used in

ICheckmarkRecognitionParams::CheckmarkType

ICheckmarkGroupRecognitionParams::CheckmarkType


CodePageEnum

API Reference > Enumerations >

CodePageEnum

CodePageEnum enumeration represents ABBYY FlexiCapture Engine internal representation of code pages.

typedef enum {
CP_Null = 0,
CP_Latin = 1,
CP_Cyrillic = 2,
CP_EasternEuropean = 3,
CP_Baltic = 4,
CP_Turkish = 5,
CP_US_MSDOS = 6,
CP_LatinI_MSDOS = 7,
CP_Russian_MSDOS = 8,
CP_Baltic_MSDOS = 9,
CP_Turkish_IBM = 10,
CP_Slavic_MSDOS = 11,
CP_Greek = 12,
CP_Greek_737 = 13,
CP_Greek_869 = 14,
CP_Latin_ISO = 16,
CP_EasternEuropean_ISO = 17,
CP_Turkish_ISO = 18,
CP_Baltic_ISO = 19,
CP_Cyrillic_ISO = 20,
CP_Greek_ISO = 21,
CP_KOI8 = 22,
CP_Tatar = 23,
CP_Tatar_MSDOS = 24,
CP_Roman_Macintosh = 25,
CP_Greek_Macintosh = 26,
CP_Cyrillic_Macintosh = 27,
CP_Ukrainian_Macintosh = 28,
CP_Latin2_Macintosh = 29,
CP_Icelandic_Macintosh = 30,
CP_Turkish_Macintosh = 31,
CP_Croatian_Macintosh = 32,
CP_Armenian = 33,
CP_Armenian_MSDOS = 34,
CP_Armenian_Macintosh = 35,
CP_Hebrew = 36,
CP_Hebrew_MSDOS = 37,
CP_Hebrew_Macintosh = 38,
CP_Hebrew_ISO = 39,
CP_Latin5_ISO = 41,
CP_Cyrillic_MSDOS = 42,
CP_Bashkir = 43,
CP_Chinese_Simpl_GB = 44,
CP_Chinese_Simpl_Mac = 45,
CP_Chinese_Trad_Big = 46,
CP_Chinese_Trad_Mac = 47,
CP_Japan_Mac = 48,
CP_Japan_SJIS = 49,
CP_Korean = 50,
CP_Korean_Johab = 51,
CP_Korean_Mac = 52,
CP_Mathematical = 53,
CP_Digits = 54,
CP_Thai = 59,
CP_Thai_Macintosh = 60
} CodePageEnum;

Elements

Name | Description
CP_Null | Invalid code page.
CP_Armenian | Windows Armenian
CP_Armenian_MSDOS | DOS Armenian
CP_Armenian_Macintosh | Macintosh Armenian
CP_Baltic | Windows Baltic (1257)
CP_Baltic_ISO | ISO Baltic (8859-4)
CP_Baltic_MSDOS | DOS Baltic (775)
CP_Bashkir | Windows Bashkir
CP_Chinese_Simpl_GB | Chinese Simplified (GB2312)
CP_Chinese_Simpl_Mac | Chinese Simplified (Mac)
CP_Chinese_Trad_Big | Chinese Traditional (Big5)
CP_Chinese_Trad_Mac | Chinese Traditional (Mac)
CP_Croatian_Macintosh | Macintosh Croatian
CP_Cyrillic | Windows Cyrillic (1251)
CP_Cyrillic_ISO | ISO Cyrillic (8859-5)
CP_Cyrillic_Macintosh | Macintosh Cyrillic
CP_Cyrillic_MSDOS | DOS Cyrillic (855)
CP_Digits | Digits
CP_EasternEuropean | Windows Central Europe (1250)
CP_EasternEuropean_ISO | ISO Central Europe (8859-2)
CP_Greek | Windows Greek (1253)
CP_Greek_737 | DOS Greek (737)
CP_Greek_869 | DOS Modern Greek (869)
CP_Greek_ISO | ISO Greek (8859-7)
CP_Greek_Macintosh | Macintosh Greek 1
CP_Hebrew | Windows Hebrew (1255)
CP_Hebrew_ISO | ISO Hebrew (8859-8)
CP_Hebrew_Macintosh | Macintosh Hebrew
CP_Hebrew_MSDOS | DOS Hebrew (862)
CP_Icelandic_Macintosh | Macintosh Icelandic
CP_Japan_Mac | Japanese (Mac)
CP_Japan_SJIS | Japanese (Shift-JIS)
CP_KOI8 | Russian KOI8
CP_Korean | Korean
CP_Korean_Johab | Korean (Johab)
CP_Korean_Mac | Korean (Mac)
CP_Latin | Windows Western Europe (1252)
CP_Latin_ISO | ISO Latin 1 (8859-1)
CP_Latin2_Macintosh | Macintosh Latin 2
CP_Latin5_ISO | ISO Turkish (8859-9)
CP_LatinI_MSDOS | DOS Multilingual Latin 1 (850)
CP_Mathematical | Mathematical symbols
CP_Roman_Macintosh | Macintosh Roman
CP_Russian_MSDOS | DOS Russian (866)
CP_Slavic_MSDOS | DOS Latin 2 (852)
CP_Tatar | Windows Tatar
CP_Tatar_MSDOS | DOS Tatar
CP_Thai | Windows Thai (874)
CP_Thai_Macintosh | Macintosh Thai
CP_Turkish | Windows Turkish ( 1254)
CP_Turkish_IBM | DOS Turkish (857)
CP_Turkish_ISO | ISO Latin 3 (8859-3)
CP_Turkish_Macintosh | Macintosh Turkish
CP_Ukrainian_Macintosh | Macintosh Ukrainiane
CP_US_MSDOS | DOS United States (437)

Used in

ITextExportParams::CodePage

IDBFExportParams::CodePage


CodePageTypeEnum

API Reference > Enumerations >

CodePageTypeEnum

CodePageTypeEnum enumeration constants specify different types of code pages that are supported for the export of recognized text to external formats.

typedef enum {
CPT_OEM,
CPT_ANSI,
CPT_Unicode
} CodePageTypeEnum;

Elements

Name | Description
CPT_OEM | OEM code page. To specify particular code page, use the ITextExportParams::CodePage property.
CPT_ANSI | ANSI code page. To specify particular code page, use the ITextExportParams::CodePage property.
CPT_Unicode | Unicode code page. To specify encoding type of a Unicode file, use the ITextExportParams::EncodingType property.

Used in

ITextExportParams::CodePageType


ColorToFilterEnum

API Reference > Enumerations >

ColorToFilterEnum

ColorToFilterEnum enumeration constants describe the colors of the objects which can be removed from the image.

typedef enum {
CTF_Red,
CTF_Green,
CTF_Blue,
CTF_Yellow
} ColorToFilterEnum;

Elements

Name | Description
CTF_Red | Red tint.
CTF_Green | Green tint.
CTF_Blue | Blue tint.
CTF_Yellow | Yellow tint.

Used in

IImageProcessingTools::FilterColor

See sample: Color Stamps Removal


DatatypeCategoryEnum

API Reference > Enumerations >

DatatypeCategoryEnum

DatatypeCategoryEnum enumeration constants describe different categories of data that may be recognized using a recognition language.

typedef enum {
TC_NotSpecified,
TC_Number,
TC_DateTime,
TC_Currency,
TC_HumanProperName,
TC_Address,
TC_WellKnownCode
} DatatypeCategoryEnum;

Elements

Name | Description
TC_NotSpecified | Text of any type not described below.
TC_Number | Numerical value.
TC_DateTime | Date, time, or their components.
TC_Currency | Amount of money (e.g. a number with a currency code).
TC_HumanProperName | Name, surname, patronymic, or any other part of a human name, and their combinations.
TC_Address | Address. It may contain the name of the country, region, city, zip code, etc.
TC_WellKnownCode | Well known code, e.g. ISBN, passport number, social security number, bank investment contract, etc.

Used in

ILanguage::DatatypeCategory

See sample: FlexiCapture Engine Code Snippets


DBFVersionEnum

API Reference > Enumerations >

DBFVersionEnum

DBFVersionEnum enumeration constants are used to specify different DBF versions.

typedef enum {
DBFV_Version3,
DBFV_Version4,
DBFV_Version5
} DBFVersionEnum;

Elements

Name | Description
DBFV_Version3 | DBase III version.
DBFV_Version4 | DBase IV version.
DBFV_Version5 | DBase 5 version.

Used in

IDBFExportParams::DBFVersion


ErrorHighlightLevelEnum

API Reference > Enumerations >

ErrorHighlightLevelEnum

ErrorHighlightLevelEnum enumeration constants are used to set the confidence level at which the recognized characters will be marked as suspicious (the ICharParams::IsSuspicious property is set to TRUE for such character).

typedef enum {
EHL_None,
EHL_Scanty,
EHL_Standard,
EHL_Thorough,
EHL_AllText
} ErrorHighlightLevelEnum;

Elements

Name | Description
EHL_None | Do not highlight uncertain characters at all. This means that no character in the recognized text will have the property ICharParams::IsSuspicious set to TRUE.
EHL_Scanty | Highlight only very uncertain characters.
EHL_Standard | Sets standard highlight level.
EHL_Thorough | Highlight each character that is uncertain.
EHL_AllText | Highlight all characters in the text.

Used in

ITextRecognitionParams::ErrorHighlightLevel


ExportDestinationTypeEnum

API Reference > Enumerations >

ExportDestinationTypeEnum

ExportDestinationTypeEnum enumeration constants are used to set the output data destination.

typedef enum {
EDT_File,
EDT_Database,
EDT_Script,
EDT_SharePoint
} ExportDestinationTypeEnum;

Elements

Name | Description
EDT_File | Export to file.
EDT_Database | Export to database. This destination type is not currently supported.
EDT_Script | Export described with a script. This value is used, only if an export script is specified in the corresponding Document Definition.
EDT_SharePoint | Export to SharePoint. This destination type is not currently supported.

Used in

IExportParams::DestinationType

IEngine::CreateExportParams


FieldMarkingTypeEnum

API Reference > Enumerations >

FieldMarkingTypeEnum

FieldMarkingTypeEnum enumeration constants describe available types of field marking for handprinted text.

note Note: The number of character cells for a recognized block you can set with the help of the ITextRecognitionParams::CellsCount property.

typedef enum {
FMT_SimpleText,
FMT_UnderlinedText,
FMT_TextInFrame,
FMT_GreyBoxes,
FMT_CharBoxSeries,
FMT_SimpleComb,
FMT_CombInFrame,
FMT_PartitionedFrame
} FieldMarkingTypeEnum;

Elements

Name | Description
FMT_SimpleText | This value denotes the plain text:
FMT_UnderlinedText | This value specifies that the text is underlined:
FMT_TextInFrame | This value specifies that the text is enclosed in a frame:
FMT_GreyBoxes | This value specifies that the text is located in white fields on a gray background:
FMT_CharBoxSeries | This value specifies that the field where the text is located is a set of separate boxes:
FMT_SimpleComb | This value specifies that the field where the text is located is a comb:
FMT_CombInFrame | This value specifies that the field where the text is located is a comb and that this comb is also the bottom line of a frame:
FMT_PartitionedFrame | This value specifies that the field where the text is located is a frame and this frame is split by vertical lines:

Used in

ITextRecognitionParams::FieldMarkingType


FieldTypeEnum

API Reference > Enumerations >

FieldTypeEnum

FieldTypeEnum enumeration constants define different types of fields.

typedef enum {
FT_TextField,
FT_DateTimeField,
FT_NumberField,
FT_PictureField,
FT_Checkmark,
FT_CheckmarkGroup,
FT_Group,
FT_PageGroup,
FT_Table,
FT_Document,
FT_CurrencyField,
FT_LinkField,
FT_DocumentLinkField,
FT_MirrorField
} FieldTypeEnum;

Elements

Name | Description
FT_TextField | Text field, contains descriptions and explanatory text, such as field names, instructions on how to fill out the form, etc.
FT_DateTimeField | Field containing date and time, is meant to input date when filling in the form.
FT_NumberField | Field containing numbers, is meant to input figures when filling in the form.
FT_PictureField | Picture field, contains an image.
FT_Checkmark | Checkmark field, in which a mark (e.g. a check, a cross, etc.) is made by the person filling out the form.
FT_CheckmarkGroup | Checkmark group field, unites several checkmark fields. Checkmark groups are usually accompanied by explanatory text that explains the type of choice to be made.
FT_Group | Field group, several logically connected fields.
FT_PageGroup | Page group, several logically connected pages.
FT_Table | Table field, contains columns of elements of the same type. Each table field has child fields corresponding to the columns of a table.
FT_Document | Document field. The whole document can be considered as the top-level field which contains all the data fields of the document.
FT_CurrencyField | Field containing currency values.
FT_LinkField | Field containing a link to a field of another document.
FT_DocumentLinkField | Field containing a link to another document.
FT_MirrorField | Field containing a link to a field of the same document.

Used in

IField::Type

IFieldDefinition::Type


FieldValueTypeEnum

API Reference > Enumerations >

FieldValueTypeEnum

FieldValueTypeEnum enumeration constants define different types of field values.

typedef enum {
FVT_None,
FVT_Text,
FVT_DateTime,
FVT_Number,
FVT_Picture,
FVT_Boolean,
FVT_Choice,
FVT_Currency
} FieldValueTypeEnum;

Elements

Name | Description
FVT_None | Undefined type.
FVT_Text | Text. Recognized value can be received: ·as Text object using the IFieldValue::AsText property ·as String using the IFieldValue::AsString property
FVT_DateTime | Date and time. Recognized value can be received: ·as DATE using the IFieldValue::AsDateTime property ·as Text object using the IFieldValue::AsText property ·as String using the IFieldValue::AsString property
FVT_Number | Numerical value. Recognized value can be received: ·as Double using the IFieldValue::AsDouble property ·as Integer using the IFieldValue::AsInteger property ·as Text object using the IFieldValue::AsText property ·as String using the IFieldValue::AsString property
FVT_Picture | Picture. Recognized value can be received as FieldPictureValue object using the IFieldValue::AsPicture property.
FVT_Boolean | Boolean value. Recognized value can be received: ·as Boolean using the IFieldValue::AsBoolean property ·as String using the IFieldValue::AsString property. The returned string contains localized "Yes" or "No".
FVT_Choice | Choice value. Recognized value can be received: ·as FieldChoiceValue object using the IFieldValue::AsChoice property. ·as String using the IFieldValue::AsString property. The returned string contains the value of the selected choice.
FVT_Currency | Currency value. Recognized value can be received: ·as Text object using the IFieldValue::AsText property ·as String using the IFieldValue::AsString property

Used in

IFieldValue::Type

IFieldDefinition::ValueType

ITextRecognitionParams::CreateEmbeddedLanguageByDataType

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer, Mobile Data Capture, Color Stamps Removal, Redaction


FieldValueVerificationEnum

API Reference > Enumerations >

FieldValueVerificationEnum

FieldValueVerificationEnum enumeration constants define the principle how to submit field value for verification.

typedef enum {
FVV_Never,
FVV_RecognizedWithUncertainCharacters,
FVV_Always
} FieldValueVerificationEnum;

Elements

Name | Description
FVV_Never | Characters in a field are not submitted for verification.
FVV_RecognizedWithUncertainCharacters | Field characters are submitted for verification if they have been recognized uncertainly.
FVV_Always | All field characters are submitted for verification.

Used in

IFieldDefinition::MarkFieldValueForVerification


FileExportFormatEnum

API Reference > Enumerations >

FileExportFormatEnum

FileExportFormatEnum enumeration constants define different file formats in which ABBYY FlexiCapture Engine can save the recognized text.

typedef enum {
FEF_Text,
FEF_CSV,
FEF_DBF,
FEF_XML,
FEF_XLS
} FileExportFormatEnum;

Elements

Name | Description
FEF_Text | TXT format. The parameters of a file in this format are tuned through the TextExportParams object.
FEF_CSV | CSV format. The parameters of a file in this format are tuned through the TextExportParams object.
FEF_DBF | DBF format. The parameters of a file in this format are tuned through the DBFExportParams object.
FEF_XML | XML format. The parameters of a file in this format are tuned through the XMLExportParams object.
FEF_XLS | XLS (Microsoft Excel) format. The parameters of a file in this format are tuned through the ExcelExportParams object.

Used in

IFileExportParams::FileFormat

See sample: FlexiCapture Engine Code Snippets


FileMarshallingTypeEnum

API Reference > Enumerations >

FileMarshallingTypeEnum

FileMarshallingTypeEnum enumeration constants define how the information, provided by the adapter is handled.

typedef enum {
FMT_MarshalByReference,
FMT_MarshalByValue,
FMT_LocalPath
} FileMarshallingTypeEnum;

Elements

Name | Description
FMT_MarshalByReference | Marshal by reference.
FMT_MarshalByValue | Marshal by value.
FMT_LocalPath | Path on the local file system. Not marshaled. Required to be valid only during the lifetime of the particular instance of the adapter.

Used in

IFileAdapter::GetMarshallingType

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Processors Pool, Multi-Core Processing


FileOverwriteRuleEnum

API Reference > Enumerations >

FileOverwriteRuleEnum

FileOverwriteRuleEnum enumeration constants define rules to be used during export if a file with the same name already exists.

typedef enum {
FOR_Replace,
FOR_Append,
FOR_Rename
} FileOverwriteRuleEnum;

Elements

Name | Description
FOR_Replace | Replace the existing file with the new one.
FOR_Append | Append the new file to the existing file.
FOR_Rename | Rename the new file.

Used in

IFileExportParams::FileOverwriteRule


FilterColorModeEnum

API Reference > Enumerations >

FilterColorModeEnum

FilterColorModeEnum enumeration constants describe the types of color objects which can be removed from the image.

typedef enum {
FCM_Full,
FCM_Background,
FCM_Stamp
} FilterColorModeEnum;

Elements

Name | Description
FCM_Full | All color object on the image.
FCM_Background | Color objects in the background.
FCM_Stamp | Color stamps and signatures.

Used in

IImageProcessingTools::FilterColor

See sample: Color Stamps Removal


FrequencyTransformTypeEnum

API Reference > Enumerations >

FrequencyTransformTypeEnum

FrequencyTransformTypeEnum enumeration constants define the types of frequency domain transforms, which can be applied to an image.

typedef enum {
FTT_MultiplyByCoefficient,
FTT_AutocontrastByCoefficient
} FrequencyTransformTypeEnum;

Elements

Name | Description
FTT_MultiplyByCoefficient | Multiply signal at different levels of detail by the specified coefficients. The coefficients are specified via the CoefficientAtLevel property of the FrequencyTransformParams object.
FTT_AutocontrastByCoefficient | Apply autocontrast at different levels of detail using the specified coefficients. The coefficients are specified via the CoefficientAtLevel property of the FrequencyTransformParams object.

Used in

IFrequencyTransformParams::Type


GetPictureFlags

API Reference > Enumerations >

GetPictureFlags

The GP_ prefixed flags are used as a mask in some methods of the Image object. The mask is an OR combination of these flags' values and define how the image should be converted in this method.

module GetPictureFlags
{
const int GP_ScaleToGray = 0x00000001;
const int GP_ReduceToHighColor = 0x00000002;
const int GP_ReduceToGray = 0x00000004;
}

Elements

Flag name | Description
GP_ScaleToGray | For black-and-white image page and the stretch ratio <1, as defined by the ImageModification object, a gray bitmap will be created and returned by the method.
GP_ReduceToHighColor | For color image page the presence of this flag reduces the number of its colors to 65536, that corresponds to high color.
GP_ReduceToGray | For color image page a gray bitmap will be created and returned by the method.

Used in

IImage::EstimateBitmapSize

IImage::GetPicture


ImageColorTypeEnum

API Reference > Enumerations >

ImageColorTypeEnum

ImageColorTypeEnum enumeration constants are used to describe different color types of an image.

typedef enum {
ICT_BlackWhite,
ICT_Gray,
ICT_Color
} ImageColorTypeEnum;

Elements

Name | Description
ICT_BlackWhite | Black-and-white image.
ICT_Gray | Gray image.
ICT_Color | Color image.

Used in

IImageExportParams::ColorType

IImageDocument::ImageColorType

IImage::ImageColorType

See sample: FlexiCapture Engine Code Snippets


ImageCompressionTypeEnum

API Reference > Enumerations >

ImageCompressionTypeEnum

ImageCompressionTypeEnum enumeration constants are used to set the image compression type.

typedef enum {
ICT_ABBYYLossless,
ICT_Lzw,
ICT_Jpeg,
ICT_PackBits,
ICT_Png,
ICT_Uncompressed,
ICT_Zip,
ICT_CcittGroup4,
ICT_Default
} ImageCompressionTypeEnum;

Elements

Name | Description
ICT_ABBYYLossless | Lossless compression. This compression type provides a medium image file size and the quality of the original image.
ICT_Lzw | LZW compression.
ICT_Jpeg | JPEG compression.
ICT_PackBits | PackBits compression.
ICT_Png | PNG compression.
ICT_Uncompressed | Uncompressed.
ICT_Zip | ZIP compression.
ICT_CcittGroup4 | CCITT4 compression.
ICT_Default | Sets the compression type automatically corresponding to the selected file format.

Used in

IImageExportParams::CompressionType

IImage::WriteToFile

See sample: FlexiCapture Engine Code Snippets


ImageFileAssemblingRuleEnum

API Reference > Enumerations >

ImageFileAssemblingRuleEnum

ImageFileAssemblingRuleEnum enumeration constants define assembling rules for saving images.

typedef enum {
IFAR_FilePerImage,
IFAR_FilePerDocument,
IFAR_Embed
} ImageFileAssemblingRuleEnum;

Elements

Name | Description
IFAR_FilePerImage | Each image is saved in a separate file.
IFAR_FilePerDocument | Images of one document are saved in one file.
IFAR_Embed | Images are saved into the data file or database.

Used in

IImageExportParams::FileAssemblingRule

See sample: FlexiCapture Engine Code Snippets


ImageFileFormatEnum

API Reference > Enumerations >

ImageFileFormatEnum

ImageFileFormatEnum enumeration constants are used to specify the format of image file.

typedef enum {
IFF_Bmp,
IFF_Dcx,
IFF_Jpg,
IFF_J2k,
IFF_JBIG2,
IFF_Pcx,
IFF_Pdf,
IFF_Png,
IFF_Tif,
IFF_Gif,
IFF_DjVu
} ImageFileFormatEnum;

Elements

Name | Description
IFF_Bmp | BMP format.
IFF_Dcx | DCX format.
IFF_Jpg | JPEG format.
IFF_J2k | JPEG 2000 format.
IFF_JBIG2 | JBIG2 format.
IFF_Pcx | PCX format.
IFF_Pdf | PDF format.
IFF_Png | PNG format.
IFF_Tif | TIFF format.
IFF_Gif | GIF format. ABBYY FlexiCapture Engine 12 does not save image files in this format.
IFF_DjVu | DjVu format. ABBYY FlexiCapture Engine 12 does not save image files in this format.

Used in

IImageDocument::SourceImageFileFormat

IImageExportParams::Format

IImage::WriteToFile

See sample: FlexiCapture Engine Code Snippets


ImageTransformationEnum

API Reference > Enumerations >

ImageTransformationEnum

ImageTransformationEnum enumeration constants are used to denote possible image transformations.

typedef enum {
IT_RotateClockwise,
IT_RotateUpsideDown,
IT_RotateCounterclockwise,
IT_Despeckle,
IT_Invert,
IT_FlipHorizontalAxis,
IT_FlipVerticalAxis
} ImageTransformationEnum;

Elements

Name | Description
IT_RotateClockwise | Rotate 90 degrees clockwise.
IT_RotateUpsideDown | Rotate upside down, or 180 degrees.
IT_RotateCounterclockwise | Rotate 90 degrees counterclockwise or 270 degrees clockwise.
IT_Despeckle | Despeckle image.
IT_Invert | Invert image colors.
IT_FlipHorizontalAxis | Flip image vertically, i.e. mirror image around the horizontal axis.
IT_FlipVerticalAxis | Flip image horizontally, i.e. mirror image around the vertical axis.

Used in

IPage::TransformImage


ImageTypeEnum

API Reference > Enumerations >

ImageTypeEnum

ImageTypeEnum enumeration constants are used to convert coordinates between different image planes of the ImageDocument object. The latter object represents an open image. The open image contains only one page for each color type (black-and-white or color). It is either deskewed or non-deskewed depending on the values of the CorrectSkewXXX properties of the ImageLoadingParams object.

typedef enum {
IT_Base,
IT_Modified,
IT_Preview
} ImageTypeEnum;

Elements

Name | Description
IT_Base | Non-deskewed image.
IT_Modified | Fully deskewed image.
IT_Preview | Preview image.

Used in

IImageDocument::ConvertCoordinates


LanguageCategoryEnum

API Reference > Enumerations >

LanguageCategoryEnum

LanguageCategoryEnum enumeration constants are used to describe the category of a recognition language.

typedef enum {
LC_UserDefinedLanguage,
LC_CoreLanguage,
LC_AdditionalLanguage,
LC_ConstructedLanguage,
LC_FormalLanguage
} LanguageCategoryEnum;

Elements

Name | Description
LC_UserDefinedLanguage | User defined language.
LC_CoreLanguage | Widespread language, such as English or Russian.
LC_AdditionalLanguage | Additional languages, not so widely used as core languages. Examples are Afrikaans or Albanian.
LC_ConstructedLanguage | Artificial language such as Esperanto or Interlingua.
LC_FormalLanguage | Programming language or another formal language. For example, Basic and C/C++ languages belong to this category.

Used in

ILanguage::LanguageCategory

See sample: FlexiCapture Engine Code Snippets


LanguageIdEnum

API Reference > Enumerations >

LanguageIdEnum

LanguageIdEnum enumeration represents ABBYY FlexiCapture Engine internal representation of language ID.

typedef enum {
LI_Abkhaz = 185,
LI_Adyghe = 186,
LI_Afrikaans = 68,
LI_Agul = 188,
LI_Albanian = 69,
LI_Altaic = 189,
LI_ArmenianEastern = 131,
LI_ArmenianGrabar = 133,
LI_ArmenianWestern = 132,
LI_Awar = 187,
LI_Aymara = 190,
LI_AzeriCyrillic = 137,
LI_AzeriLatin = 138,
LI_Bashkir = 191,
LI_Basque = 70,
LI_Belarusian = 71,
LI_Bemba = 192,
LI_Blackfoot = 193,
LI_Breton = 116,
LI_Bugotu = 194,
LI_Bulgarian = 12,
LI_Buryat = 195,
LI_Catalan = 72,
LI_Chamorro = 196,
LI_Chechen = 124,
LI_ChineseHongKong = 102,
LI_ChineseMacau = 141,
LI_ChinesePRC = 98,
LI_ChineseSingapore = 99,
LI_ChineseTaiwan = 101,
LI_Chukcha = 197,
LI_Chuvash = 198,
LI_Corsican = 199,
LI_CrimeanTatar = 126,
LI_Croatian = 60,
LI_Crow = 200,
LI_Czech = 13,
LI_Danish = 14,
LI_Dargwa = 201,
LI_Dungan = 202,
LI_DutchBelgian = 52,
LI_DutchStandard = 51,
LI_EnglishAustralian = 3,
LI_EnglishBelize = 10,
LI_EnglishCanadian = 4,
LI_EnglishCaribbean = 9,
LI_EnglishIreland = 6,
LI_EnglishJamaica = 8,
LI_EnglishLaw = 290,
LI_EnglishMedical = 293,
LI_EnglishNewZealand = 5,
LI_EnglishPhilippines = 142,
LI_EnglishSouthAfrica = 7,
LI_EnglishTrinidad = 11,
LI_EnglishUnitedKingdom = 2,
LI_EnglishUnitedStates = 1,
LI_EnglishZimbabwe = 143,
LI_EskimoCyrillic = 203,
LI_EskimoLatin = 211,
LI_Esperanto = 117,
LI_Estonian = 73,
LI_Even = 204,
LI_Evenki = 205,
LI_Faeroese = 74,
LI_Fijian = 118,
LI_Finnish = 41,
LI_FrenchBelgian = 43,
LI_FrenchCanadian = 44,
LI_FrenchLuxembourg = 46,
LI_FrenchMonaco = 145,
LI_FrenchStandard = 42,
LI_FrenchSwiss = 45,
LI_Frisian = 206,
LI_Friulian = 207,
LI_GaelicScottish = 146,
LI_Gagauz = 208,
LI_Galician = 209,
LI_Ganda = 210,
LI_GermanAustrian = 17,
LI_GermanLaw = 291,
LI_GermanLiechtenstein = 19,
LI_GermanLuxembourg = 18,
LI_GermanMedical = 294,
LI_GermanNewSpelling = 134,
LI_GermanNewSpellingLaw = 292,
LI_GermanNewSpellingMedical = 295,
LI_GermanStandard = 15,
LI_GermanSwiss = 16,
LI_Greek = 20,
LI_Guarani = 212,
LI_Hani = 213,
LI_Hausa = 282,
LI_Hawaiian = 119,
LI_Hebrew = 104,
LI_Hungarian = 47,
LI_Icelandic = 48,
LI_Ido = 214,
LI_Indonesian = 75,
LI_Ingush = 215,
LI_Interlingua = 216,
LI_Irish = 108,
LI_ItalianStandard = 49,
LI_ItalianSwiss = 50,
LI_Japanese = 95,
LI_Kabardian = 129,
LI_Kalmyk = 217,
LI_KarachayBalkar = 219,
LI_Karakalpak = 218,
LI_Kasub = 220,
LI_Kawa = 221,
LI_Kazakh = 153,
LI_Khakas = 222,
LI_Khanty = 223,
LI_Kikuyu = 224,
LI_Kirgiz = 225,
LI_Kongo = 228,
LI_Korean = 96,
LI_KoreanJohab = 97,
LI_Koryak = 229,
LI_Kpelle = 230,
LI_Kumyk = 231,
LI_Kurdish = 232,
LI_Lak = 234,
LI_Lappish = 157,
LI_Latin = 120,
LI_Latvian = 76,
LI_Lezgin = 235,
LI_Lithuanian = 77,
LI_LithuanianClassic = 158,
LI_Luba = 236,
LI_Macedonian = 105,
LI_Malagasy = 237,
LI_MalayBruneiDarussalam = 112,
LI_MalayMalaysian = 111,
LI_Malinke = 238,
LI_Maltese = 160,
LI_Mansi = 239,
LI_Maori = 113,
LI_Mari = 240,
LI_Maya = 241,
LI_Miao = 242,
LI_Minankabaw = 243,
LI_Mohawk = 244,
LI_Mongol = 127,
LI_Mordvin = 245,
LI_Nahuatl = 246,
LI_Nenets = 248,
LI_Nivkh = 249,
LI_Nogay = 250,
LI_NorwegianBokmal = 53,
LI_NorwegianNynorsk = 54,
LI_Null = 0,
LI_Nyanja = 251,
LI_Occidental = 252,
LI_Ojibway = 253,
LI_OldEnglish = 285,
LI_OldFrench = 287,
LI_OldGerman = 286,
LI_OldItalian = 288,
LI_OldSpanish = 289,
LI_Ossetic = 128,
LI_Papiamento = 255,
LI_PidginEnglish = 256,
LI_Polish = 55,
LI_PortugueseBrazilian = 56,
LI_PortugueseStandard = 57,
LI_Provencal = 121,
LI_Quechua = 257,
LI_RhaetoRomanic = 115,
LI_Romanian = 58,
LI_RomanianMoldavia = 114,
LI_Romany = 258,
LI_Ruanda = 259,
LI_Rundi = 260,
LI_Russian = 59,
LI_RussianMoldavia = 167,
LI_RussianOldSpelling = 135,
LI_Samoan = 122,
LI_Selkup = 261,
LI_SerbianCyrillic = 62,
LI_SerbianLatin = 61,
LI_Shona = 262,
LI_Sioux = 263,
LI_Slovak = 63,
LI_Slovenian = 67,
LI_Somali = 264,
LI_Sorbian = 170,
LI_Sotho = 265,
LI_SpanishArgentina = 31,
LI_SpanishBolivia = 36,
LI_SpanishChile = 33,
LI_SpanishColombia = 29,
LI_SpanishCostaRica = 25,
LI_SpanishDominicanRepublic = 27,
LI_SpanishEcuador = 32,
LI_SpanishElSalvador = 37,
LI_SpanishGuatemala = 24,
LI_SpanishHonduras = 38,
LI_SpanishMexican = 22,
LI_SpanishModernSort = 23,
LI_SpanishNicaragua = 39,
LI_SpanishPanama = 26,
LI_SpanishParaguay = 35,
LI_SpanishPeru = 30,
LI_SpanishPuertoRico = 40,
LI_SpanishTraditionalSort = 21,
LI_SpanishUruguay = 34,
LI_SpanishVenezuela = 28,
LI_Sunda = 266,
LI_Swahili = 106,
LI_Swazi = 267,
LI_Swedish = 64,
LI_SwedishFinland = 65,
LI_Tabassaran = 268,
LI_Tagalog = 109,
LI_Tahitian = 270,
LI_Tajik = 269,
LI_Tatar = 107,
LI_Thai = 100,
LI_Tinpo = 271,
LI_Tongan = 272,
LI_Tswana = 176,
LI_Tun = 273,
LI_Turkish = 66,
LI_Turkmen = 274,
LI_Tuvin = 275,
LI_Udmurt = 276,
LI_UighurCyrillic = 277,
LI_UighurLatin = 296,
LI_Ukrainian = 78,
LI_User = 110,
LI_UzbekCyrillic = 179,
LI_UzbekLatin = 180,
LI_Visayan = 278,
LI_Welsh = 123,
LI_Wolof = 279,
LI_Xhosa = 182,
LI_Yakut = 280,
LI_Yiddish = 130,
LI_Zapotec = 281,
LI_Zulu = 183
} LanguageIdEnum;

Used in

IDocumentDefinition::DefaultWritingStyle

ITextRecognitionParams::WritingStyle

ICharParams::LanguageId

ISimpleLanguage::LanguageId

IRecognizedCharacterInfo::LanguageId


LanguageLetterSetEnum

API Reference > Enumerations >

LanguageLetterSetEnum

LanguageLetterSetEnum enumeration constants are used to describe different letter sets of a simple language. Letter sets are the sets of characters that are allowed or disallowed in certain places inside the words in a specified language.

typedef enum {
LLS_Alphabet,
LLS_Prefixes,
LLS_Suffixes,
LLS_IgnorableLetters,
LLS_SubscriptAlphabet,
LLS_SuperscriptAlphabet
} LanguageLetterSetEnum;

Elements

Name | Description
LLS_Alphabet | This value denotes a letter set that includes the full alphabet of the language.
LLS_Prefixes | This constant denotes a letter set that covers the punctuation marks that may be found immediately before words. Among these characters there may be ", (, { and so on.
LLS_Suffixes | This constant denotes a letter set that covers the punctuation marks that may be found immediately after words. Among these characters there may be !, ", ), } and so on.
LLS_IgnorableLetters | This value denotes a letter set that includes the characters that may be found inside a word, but are ignored during the internal spelling check.
LLS_SubscriptAlphabet | This value denotes a letter set that includes the characters allowed inside the words of the language as subscripts.
LLS_SuperscriptAlphabet | This value denotes a letter set that includes the characters allowed inside the words of the language as superscripts.

Used in

ISimpleLanguage::LetterSet

See sample: FlexiCapture Engine Code Snippets


LanguageTypeEnum

API Reference > Enumerations >

LanguageTypeEnum

LanguageTypeEnum enumeration constants are used to describe the type of a recognition language.

typedef enum {
LT_Simple,
LT_Group
} LanguageTypeEnum;

Elements

Name | Description
LT_Simple | Simple language, e.g. English, Russian.
LT_Group | A language, which is composed of several simple languages, e.g. English and Russian.

Used in

ILanguage::Type

ITextRecognitionParams::CreateEmbeddedLanguage

See sample: FlexiCapture Engine Code Snippets


LicenseCounterMeasuringUnitEnum

API Reference > Enumerations >

LicenseCounterMeasuringUnitEnum

LicenseCounterMeasuringUnitEnum enumeration constants are used to denote the units (pages or characters) used by the ABBYY FlexiCapture Engine license to limit the number of the recognition and export operations during a period.

typedef enum {
LCM_Pages,
LCM_Characters
} LicenseCounterMeasuringUnitEnum;

Elements

Name | Description
LCM_Pages | The limitation counts pages.
LCM_Characters | The limitation counts characters.

Used in

ILicense::CounterMeasureUnit


LicenseLimitationPeriodEnum

API Reference > Enumerations >

LicenseLimitationPeriodEnum

LicenseLimitationPeriodEnum enumeration constants are used to denote the period during which the ABBYY FlexiCapture Engine license limits the number of the recognition and export operations.

typedef enum {
LLP_Hour,
LLP_Day,
LLP_Week,
LLP_Month,
LLP_Year,
LLP_Infinite
} LicenseLimitationPeriodEnum;

Elements

Name | Description
LLP_Hour | The remaining units counter is refreshed at the beginning of each hour.
LLP_Day | The remaining units counter is refreshed at the beginning of each day.
LLP_Week | The remaining units counter is refreshed at the beginning of each week.
LLP_Month | The remaining units counter is refreshed at the beginning of each month.
LLP_Year | The remaining units counter is refreshed at the beginning of each year.
LLP_Infinite | The remaining units counter is never refreshed.

Used in

ILicense::LimitationPeriod


LockTypeEnum

API Reference > Enumerations >

LockTypeEnum

LockTypeEnum enumeration constants are used to denote the state of the document.

typedef enum {
LT_None,
LT_Read,
LT_ReadWrite
} LockTypeEnum;

Elements

Name

Description

LT_None

For the document, which belongs to some project, this lock type designates that the document is closed. Not all the properties and methods of such document are available.

The documents, received from the FlexiCapture processor, always have this lock type. Such documents are already in memory, and you can work with them without calling Open, Close, or Save methods.

LT_Read

The document is open for reading. You can view the structure and parameters of the document, but cannot edit them.

LT_ReadWrite

The document is open for reading and writing. You can edit its structure, parameters, etc.

Used in

IDocument::LockType


MessagesLanguageEnum

API Reference > Enumerations >

MessagesLanguageEnum

MessagesLanguageEnum enumeration constants describe different interface languages that ABBYY FlexiCapture Engine supports. Some languages defined by this enumeration are not currently supported, and the specific set of languages that are supported by your system depends on the availability of resource modules. If you try to set a messages language that is not supported by ABBYY FlexiCapture Engine, it will automatically be changed to the language with the lowest code available.

note Note: The locale for the selected messages language must be installed on the computer.

typedef enum {
ML_English = 0,
ML_Russian = 1,
ML_German = 2,
ML_French = 3,
ML_Spanish = 5,
ML_Italian = 6,
ML_Polish = 15,
ML_Czech = 16,
ML_Hungarian = 17,
ML_PortugueseBrazilian = 27
} MessagesLanguageEnum;

Elements

Name | Description
ML_English | English language
ML_Russian | Russian language
ML_German | German language
ML_French | French language
ML_Spanish | Spanish language
ML_Italian | Italian language
ML_Polish | Polish language
ML_Czech | Czech language
ML_Hungarian | Hungarian language
ML_PortugueseBrazilian | Portuguese (Brazil) language

Used in

IEngine::MessagesLanguage


MirrorTypeEnum

API Reference > Enumerations >

MirrorTypeEnum

MirrorTypeEnum enumeration constants are used to denote whether the image should be mirrored horizontally or vertically..

typedef enum {
MT_Horizontal,
MT_Vertical
} MirrorTypeEnum;

Elements

Name | Description
MT_Horizontal | Mirror horizontally (around the vertical axis).
MT_Vertical | Mirror vertically (around the horizontal axis).

Used in

IImageProcessingTools::MirrorImage


NoiseModelTypeEnum

API Reference > Enumerations >

NoiseModelTypeEnum

NoiseModelTypeEnum enumeration constants are used to describe the type of noise on an image.

typedef enum {
NMT_Normal,
NMT_Correlated
} NoiseModelTypeEnum;

Elements

Name | Description
NMT_Normal | Additive white Gaussian noise. This is a standard noise model for normal photos taken with low ISO settings and having not high JPEG compression. This mode is useful for most of the photos.
NMT_Correlated | Strongly correlated noise. This mode can be useful, for example, for the JPEG photos with high compression settings.

Used in

IImageProcessingTools::CreateDenoiseFilterParamsByImage


PagesGroupingEnum

API Reference > Enumerations >

PagesGroupingEnum

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
PagesGroupingEnum enumeration constants are used to denote the types of grouping images into documents.

typedef enum {
PG_NotGroupPages,
PG_GroupPagesByPagesCount,
PG_GroupPagesByOriginFile,
PG_GroupPagesByEmptyPageDelimiters,
PG_GroupPagesByBarcode
} PagesGroupingEnum;

Elements

Name | Description
PG_NotGroupPages | Do not group images. All the images will be added to one document.
PG_GroupPagesByPagesCount | Group every n image pages into a separate document. The number of pages (n) is specified in the IImageGroupingParams::PagesCount property.
PG_GroupPagesByOriginFile | Group image pages as in the original files. Pages from each image file will be grouped into a separate document.
PG_GroupPagesByEmptyPageDelimiters | Use blank pages to group images. A new document will be created at each blank page found in the image file. The blank pages can then be deleted (set the IImageGroupingParams::DeleteDelimiters property to TRUE if required).
PG_GroupPagesByBarcode | Use barcodes to group images. A new document will be created at each page with a barcode of the specified type or value (set the BarcodeType and BarcodeValue properties of the ImageGroupingParams object). The barcode pages can then be deleted (set the IImageGroupingParams::DeleteDelimiters property to TRUE if required).

Used in

IImageGroupingParams::GroupingRule


PageTypeEnum

API Reference > Enumerations >

PageTypeEnum

PageTypeEnum enumeration constants are used to designate the types of pages.

typedef enum {
PT_Unknown,
PT_Delimeter,
PT_MeetsDocumentDefinition,
PT_Attachment
} PageTypeEnum;

Elements

Name | Description
PT_Unknown | Unknown page type.
PT_Delimeter | Documents delimiter. This is usually an empty page or a page with barcode which was used for image grouping.
PT_MeetsDocumentDefinition | Analyzed page for which some page definition was applied.
PT_Attachment | Annex page. This page does not contain fields, but is included in document assembly. No data is extracted from these pages, but they may be saved as images or PDF searchable files.

Used in

IPage::Type

IClassificationResult::PageType


PdfAModeEnum

API Reference > Enumerations >

PdfAModeEnum

PdfAModeEnum enumeration constants are used to set the compliance with PDF/A standard for output PDF files.

typedef enum {
PDFAM_1a,
PDFAM_1b,
PDFAM_2a
PDFAM_2b,
PDFAM_2u,
PDFAM_3a,
PDFAM_3b,
PDFAM_3u
} PdfAModeEnum;

Elements

Name | Description
PDFAM_1a | The recognized text should be exported to PDF/A-1a format.
PDFAM_1b | The recognized text should be exported to PDF/A-1b format.
PDFAM_2a | The recognized text should be exported to PDF/A-2a format.
PDFAM_2b | The recognized text should be exported to PDF/A-2b format.
PDFAM_2u | The recognized text should be exported to PDF/A-2u format.
PDFAM_3a | The recognized text should be exported to PDF/A-3a format.
PDFAM_3b | The recognized text should be exported to PDF/A-3b format.
PDFAM_3u | The recognized text should be exported to PDF/A-3u format.

Used in

IImageExportParams


PreprocessCameraImagePresetEnum

API Reference > Enumerations >

PreprocessCameraImagePresetEnum

PreprocessCameraImagePresetEnum enumeration constants are used to denote possible types of preprocessing settings.

typedef enum {
PCIP_General,
PCIP_iPhone_ISBN
} PreprocessCameraImagePresetEnum;

Elements

Name | Description
PCIP_General | Mild noise reduction and contrast enhancement, which will improve recognition of camera images in most cases.
PCIP_iPhone_ISBN | Preprocessing optimized for ISBN-like images (see sample images) from all models of iPhone.

Used in

IImageProcessingTools::PreprocessCameraImage


ProcessingErrorTypeEnum

API Reference > Enumerations >

ProcessingErrorTypeEnum

ProcessingErrorTypeEnum enumeration constants define the types of processing errors.

typedef enum {
PET_ImageFileNotFound,
PET_ImageFileAccessDenied,
PET_ImageFileBadFormat,
PET_WaitingForMoreImages
} ProcessingErrorTypeEnum;

Elements

Name | Description
PET_ImageFileNotFound | Image file was not found.
PET_ImageFileAccessDenied | Access to the image file is denied.
PET_ImageFileBadFormat | Image file is corrupt or has unrecognized format.
PET_WaitingForMoreImages | All available images in the queue have been processed. Waiting for more images.

Used in

IProcessingError::GetType


RecognitionModeEnum

API Reference > Enumerations >

RecognitionModeEnum

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
RecognitionModeEnum enumeration constants are used to denote recognition modes.

typedef enum {
RM_ReApplyDocumentDefinitions,
RM_ReRecognizeAll,
RM_ReRecognizeMinimal
} RecognitionModeEnum;

Elements

Name | Description
RM_ReApplyDocumentDefinitions | The full recognition mode. Initially a Document Definition is selected using anchors and identifiers, then the Document Definition is applied, and finally data recognition in document regions matching field regions in the selected Document Definition is performed.
RM_ReRecognizeAll | Document definitions are not matched, only recognition of all the documents is performed. We recommend that you use this mode if the document definitions have already been matched and have not been changed before recognition.
RM_ReRecognizeMinimal | Only the batches which were changed, or documents with changed Document Definitions are recognized.

Used in

IBatch::Recognize

IProject::Recognize

See sample: FlexiCapture Engine Code Snippets, FlexiCapture Project Viewer


RotationTypeEnum

API Reference > Enumerations >

RotationTypeEnum

RotationTypeEnum enumeration constants are used to denote types of rotation that can be performed upon image.

typedef enum {
RT_NoRotation,
RT_Clockwise,
RT_Counterclockwise,
RT_Upsidedown
} RotationTypeEnum;

Elements

Name | Description
RT_NoRotation | This value denotes no rotation.
RT_Clockwise | Rotation 90 degrees clockwise.
RT_Counterclockwise | Rotation 90 degrees counterclockwise or 270 degrees clockwise.
RT_Upsidedown | Rotation upside down, or 180 degrees.

Used in

IImageLoadingParams::ImageRotation

IImageProcessingParams::RotationType

IPage::ImageRotation

IImageDocument::ImageRotation

IImageProcessingTools::DetectOrientationByText

IImageProcessingTools::RotateImageByRotationType


RuleErrorSeverityEnum

API Reference > Enumerations >

RuleErrorSeverityEnum

RuleErrorSeverityEnum enumeration constants are used to set the severity of a rule error.

typedef enum {
RES_CriticalError,
RES_Warning
} RuleErrorSeverityEnum;

Elements

Name | Description
RES_CriticalError | Critical error.
RES_Warning | Warning.

Used in

IRuleError::Severity


ScanBrightnessControlEnum

API Reference > Enumerations >

ScanBrightnessControlEnum

ScanBrightnessControlEnum enumeration constants are used to set brightness control modes.

typedef enum {
SBC_Fine,
SBC_Scanner,
SBC_Manual
}ScanBrightnessControlEnum;

Elements

Name | Description
SBC_Fine | Brightness is controlled by ABBYY FlexiCapture Engine.
SBC_Scanner | Brightness is controlled by the scanner.
SBC_Manual | Brightness is set by the user.

Used in

IScanSourceSettings::BrightnessControl

IScanSourceCapabilities::BrightnessControls


ScanCompressionTypeEnum

API Reference > Enumerations >

ScanCompressionTypeEnum

ScanCompressionTypeEnum enumeration constants are used to specify modes of image compression after scanning. The compression type depends also on colority.

typedef enum {
SCT_NoCompression,
SCT_CcittGroup3,
SCT_CcittGroup4,
SCT_JpegJfif
}ScanCompressionTypeEnum;

Elements

Name | Description
SCT_NoCompression | The image is to be saved without any compression.
SCT_CcittGroup3 | Black-and-white TIFF compression with CCITT Group 3.
SCT_CcittGroup4 | Black-and-white TIFF compression with CCITT Group 4.
SCT_JpegJfif | Gray or color TIFF compression with JPEG protocol (JFIF).

Used in

IScanSourceSettings::CompressionType

IScanSourceCapabilities::Compressions


ScanOptionsInterfaceTypeEnum

API Reference > Enumerations >

ScanOptionsInterfaceTypeEnum

ScanOptionsInterfaceTypeEnum enumeration constants are used to specify the interface type for the scanning options.

typedef enum {
SOIT_None,
SOIT_Twain,
SOIT_Fine
}ScanOptionsInterfaceTypeEnum;

Elements

Name | Description
SOIT_Fine | This constant is deprecated. Using it will cause an error.
SOIT_None | If this parameter is used no interface will be displayed. The settings specified in the IScanManager::ScanSourceSettings property will be used for scanning.
SOIT_Twain | Displays the Twain interface.

Used in

IScanManager::ScanOptionsInterfaceType

IScanManager::FindScanSources

IScanSource::BeginScan

IScanSource::Scan

IScanSource::AvailableOptionsInterfaceTypes


ScanPageRotationAngleEnum

API Reference > Enumerations >

ScanPageRotationAngleEnum

ScanPageRotationAngleEnum enumeration constants are used to set the image rotation angle (once the page has been scanned).

typedef enum {
SPRA_Rotation0,
SPRA_Rotation90,
SPRA_Rotation180,
SPRA_Rotation270
}ScanPageRotationAngleEnum;

Elements

Name | Description
SPRA_Rotation0 | No rotation.
SPRA_Rotation90 | The image to be rotated by 90 degrees.
SPRA_Rotation180 | The image to be rotated by 180 degrees.
SPRA_Rotation270 | The image to be rotated by 270 degrees.

Used in

IScanSourceSettings::RotationAngle

IScanSourceCapabilities::RotationAngles


ScanPaperFeedModeEnum

API Reference > Enumerations >

ScanPaperFeedModeEnum

ScanPaperFeedModeEnum enumeration constants are used to describe the paper feeder modes of the scanner.

typedef enum {
SPFM_Flatbed,
SPFM_AutoFeeder
}ScanPaperFeedModeEnum;

Elements

Name | Description
SPFM_Flatbed | The scanner has a flatbed.
SPFM_AutoFeeder | The scanner has an automatic document feeder.

Used in

IScanSourceCapabilities::PaperFeedModes


ScanPaperSizeEnum

API Reference > Enumerations >

ScanPaperSizeEnum

ScanPaperSizeEnum enumeration constants are used to set size of the scanned page.

typedef enum {
SPS_None,
SPS_BroadSheet,
SPS_Tabloid,
SPS_Double,
SPS_Fanfold,
SPS_Legal,
SPS_Folio,
SPS_Letter,
SPS_Slide,
SPS_Executive,
SPS_Statement,
SPS_GermanLegalFanfold,
SPS_GermanFanfold,
SPS_A0,
SPS_A1,
SPS_A2,
SPS_A3,
SPS_A4,
SPS_A5,
SPS_A6,
SPS_A7,
SPS_A8,
SPS_B1_ISO,
SPS_B2_ISO,
SPS_B3_ISO,
SPS_B4_ISO,
SPS_B5_ISO,
SPS_B6_ISO,
SPS_B4_JIS,
SPS_B5_JIS,
SPS_B6_JIS,
SPS_C3,
SPS_C4,
SPS_C5,
SPS_C6,
SPS_RA2,
SPS_RA3,
SPS_RA4,
SPS_QUARTO,
SPS_DL,
SPS_Envelope14,
SPS_Envelope12,
SPS_Envelope11,
SPS_Envelope10,
SPS_Envelope9,
SPS_EnvelopeCheck,
SPS_EnvelopeMonarch,
SPS_Custom
}ScanPaperSizeEnum;

Elements

Name | Description | Page size in inches | Page size in mm
SPS_None | Page size is not defined. |  |
SPS_BroadSheet | Page size is Broad Sheet. | 18 x 24 |
SPS_Tabloid | Page size is Tabloid. | 11 x 17 | 279.4 x 431.8
SPS_Double | Page size is Double. | 11 x 17 | 279.4 x 431.8
SPS_Fanfold | Page size is Fanfold. | 11 x 14.88 |
SPS_Legal | Page size is Legal. | 8.5 x 14 | 216 x 356
SPS_Folio | Page size is Folio. | 8.5 x 13 |
SPS_Letter | Page size is Letter. | 8.5 x 11 | 216 x 279
SPS_Slide | Page size is Slide. | 7.33 x 11 |
SPS_Executive | Page size is Executive. | 7.25 x 10.5 | 184 x 266
SPS_Statement | Page size is Statement. | 5.5 x 8.5 | 140 x 216
SPS_GermanLegalFanfold | Page size is German Legal Fanfold. | 8.5 x 13 |
SPS_GermanFanfold | Page size is German Fanfold. | 8.5 x 12 |
SPS_A0 | Page size is А0. | 33.1 x 46.8 | 841 x 1189
SPS_A1 | Page size is A1. | 23.4 x 33.1 | 594 x 841
SPS_A2 | Page size is A2. | 16.5 x 23.4 | 420 x 594
SPS_A3 | Page size is A3. | 11.69 x 16.54 | 297 x 420
SPS_A4 | Page size is A4. | 8.27 x 11.69 | 210 x 297
SPS_A5 | Page size is A5. | 5.83 x 8.27 | 148 x 210
SPS_A6 | Page size is A6. | 4.1 x 5.8 | 105 x 148
SPS_A7 | Page size is A7. | 2.9 x 4.1 | 74 x 105
SPS_A8 | Page size is A8. | 2.0 x 2.9 | 52 x 74
SPS_B1_ISO | Page size is B1 (ISO). | 27.8 x 39.4 | 707 x 1000
SPS_B2_ISO | Page size is B2 (ISO). | 19.7 x 27.8 | 500 x 707
SPS_B3_ISO | Page size is B3 (ISO). | 13.9 x 19.7 | 353 x 500
SPS_B4_ISO | Page size is B4 (ISO). | 9.8 x 13.9 | 250 x 353
SPS_B5_ISO | Page size is B5 (ISO). | 6.9 x 9.8 | 176 x 250
SPS_B6_ISO | Page size is B6 (ISO). | 4.9 x 6.9 | 125 x 176
SPS_B4_JIS | Page size is B4 (JIS). | 10.12 x 14.33 | 257 x 364
SPS_B5_JIS | Page size is B5 (JIS). | 7.17 x 10.12 | 182 x 257
SPS_B6_JIS | Page size is B6 (JIS). | 5.06 x 7.17 | 128 x 182
SPS_C3 | Page size is C3. | 12.8 x 18.0 | 324 x 458
SPS_C4 | Page size is C4. | 9.0 x 12.8 | 229 x 324
SPS_C5 | Page size is C5. | 6.4 x 9.0 | 162 x 229
SPS_C6 | Page size is C6. | 4.5 x 6.4 | 114 x 162
SPS_RA2 | Page size is RA2. |  | 430 x 610
SPS_RA3 | Page size is RA3. |  | 305 x 430
SPS_RA4 | Page size is RA4. |  | 215 x 305
SPS_QUARTO | Page size is QUARTO. |  | 215 x 275
SPS_DL | Page size is Envelope DL. | 4.33 x 8.66 | 110 x 220
SPS_Envelope14 | Page size is Envelope #14. | 5 x 11.5 |
SPS_Envelope12 | Page size is Envelope #12. | 4.75 x 11 |
SPS_Envelope11 | Page size is Envelope #11. | 4.5 x 10.38 |
SPS_Envelope10 | Page size is Envelope #10. | 4.13 x 9.5 | 104,8 x 241,3
SPS_Envelope9 | Page size is Envelope #9. | 3.88 x 8.88 |
SPS_EnvelopeCheck | Page size is Envelope Check. | 3.88 x 8.58 |
SPS_EnvelopeMonarch | Page size is Envelope Monarch. | 3.88 x 7.5 | 98,4 x 190,5
SPS_Custom | Page size is set by the user. |  |

Used in

IScanSourceSettings::PaperSize

IScanSourceCapabilities::PaperSizes


ScanPictureModeEnum

API Reference > Enumerations >

ScanPictureModeEnum

ScanPictureModeEnum enumeration constants are used to set image type.

typedef enum {
SPM_BlackAndWhite,
SPM_Grayscale,
SPM_Color
}ScanPictureModeEnum;

Elements

Name | Description
SPM_BlackAndWhite | Black-and-white image.
SPM_Grayscale | Gray image.
SPM_Color | Color image.

Used in

IScanSourceSettings::PictureMode

IScanSourceCapabilities::Compressions

IScanSourceCapabilities::PictureModes

See sample: FlexiCapture Engine Code Snippets


ScanSourceApiTypeEnum

API Reference > Enumerations >

ScanSourceApiTypeEnum

ScanSourceApiTypeEnum enumeration constants are used to specify the type of API supported by scanner.

typedef enum {
SSAT_Twain,
SSAT_Wia,
SSAT_All
}ScanSourceApiTypeEnum;

Elements

Name | Description
SSAT_Twain | This constant corresponds to TWAIN scanning API.
SSAT_Wia | This constant corresponds to WIA scanning API.
SSAT_All | This constant signifies that both API types are supported.

Used in

IScanSource::ApiType

IScanManager::FindScanSources


ScanSourceStatusEnum

API Reference > Enumerations >

ScanSourceStatusEnum

ScanSourceStatusEnum enumeration constants are used to define the current status of scanning source.

typedef enum {
SS_Disconnected,
SS_Idle,
SS_Busy
}ScanSourceStatusEnum;

Elements

Name | Description
SS_Disconnected | The scanning source is disconnected and therefore not available for processing.
SS_Idle | The scanning source is idle and can be used at once. note Note: Scanners with TWAIN scanning API may return this status even if the scanning source is only registered. If you try to use the scanner which is registered but not connected, an error will occur. However, note that some scanners with TWAIN scanning API can make an attempt to scan with unconnected source and only after that return the connection error.
SS_Busy | The scanning source is currently performing a scanning operation. It will be possible to use it after the operation is completed.

Used in

IScanSource::Status


SourceContentReuseModeEnum

API Reference > Enumerations >

SourceContentReuseModeEnum

SourceContentReuseModeEnum enumeration constants describe available modes of source PDF file contents reusing.

typedef enum {
CRM_Auto,
CRM_DoNotReuse,
CRM_ContentOnly
} SourceContentReuseModeEnum;

Elements

Name | Description
CRM_Auto | ABBYY FlexiCapture Engine uses both text and image layer of the source PDF file.
CRM_ContentOnly | Only the text layer of the source PDF file is used, the image layer is not used. note Note: OCR may be used in cases when the content is not reliable. Do not use this setting if the source file contains only raster information: for example, for image-only PDFs.
CRM_DoNotReuse | Text layer of the source PDF file is not used, the image layer is recognized by ABBYY FlexiCapture Engine.

Used in

IImageLoadingParams


TextEncodingTypeEnum

API Reference > Enumerations >

TextEncodingTypeEnum

TextEncodingTypeEnum enumeration constants are used to specify encoding type of a Unicode file.

typedef enum {
TET_UTF16LE,
TET_UTF16BE,
TET_UTF8,
TET_UTF8_WoBOM
} TextEncodingTypeEnum;

Elements

Name | Description
TET_UTF16LE | Unicode UTF-16LE format. UTF-16BE is a 16-bit variable-width encoding, each 16-bit unit is represented in little-endian byte order.
TET_UTF16BE | Unicode UTF-16BE format. UTF-16BE is a 16-bit variable-width encoding, each 16-bit unit is represented in big-endian byte order.
TET_UTF8 | Unicode UTF-8 format. UTF-8 is a code page that uses a string of bytes to represent a 16-bit Unicode string where ASCII text (<=U+007F) remains unchanged as a single byte, U+0080-07FF (including Latin, Greek, Cyrillic, Hebrew, and Arabic) is converted to a 2-byte sequence, and U+0800-FFFF (Chinese, Japanese, Korean, and others) becomes a 3-byte sequence.
TET_UTF8_WoBOM | Unicode UTF-8 format without the byte order mark (BOM) at the start of the text stream.

Used in

ITextExportParams::EncodingType

IXMLExportParams::EncodingType


TextTypeEnum

API Reference > Enumerations >

TextTypeEnum

TextTypeEnum enumeration constants are used to describe the type of recognized text.

typedef enum {
TT_Normal,
TT_Typewriter,
TT_Matrix,
TT_Index,
TT_Handprinted,
TT_OCR_A,
TT_OCR_B,
TT_MICR_E13B,
TT_MICR_CMC7,
TT_Fax
} TextTypeEnum;

Elements

Name | Description
TT_Fax | This value corresponds to the kind of text printed by fax machines.
TT_Handprinted | This value corresponds to handprinted text. It may look as follows:
TT_Index | This constant corresponds to a special set of characters including only digits written in ZIP-code style. They look as follows:
TT_Matrix | This value tells ABBYY FlexiCapture Engine to presume that the text on the recognized image is printed on a dot matrix printer.
TT_MICR_E13B | This value corresponds to a special set of numeric characters printed with special magnetic inks. MICR (Magnetic Ink Character Recognition) characters are found in a variety of places, including personal checks. It may look as follows:
TT_MICR_CMC7 | This value corresponds to a special MICR barcode font (CMC-7). It may look as follows:
TT_Normal | This value corresponds to the common typographic type of text.
TT_OCR_A | This value corresponds to the monospaced font designed for Optical Character Recognition. Largely used by banks, credit card companies and similar businesses. It may look as follows:
TT_OCR_B | This value corresponds to a font designed for Optical Character Recognition. It may look as follows:
TT_Typewriter | This value tells ABBYY FlexiCapture Engine to presume that the text on the recognized image is typed on a typewriter.

Used in

ITextBlock::TextType

IDocumentDefinition::DefaultTextType

ITextRecognitionParams::TextType

ITrainingDefinition::PossibleTextTypes

See also

Text Types

See sample: FlexiCapture Engine Code Snippets


TrainingFieldTypeEnum

API Reference > Enumerations >

TrainingFieldTypeEnum

TrainingFieldTypeEnum enumeration constants define the types of fields in a training Document Definition.

typedef enum {
TFT_Field,
TFT_ReferenceText,
TFT_ReferenceSeparator,
TFT_ReferenceBarcode
} TrainingFieldTypeEnum;

Elements

Name | Description
TFT_Field | Field, containing the data to extract.
TFT_ReferenceText | Reference text.
TFT_ReferenceSeparator | Reference separator.
TFT_ReferenceBarcode | Reference barcode.

Used in

ITrainingField::Type

ITrainingFields::AddNew


VerificationObjectStateEnum

API Reference > Enumerations >

VerificationObjectStateEnum

VerificationObjectStateEnum enumeration constants are used to set the verification object state.

typedef enum {
VOS_Initial,
VOS_Uncertain,
VOS_Corrected,
VOS_Confirmed
} VerificationObjectStateEnum;

Elements

Name | Description
VOS_Initial | The object is in an initial state. No decision has been made about this object.
VOS_Uncertain | The decision cannot be made during group verification and is put off till the context verification.
VOS_Corrected | The object has been corrected.
VOS_Confirmed | The object value has been corrected automatically by the system, and was confirmed during verification.

Used in

IVerificationObject::State


VerificationObjectTypeEnum

API Reference > Enumerations >

VerificationObjectTypeEnum

VerificationObjectTypeEnum enumeration constants are used to define the verification object type.

typedef enum {
VOT_Group,
VOT_Context
} VerificationObjectTypeEnum;

Elements

Name | Description
VOT_Group | The object is submitted for group verification.
VOT_Context | The object is submitted for context verification.

Used in

IVerificationObject::Type

See sample: FlexiCapture Engine Code Snippets


WordModelTypeEnum

API Reference > Enumerations >

WordModelTypeEnum

WordModelTypeEnum enumeration constants are used to describe the type of the word model.

typedef enum {
WMT_MonolingualWord,
WMT_RegExpWord,
WMT_BilingualComposite,
WMT_Acronym,
WMT_Number,
WMT_NumberWithQualifier,
WMT_WordNumberComposite,
WMT_BilingualWordNumberComposite,
WMT_RomanNumber,
WMT_MonolingualWordWithExtras,
WMT_MixedFormDictionaryWord,
WMT_PhoneNumber,
WMT_Punctuation,
WMT_FileName,
WMT_UrlOrEmail,
WMT_NoSuitableModel
} WordModelTypeEnum;

Elements

Name | Description
WMT_MonolingualWord | A common word. Its grammar is determined by the language alphabet. Besides that, the word can contain characters-separators, e.g., "/" or "-".
WMT_RegExpWord | A word from the language which grammar is described by a regular expression.
WMT_BilingualComposite | A bilingual compound word with an explicit dividing point.
WMT_Acronym | An acronym consisting of capital letters. The word can contain digits and separators, e.g., "B2B", "C.E.R.N.".
WMT_Number | A word consisting of digits and punctuators, e.g., "123", "4.56", "#789".
WMT_NumberWithQualifier | A word with a prefix or suffix that serves as a qualifier or inflexion, e.g., "USD250", "1.2GHz", "2nd".
WMT_WordNumberComposite | A compound word with an explicit dividing point consisting of a word and a digit, e.g., "2-meter".
WMT_BilingualWordNumberComposite | A compound word with explicit dividing points consisting of two words belonging to different languages and a number, e.g., "Windows-2000-kompatibel".
WMT_RomanNumber | A Roman number.
WMT_MonolingualWordWithExtras | A word consisting of the language alphabet characters and special characters, digits, etc., e.g., "Alias|Wavefront".
WMT_MixedFormDictionaryWord | A word belonging to the mixed form dictionary. It can contain any characters including characters from the alphabets of different languages. Non-dictionary words are not allowed.
WMT_PhoneNumber | A phone number. A prefix is allowed, e.g., "Ph.(495)123-45678".
WMT_Punctuation | A set of punctuation marks separated from a word by a space(s).
WMT_FileName | A DOS/Windows or UNIX file name, e.g., "README.TXT", "C:\WINNT\system32", "/etc/motd.rc".
WMT_UrlOrEmail | An URL or e-mail address, e.g., "http://www.abbyy.com", "engine_support@abbyy.com".
WMT_NoSuitableModel | A word that does not meet any word model. Every word character is recognized separately, without context. The recognition result may be a meaningless character sequence.

Used in

IRecognizedWordInfo::ModelType


XLFileFormatEnum

API Reference > Enumerations >

XLFileFormatEnum

XLFileFormatEnum enumeration constants specify formats available for XLS file format.

typedef enum {
XLFF_BIFF5,
XLFF_BIFF8,
XLFF_DoubleStream
} XLFileFormatEnum;

Elements

Name | Description
XLFF_BIFF5 | MS Excel 5. This format is previous to the XLFF_BIFF8 one and may be used for compatibility with the older versions of MS Excel.
XLFF_BIFF8 | MS Excel 8. This is a newer format of XLS-formatted clipboard data.
XLFF_DoubleStream | Both formats (MS Excel 5 and 8 versions) are saved to the same file.

Used in

IExcelExportParams::XLFileFormat


Types of ABBYY FlexiCapture Engine Properties

API Reference >

Types of ABBYY FlexiCapture Engine Properties

The ABBYY FlexiCapture Engine properties may be of the following types:

Visual Basic type | C++ type
Boolean (with two values, True and False) | VARIANT_BOOL (with two values VARIANT_TRUE and VARIANT_FALSE)
Int | int
Double | double
String | BSTR, a pointer to Unicode string. Zero value specifies an empty string.
Object | IUnknown-derived interface
Enumeration | Enumeration

See the detailed description of working with properties in ABBYY FlexiCapture Engine in the Working with Properties section.


Standard Return Codes of FlexiCapture Engine Functions

Standard Return Codes

API Reference >

Standard Return Codes

Here is a list of the standard return codes of ABBYY FlexiCapture Engine functions and properties.

Return code | Value | Description
S_OK | 0 (&H00000000L) | Method completed successfully.
E_OUTOFMEMORY | -2147024882 (&H8007000EL) | There was not enough memory to perform the operation.
E_UNEXPECTED | -2147418113 (&H8000FFFFL) | Unexpected internal error.
E_ABORT | -2147467260 (&H80004004L) | Operation was aborted by the user.
E_NOTIMPL | -2147467263 (&H80004001L) | Method is not implemented.
E_POINTER | -2147467261 (&H80004003L) | Invalid pointer argument.
E_INVALIDARG | -2147024809 (&H80070057L) | One or more arguments are invalid.
CO_E_OBJNOTCONNECTED | -2147220995 (&H800401FDL) | A pointer to an object was passed that is no longer valid (this object was destroyed).
CLASS_E_NOTLICENSED | -2147221230 (&H80040112L) | This copy of ABBYY FlexiCapture Engine is not registered.
CO_E_NOT_SUPPORTED | -2147467231 (&H80004021L) | Some property or method is not available under the current license.
E_FAIL | -2147467259 (&H80004005L) | Unspecified error.

note Note: These return codes you can find in the Microsoft® Platform Software Development Kit (SDK) header file winerror.h.

Other return codes are possible, specifically those related to file system errors.

See also

Error Handling


FlexiCapture Engine Visual Components Reference

No topics above this level

FlexiCapture Engine Visual Components Reference

warning Important! This functionality is deprecated and will be removed in future versions.

The ABBYY FlexiCapture Engine 12 Visual Components are intended for developers of user interfaces for data verification. The Visual Components provide a graphical interface to the main data verification steps: checking and correcting the results of document assembly, Document Definition matching, and data recognition. This section provides an overview of the API and architecture of the components:

·BatchView

Used for displaying the images in a batch, grouped by document. Allows basic operations on documents and pages.

·VerificationView

Used for group and context verification.

·DocumentView

Used for displaying and editing document fields and blocks.

You can find some examples of using the Visual Components in the ABBYY FlexiCapture Engine Samples.

All ABBYY FlexiCapture Engine 12 Visual Components are written in C#, using .NET and Windows Forms technologies. These controls are provided with open code, so that you can change both appearance and implementation of the controls. The Visual Components are control elements of Windows Forms, i.e. they inherit from the System.Windows.Forms.UserControl class.


BatchView Component

Visual Components Reference >

BatchView Component

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The BatchView component is intended for displaying batch pages grouped by document. The component allows basic operations on documents and pages: deleting and reordering pages and documents, moving pages from one document to another, recognizing documents, etc. The figure below shows how the component looks like.

note Note: If you work with FlexiCapture Processor, you do not need this component.

The BatchView control element responds to ABBYY FlexiCapture Engine 12 events. When any of the following events occurs, the contents of BatchView is updated, entirely or in part, displaying the current statuses of the ABBYY FlexiCapture Engine objects:

·the collection of documents of the batch is changed

·the collection of document assembly errors is changed

·the collection of pages in the document is changed

The major properties, methods, and events of the BatchView Visual Component are listed in the tables below.

Properties

Name | Type | Description
Common properties
Engine | FCEngine.IEngine | A reference to the ABBYY FlexiCapture Engine object. You must specify this property before you start working with BatchView.
Major properties of BatchView
Batch | FCEngine.IBatch | A reference to the FCEngine.IBatch object, which represents the batch of documents. Specify this property before you start working with BatchView. You need to open the batch first by calling FCEngine.IBatch.Open.
PrimarySelection | System.Object, read-only | The object (document or page) which is currently active.
SelectedDocuments | FCEngine.IDocument[], read-only | The list of selected documents.
SelectedPages | FCEngine.IPage[], read-only | The list of selected pages.
ThumbnailSize | ThumbnailSize | The size of page thumbnails: extra small, small, normal, large, extra large thumbnails.

Methods

Name | Description
Common methods
DisableCommand | Disables the specified command.
DoCommand | Executes the specified command.
EnableCommand | Enables the specified command.
Major methods of BatchView
Clear | Clears the BatchView workspace, returning the component to its initial (empty) state. This method does not close the batch. If required, close the batch by calling FCEngine.IBatch.Close. The method has no input parameters and returns void.
SelectAll | Selects all documents in BatchView. The method has no input parameters and returns void.

Events

Name | Description
Common events
CommandExecuting | Occurs before the command is executed. Allows the command to be revoked.
CommandExecuted | Occurs after the command is executed.
Major events of BatchView
DocumentDoubleClick | Occurs upon double-clicking a document caption (i.e. DocumentCaptionControl).
DocumentsCollectionChanged | Occurs after the document collection is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
PageDoubleClick | Occurs upon double-clicking a document page.
SelectionChanged | Occurs after the page or document selection is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
ThumbnailSizeChanged | Occurs after the size of the thumbnails is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.

Architecture

In terms of architecture, BatchView is a container for DocumentControl control elements, which represent the documents of the batch. Each DocumentControl control element consists of one DocumentCaptionControl control element and one or more PageControl control elements:

See also

See sample: Visual Components, Visual Components - Hello with FlexiCapture Project


DocumentControl Control Element

Visual Components Reference > BatchView >

DocumentControl Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The DocumentControl control elements represent the documents of the batch. The purpose of the DocumentControl control element is to display the thumbnails of the batch pages grouped into a document. Each DocumentControl control element consists of one DocumentCaptionControl control element and one or more PageControl control elements.

The major properties, methods, and events of the DocumentControl class are listed in the tables below.

Properties

Name | Type | Description
BatchView | BatchView | A reference to the BatchView component, which is a container for the DocumentControl control element.
CaptionControl | DocumentCaptionControl | A reference to the DocumentCaptionControl object, which represents the caption of a document.
Document | FCEngine.IDocument | A reference to the FCEngine.IDocument object, which represents the document.
Index | System.Int32 | The index (i.e. number) of the document in the batch.
Pages | PageControlCollection, read-only | The list of control elements (PageControl) that represent the document pages.

Methods

Name | Description
DeletePage | Deletes a document page.

Events

Name | Description
DocumentDoubleClick | Occurs upon double-clicking a document.
PageDoubleClick | Occurs upon double-clicking a document page.

See also

BatchView

See sample: Visual Components


DeletePage Method of DocumentControl

Visual Components Reference > BatchView > DocumentControl >

DeletePage Method of DocumentControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method deletes a document page.

C# Syntax

public void DeletePage(IPage page);

Parameters

page

[in] Specifies the page (FCEngine.IPage) to be deleted.

See also

DocumentControl

See sample: Visual Components


DocumentCaptionControl Control Element

Visual Components Reference > BatchView >

DocumentCaptionControl Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The DocumentCaptionControl control element displays information about the type of the document, its number within the batch, and information about document assembly errors. Each DocumentControl control element includes one DocumentCaptionControl control element.

Properties

Name | Type | Description
Document | FCEngine.IDocument | A reference to the FCEngine.IDocument object, which represents the document.

See also

DocumentControl

See sample: Visual Components


PageControl Control Element

Visual Components Reference > BatchView >

PageControl Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

The PageControl control element represents a page thumbnail. This control element displays the thumbnail of a page, its name, and the value of the key field (if any) that is used for grouping pages into documents. The PageControl control element may contain a number of AssemblingErrorControl elements. The major properties and methods of the PageControl class are listed in the tables below.

Properties

Name | Type | Description
Page | FCEngine.IPage | A reference to the FCEngine.IPage object, which represents a document page.
ThumbnailImage | System.Drawing.Image | The thumbnail proper.
ThumbnailSize | ThumbnailSize | The size of the page thumbnail.

Methods

Name | Description
AddAssemblingError | Adds an assembly error indicator onto a page thumbnail.
ClearAssemblingErrors | Removes all assembly error indicators from the page thumbnail. The method has no input parameters and returns void.
SetKeyValueMismatchError | Toggles the error indicator shown when key fields do not match.

See also

DocumentControl

AssemblingErrorControl

See sample: Visual Components


AddAssemblingError Method of PageControl

Visual Components Reference > BatchView > PageControl >

AddAssemblingError Method of PageControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method adds an assembly error indicator onto a page thumbnail.

C# Syntax

public void AddAssemblingError(IAssemblingError pageAssemblingError);

Parameters

pageAssemblingError

[in] Specifies the assembly error (FCEngine.IAssemblingError) whose indicator should be added onto the page thumbnail.

See also

PageControl

See sample: Visual Components


SetKeyValueMismatchError Method of PageControl

Visual Components Reference > BatchView > PageControl >

SetKeyValueMismatchError Method of PageControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method toggles the error indicator shown when key fields do not match.

C# Syntax

public void SetKeyValueMismatchError(bool stateHasError);

Parameters

stateHasError

[in] This parameter is true if there is an error; otherwise it is false.

See also

PageControl

See sample: Visual Components


AssemblingErrorControl Control Element

Visual Components Reference > BatchView >

AssemblingErrorControl Control Element

The purpose of the AssemblingErrorControl control element is to display assembly errors on page thumbnails (i.e. on the PageControl control element). This is a control element which inherits from the System.Windows.Forms.PictureBox class and displays an assembly error symbol and a pop-up description of the error.

Methods

Name | Description
AddAssemblingError | Associates a given assembly error with the control element.
Clear | Removes the assembly error associated with the control element. The method has no input parameters and returns void.

See also

PageControl

See sample: Visual Components


AddAssemblingError Method of AssemblingErrorControl

Visual Components Reference > BatchView > AssemblingErrorControl >

AddAssemblingError Method of AssemblingErrorControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method associates a given assembly error with the control element.

C# Syntax

public void AddAssemblingError(IAssemblingError error);

Parameters

error

[in] Specifies the error (FCEngine.IAssemblingError) to be associated with the control element.

See also

AssemblingErrorControl

See sample: Visual Components


BatchView.Commands

Visual Components Reference > BatchView >

BatchView.Commands

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
BatchView.Commands enumeration constants define the commands available in BatchView.

C# Syntax

public enum Commands
{
LoadImages,
Recognize,
Export,
Delete,
ZoomIn,
ZoomOut,
SplitDocument,
Move
}

Elements

Name | Description
LoadImages | Load images into the current batch of BatchView.
Recognize | Recognize the document selected in BatchView.
Export | Export the document selected in BatchView.
Delete | Delete the page or document selected in BatchView.
ZoomIn | Zoom into BatchView.
ZoomOut | Zoom out of BatchView.
SplitDocument | Split the document selected in BatchView into pages.
Move | Move the page or document selected in BatchView to the new location.

See also

BatchView.DisableCommand

BatchView.DoCommand

BatchView.EnableCommand


DisableCommand Method

Visual Components Reference > BatchView >

DisableCommand Method

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method disables the specified command in the Visual Component.

C# Syntax

public void DisableCommand( Commands command );

Parameters

command

[in] Contains the enumeration constant that specifies which command to disable. See the descriptions of the BatchView.Commands, DocumentView.Commands, or VerificationView.Commands.

Remarks

The method is provided by the following components:

·BatchView

·DocumentView

·VerificationView

See also

See sample: Visual Components


DoCommand Method

Visual Components Reference > BatchView >

DoCommand Method

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method executes the specified command, e.g. BatchView.Commands.Recognize or VerificationView.Commands.ConfirmAll.

C# Syntax

public void DoCommand( Commands command );

Parameters

command

[in] Contains the enumeration constant that specifies which command to execute. See the descriptions of the BatchView.Commands, DocumentView.Commands, or VerificationView.Commands.

Remarks

The method is provided by the following components:

·BatchView

·DocumentView

·VerificationView

See also

See sample: Visual Components


EnableCommand Method

Visual Components Reference > BatchView >

EnableCommand Method

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

This method enables the specified command.

C# Syntax

public void EnableCommand( Commands command );

Parameters

command

[in] Is the enumeration constant that specifies which command to enable. See the descriptions of the BatchView.Commands, DocumentView.Commands, or VerificationView.Commands.

Remarks

The method is provided by the following components:

·BatchView

·DocumentView

·VerificationView

See also

See sample: Visual Components


CommandExecuted Event

Visual Components Reference > BatchView >

CommandExecuted Event

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the command is executed.

note Note: In the VisualComponents implementation this event is raised only when DoCommand is called explicitly. The event does not work when you run the command from the VerificationView component toolbar or context menu.

C# Syntax

public event System.EventHandler<BatchViewCommandExecutedEventArgs> CommandExecuted;
public event System.EventHandler<DocumentViewCommandExecutedEventArgs> CommandExecuted;
public event System.EventHandler<VerificationViewCommandExecutedEventArgs> CommandExecuted;
public class BatchViewCommandExecutedEventArgs : CommandExecutedEventArgs<BatchView.Commands>
{
public BatchViewCommandExecutedEventArgs(BatchView.Commands command)
: base(command)
{ }
}
public class DocumentViewCommandExecutedEventArgs : CommandExecutedEventArgs<DocumentView.Commands>
{
public DocumentViewCommandExecutedEventArgs(DocumentView.Commands command)
: base(command)
{ }
}
public class VerificationViewCommandExecutedEventArgs : CommandExecutedEventArgs<VerificationView.Commands>
{
public VerificationViewCommandExecutedEventArgs(VerificationView.Commands command)
: base(command)
{ }
}
public class CommandExecutedEventArgs<TCommand>: EventArgs
{
public TCommand Command
{
get;
protected set;
}
public CommandExecutedEventArgs(TCommand command)
{
this.Command = command;
}
}

Parameters

Command

[in] Contains the enumeration constant that specifies which command has been executed. See the descriptions of the BatchView.Commands, DocumentView.Commands, or VerificationView.Commands.

Remarks

This event is provided by the following components:

·BatchView

·DocumentView

·VerificationView

See also

See sample: Visual Components, Visual Components - Hello with FlexiCapture Project


CommandExecuting Event

Visual Components Reference > BatchView >

CommandExecuting Event

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs before the command is executed. Delivers to the client information on the command, which is going to be executed. Allows the command to be revoked.

note Note: In the VisualComponents implementation this event is raised only when DoCommand is called explicitly. The event does not work when you run the command from the VerificationView component toolbar or context menu.

C# Syntax

public event System.EventHandler<BatchViewCommandExecutingEventArgs> CommandExecuting;
public event System.EventHandler<DocumentViewCommandExecutingEventArgs> CommandExecuting;
public event System.EventHandler<VerificationViewCommandExecutingEventArgs> CommandExecuting;
public class BatchViewCommandExecutingEventArgs : CommandExecutingEventArgs<BatchView.Commands>
{
public BatchViewCommandExecutingEventArgs(BatchView.Commands command)
: base(command)
{ }
}
public class DocumentViewCommandExecutingEventArgs : CommandExecutingEventArgs<DocumentView.Commands>
{
public DocumentViewCommandExecutingEventArgs(DocumentView.Commands command)
: base(command)
{ }
}
public class VerificationViewCommandExecutingEventArgs : CommandExecutingEventArgs<VerificationView.Commands>
{
public VerificationViewCommandExecutingEventArgs(VerificationView.Commands command)
: base(command)
{ }
}
public class CommandExecutingEventArgs<TCommand>: EventArgs
{
public TCommand Command
{
get;
protected set;
}
public bool Cancel
{
get;
set;
}
public CommandExecutingEventArgs(TCommand command)
{
this.Command = command;
}
}

Parameters

Command

[in] Contains the enumeration constant that specifies which command is executed. See the descriptions of the BatchView.Commands, DocumentView.Commands, or VerificationView.Commands.

Cancel

[in, out] You may set this variable to true to indicate that the command should be revoked.

Remarks

This event is provided by the following components:

·BatchView

·DocumentView

·VerificationView

See also

See sample: Visual Components, Visual Components - Hello with FlexiCapture Project


DocumentDoubleClick Event of DocumentControl

Visual Components Reference > BatchView >

DocumentDoubleClick Event of DocumentControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs upon double-clicking a document.

C# Syntax

public event System.EventHandler<DocumentDoubleClickEventArgs> DocumentDoubleClick;
public class DocumentDoubleClickEventArgs: EventArgs
{
public IDocument Document
{
get;
private set;
}
public DocumentDoubleClickEventArgs(IDocument document)
{
Document = document;
}
}

Parameters

Document

[in] Specifies the document (FCEngine.IDocument), which has been double-clicked.

See also

DocumentControl

See sample: Visual Components - Hello, Visual Components - Hello with FlexiCapture Project, Visual Components


PageDoubleClick Event of DocumentControl

Visual Components Reference > BatchView >

PageDoubleClick Event of DocumentControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs upon double-clicking a document page.

C# Syntax

public event System.EventHandler<PageDoubleClickEventArgs> PageDoubleClick;
public class PageDoubleClickEventArgs: EventArgs
{
public IDocument ParentDocument
{
get;
private set;
}
public IPage Page
{
get;
private set;
}
internal PageDoubleClickEventArgs(IDocument parentDocument, IPage page)
{
ParentDocument = parentDocument;
Page = page;
}
}

Parameters

ParentDocument

[in] Specifies the document (FCEngine.IDocument), which contains the double-clicked page.

Page

[in] Specifies the page (FCEngine.IPage), which has been double-clicked.

See also

DocumentControl

See sample: Visual Components - Hello, Visual Components - Hello with FlexiCapture Project, Visual Components


PageDoubleClick Event of BatchView

Visual Components Reference > BatchView >

PageDoubleClick Event of BatchView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs upon double-clicking a document page.

C# Syntax

public event System.EventHandler<PageDoubleClickEventArgs> PageDoubleClick;
public class PageDoubleClickEventArgs: EventArgs
{
public IDocument ParentDocument
{
get;
private set;
}
public IPage Page
{
get;
private set;
}
internal PageDoubleClickEventArgs(IDocument parentDocument, IPage page)
{
ParentDocument = parentDocument;
Page = page;
}
}

Parameters

ParentDocument

[in] Specifies the document (FCEngine.IDocument), which contains the double-clicked page.

Page

[in] Specifies the page (FCEngine.IPage), which has been double-clicked.

See also

BatchView

See sample: Visual Components, Visual Components - Hello with FlexiCapture Project


DocumentDoubleClick Event of BatchView

Visual Components Reference > BatchView >

DocumentDoubleClick Event of BatchView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs upon double-clicking a document caption (i.e. DocumentCaptionControl).

C# Syntax

public event System.EventHandler<DocumentDoubleClickEventArgs> DocumentDoubleClick;
public class DocumentDoubleClickEventArgs: EventArgs
{
public IDocument Document
{
get;
private set;
}
public DocumentDoubleClickEventArgs(IDocument document)
{
Document = document;
}
}

Parameters

Document

[in] Specifies the document (FCEngine.IDocument), which caption has been double-clicked.

See also

BatchView

See sample: Visual Components, Visual Components - Hello with FlexiCapture Project


DocumentView Component

Visual Components Reference >

DocumentView Component

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The DocumentView Visual Component displays the list of document fields, assembly errors, rule errors, and the blocks drawn on the document pages. This Visual Component also allows editing field text and block coordinates. The figure below shows how the component looks like.

The DocumentView component responds to ABBYY FlexiCapture Engine 12 events. When any of the following events occurs, the contents of DocumentView is updated, entirely or in part, displaying the current status of the ABBYY FlexiCapture Engine objects:

·the collection of the document fields is changed

·the collection of document assembly errors is changed

·the collection of document rules is changed

The major properties, methods, and events of the DocumentView Visual Component are listed in the tables below.

Properties

Name

Type

Description

Common properties

Engine

FCEngine.IEngine

A reference to the ABBYY FlexiCapture Engine object. You must specify this property before you start working with DocumentView.

Major properties of DocumentView

AutoRecognizeBlocks

System.Boolean

It is true if the block must be automatically recognized when its coordinates are changed; otherwise it is false.

CanRedo

System.Boolean, read-only

It is true if the last undone action can be redone; otherwise it is false.

CanUndo

System.Boolean, read-only

It is true if the last action can be undone; otherwise it is false.

Document

FCEngine.IDocument, read-only

A reference to the FCEngine.IDocument object, which represents the document. You must specify this property before you start working with DocumentView.

note Note: If you process documents with FlexiCapture project, you need to open the document for writing by calling the FCEngine.IDocument.Open method at first.

DocumentHasErrors

System.Boolean, read-only

It is true if there are document assembly errors or rule errors in the document; otherwise it is false.

DocumentViewLayoutOrientation

DocumentView.Orientation

The orientation of DocumentView: horizontal or vertical.

IsDocumentModified

System.Boolean, read-only

It is true if there are unsaved changes in the document; otherwise it is false.

IsFormViewCollapsed

System.Boolean

It is true if FormView is not displayed; otherwise it is false.

IsImageViewCollapsed

System.Boolean

It is true if ImageView is not displayed; otherwise it is false.

Page

FCEngine.IPage

The current document page to be displayed in DocumentView.

SelectedBlocks

FCEngine.IBlock[], read-only

The list of selected blocks.

SplitterDistance

System.Int32

The position of the separator line between FormView and ImageView.

ViewScalePercent

System.Single, read-only

The scale at which document pages are displayed.

Methods

Name

Description

Common methods

DisableCommand

Disables the specified command.

DoCommand

Executes the specified command.

EnableCommand

Enables the specified command.

Major methods of DocumentView

Clear

Frees up the resources and clears the workspace of the component, returning it to its initial (empty) state. The method has no input parameters and returns void.

note Note: If you process documents with FlexiCapture project, pay attention that the document will not be closed in this case. If required, close the document by calling FCEngine.IDocument.Close.

Redo

Redoes the previously undone action, if any. The method has no input parameters and returns void.

Undo

Undoes the previous action, if any. The method has no input parameters and returns void.

Events

Name | Description
Common events
CommandExecuting | Occurs before the command is executed. Allows the command to be revoked.
CommandExecuted | Occurs after the command is executed.
Major events of DocumentView
AutoRecognizeChanged | Occurs after the AutoRecognizeBlocks property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
BlockSelectionChanged | Occurs after the list of selected blocks (SelectedBlocksSelectedBlocks property) is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
CurrentPageChanged | Occurs after the current document page (Page property) is changed.
HasErrorsChanged | Occurs after the DocumentHasErrors property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.

Architecture

In terms of architecture, DocumentView is a compound control element which contains two control elements: FormView and ImageView:

See also

See sample: Visual Components - Hello, Visual Components - Hello with FlexiCapture Project, Visual Components


FormView Control Element

Visual Components Reference > DocumentView >

FormView Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The FormView control element is a part of the DocumentView component, it displays the list of document fields, assembly errors, and rule errors. The component also allows editing the text in the document fields. The major properties, methods, and events of the FormView control element are listed in the tables below.

To start working with FormView, you must specify its Document property. Once that property is specified, FormView gets the list of document fields and creates one of the following control elements for each field: GroupPresenter, CheckmarkFieldPresenter, CheckmarkGroupFieldPresenter, PictureFieldPresenter, TableFieldPresenter, or TextFieldPresenter. The type of the control element is determined by the type of the field.

Properties

Name | Type | Description
CurrentPage | FCEngine.IPage | The current document page to be displayed in FormView.
CurrentPresenter | FieldPresenterBase | A reference to the control element that represents the current document field.
Document | FCEngine.IDocument | A reference to the FCEngine.IDocument object, which represents the document.

Methods

Name

Description

Close

Frees up the resources and clears the workspace of the component, returning it to its initial state. The method has no input parameters and returns void.

note Note: If you process documents with FlexiCapture project, pay attention that the document will not be closed in this case. If required, close the document by calling FCEngine.IDocument.Close.

SelectFirstErrorPresenter

Selects the first control element that corresponds to the key field whose value does not match the values of the other key fields (i.e. if an assembly error occurred) or to the field where a rule error occurred. The method has no input parameters and returns void.

SelectPresenterByField

Selects the control element that represents the specified document field.

Redo

Redoes the previously undone action, if any. The method has no input parameters and returns void.

Undo

Undoes the previous action, if any. The method has no input parameters and returns void.

Events

Name | Description
CurrentPageChanged | Occurs after the current document page is changed.
PresenterChanged | Occurs after the CurrentPresenter property is changed.

See also

DocumentView

See sample: Visual Components


FieldPresenterBase Class

Visual Components Reference > DocumentView > FormView >

FieldPresenterBase Class

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
All control elements that represent document fields (GroupPresenter, CheckmarkFieldPresenter, CheckmarkGroupFieldPresenter, PictureFieldPresenter, TableFieldPresenter, TextFieldPresenter) inherit from the FieldPresenterBase class.

The major properties, methods, and events of the FieldPresenterBase class are listed in the tables below.

Properties

Name | Type | Description
ContentControl | System.Windows.Forms. Control | A reference to the Windows Forms control element, which implements the display and editing of field data. Depending on the type of the field, it may reference TextBox, ComboBox, CheckBox, PictureBox, DataGridView, or TableLayoutPanel.
Field | FCEngine.IField | A reference to the FCEngine.IField object, which represents a document field.

Methods

Name | Description
ConnectRuleError | Adds a rule error to the control element. The text of the rule error will be displayed as a pop-up and the control element itself will be enclosed in a red frame.
DisconnectRuleError | Removes the rule error added to the control element. The method has no input parameters and returns void.
UpdateContent | Reads the value of the document field and displays it in the control element. The method has no input parameters and returns void.

Events

Name | Description
Selected | Occurs after the control element becomes active. The event does not generate event data and the event handler delegate type is System.EventHandler.

See also

FormView

See sample: Visual Components


ConnectRuleError Method of FieldPresenterBase

Visual Components Reference > DocumentView > FormView > FieldPresenterBase >

ConnectRuleError Method of FieldPresenterBase

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method adds a rule error to the control element. The text of the rule error will be displayed as a pop-up and the control element itself will be enclosed in a red frame.

C# Syntax

public void ConnectRuleError(FCEngine.IRuleError error);

Parameters

error

[in] Specifies the rule error (FCEngine.IRuleError) to be added.

See also

FieldPresenterBase

See sample: Visual Components


SelectPresenterByField Method of FormView

Visual Components Reference > DocumentView > FormView >

SelectPresenterByField Method of FormView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method selects the control element that represents the specified document field.

C# Syntax

public void SelectPresenterByField(FCEngine.IField field);

Parameters

field

[in] Specifies the field of the document (FCEngine.IField) which specifies the control element to be selected.

See also

FormView

See sample: Visual Components


CurrentPageChanged Event of FormView

Visual Components Reference > DocumentView > FormView >

CurrentPageChanged Event of FormView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the current document page is changed.

C# Syntax

public event System.EventHandler<PageChangedEventArgs> CurrentPageChanged;
public sealed class PageChangedEventArgs : EventArgs
{
private FCEngine.IPage _page;
public FCEngine.IPage Page
{
get { return _page; }
}
public PageChangedEventArgs(FCEngine.IPage page)
{
_page = page;
}
}

Parameters

Page

[in] Specifies the new active page (FCEngine.IPage) in FormView.

See also

FormView

See sample: Visual Components


PresenterChanged Event of FormView

Visual Components Reference > DocumentView > FormView >

PresenterChanged Event of FormView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the FormView.CurrentPresenter property is changed.

C# Syntax

public event System.EventHandler<PresenterChangedEventArgs> PresenterChanged;
internal sealed class PresenterChangedEventArgs : EventArgs
{
private FieldPresenterBase _presenter;
private FCEngine.IBlock[] _blocks;
public FieldPresenterBase Presenter
{
get { return _presenter; }
}
public FCEngine.IBlock[] Blocks
{
get { return _blocks; }
}
public PresenterChangedEventArgs(FieldPresenterBase presenter, FCEngine.IBlock[] blocks)
{
_presenter = presenter;
_blocks = blocks;
}
}

Parameters

ParentDocument

[in] Specifies the new value of the FormView.CurrentPresenter property (FieldPresenterBase).

Page

[in] Specifies the array of blocks (FCEngine.IBlock) corresponding to the new presenter.

See also

FormView

See sample: Visual Components


ImageView Control Element

Visual Components Reference > DocumentView >

ImageView Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The ImageView control element is a part of the DocumentView component, it displays blocks drawn on the page images. The element also allows changing block coordinates and recognizing blocks.

Drawing blocks and changing their coordinates in the ImageView control element are implemented by using the infrastructure of the Form Designer (.NET Form Designer). Its infrastructure, in a simplified form, is show in the figure below.

The ImageView control element may contain multiple PageImageControl control elements, which represent the status of a document page.

The major properties, methods, and events of the ImageView control element are listed in the tables below.

Properties

Name | Type | Description
AutoRecognizeBlocks | System.Boolean | It is true, if the block must be automatically recognized when its coordinates are changed; otherwise it is false.
CurrentPage | FCEngine.IPage | The current document page to be displayed in ImageView.
ScalePercent | System.Single, read-only | The scale at which document pages are displayed.
SelectedBlocks | FCEngine.IBlock[], read-only | The list of selected blocks.
Document | FCEngine.IDocument | A reference to the FCEngine.IDocument object, which represents the document.

Methods

Name

Description

Close

Frees up the resources and clears the workspace of the component, returning it to its initial state. The method has no input parameters and returns void.

note Note: If you process documents with FlexiCapture project, pay attention that the document will not be closed in this case. If required, close the document by calling FCEngine.IDocument.Close.

ScrollToPage

Scrolls the workspace of the component to display the specified page.

SelectAllFields

Selects all blocks. The method has no input parameters and returns void.

RecognizeBlocks

Recognizes the text of the specified blocks.

Redo

Redoes the previously undone action, if any. The method has no input parameters and returns void.

Undo

Undoes the previous action, if any. The method has no input parameters and returns void.

UpdateImageView

Reads the coordinates of the blocks from the corresponding ABBYY FlexiCapture Engine objects and redraws the workspace of ImageView. The method has no input parameters and returns void.

ZoomIn

Zooms into document pages. The method has no input parameters and returns void.

ZoomOut

Zooms out of document pages. The method has no input parameters and returns void.

Events

Name | Description
AutoRecognizeChanged | Occurs after the AutoRecognizeBlocks property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
CurrentPageChanged | Occurs after the CurrentPage property is changed.
FieldDoubleClick | Occurs upon double-clicking a block. The event does not generate event data and the event handler delegate type is System.EventHandler.
SelectionChanged | Occurs after the SelectedBlocks property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
ZoomChanged | Occurs after the ScalePercent property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.

See also

DocumentView

See sample: Visual Components


PageImageControl Control Element

Visual Components Reference > DocumentView > ImageView >

PageImageControl Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The ImageView control element may contain multiple PageImageControl control elements, which represent the status of a document page.

The major properties and methods of the PageImageControl control element are listed in the tables below.

Properties

Name | Type | Description
Page | FCEngine.IPage, read-only | The displayed document page.

Methods

Name | Description
Initialize | Specifies the page image.

See also

ImageView

See sample: Visual Components


Initialize Method of PageImageControl

Visual Components Reference > DocumentView > ImageView > PageImageControl >

Initialize Method of PageImageControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method specifies the page image.

C# Syntax

public void Initialize(FCEngine.IPage page);

Parameters

page

[in] Specifies the document page (FCEngine.IPage) to be displayed in PageImageControl.

See also

PageImageControl

See sample: Visual Components


Designer Host. BlockHost Class

Visual Components Reference > DocumentView > ImageView >

Designer Host. BlockHost Class

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The Designer Host object may be regarded as a container and provider of services. The services may be regarded as auxiliary classes, each performing a specific function. Additionally, Designer Host controls components. As implemented for ImageView, components are blocks that are drawn in the workspace. In the ImageView control element, Designer Host is represented by the BlockHost class.

The major properties, methods, and events of the BlockHost class are listed in the tables below.

Properties

Name | Type | Description
Container | System.ComponentModel.IContainer, read-only | The container that contains the components.
Loading | System.ComponentModel.IContainer, read-only | It is true if BlockHost loads a document; otherwise it is false.

Methods

Name | Description
AddService | Adds a service to the service container.
Clear | Frees up the resources and removes all components and services. The method has no input parameters and returns void.
GetService | Returns a reference to the object of the service of the specified type.
SetBlocks | Adds components (i.e. blocks) to the component container and starts initializing BlockHost.
RemoveService | Removes the specified type of service from the service container.

Events

Name | Description
LoadComplete | Occurs after the initialization of BlockHost ends. The event does not generate event data and the event handler delegate type is System.EventHandler.

See also

ImageView

See sample: Visual Components


AddService Method of BlockHost

Visual Components Reference > DocumentView > ImageView > BlockHost >

AddService Method of BlockHost

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method adds a service to the service container.

C# Syntax

public void AddService(
Type serviceType,
object serviceInstance
);

Parameters

serviceType

[in] Specifies the service type.

serviceInstance

[in] Specifies a reference to the object of the service to add.

See also

BlockHost

See sample: Visual Components


GetService Method of BlockHost

Visual Components Reference > DocumentView > ImageView > BlockHost >

GetService Method of BlockHost

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method returns a reference to the object of the service of the specified type.

C# Syntax

public void GetService(Type serviceType);

Parameters

serviceType

[in] Specifies the type of the requested service.

See also

BlockHost

See sample: Visual Components


SetBlocks Method of BlockHost

Visual Components Reference > DocumentView > ImageView > BlockHost >

SetBlocks Method of BlockHost

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method adds components (i.e. blocks) to the component container and starts initializing BlockHost.

C# Syntax

public void SetBlocks(IEnumerable<IBlockRegion> blocks);

Parameters

blocks

[in] Specifies the set of blocks (BlockRegion) to add.

See also

BlockHost

See sample: Visual Components


RemoveService Method of BlockHost

Visual Components Reference > DocumentView > ImageView > BlockHost >

RemoveService Method of BlockHost

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method removes the specified type of service from the service container.

C# Syntax

public void RemoveService(Type serviceType);

Parameters

serviceType

[in] Specifies the service type to remove.

See also

BlockHost

See sample: Visual Components


Components. BlockRegion Class

Visual Components Reference > DocumentView > ImageView >

Components. BlockRegion Class

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
A component is an object that implements the System.ComponentModel.IComponent interface. In the context of the ImageView control element, components are blocks drawn in the workspace of ImageView. For different block types, there are different types of components in ImageView. However, all of them are inherited from the BlockRegion class.

The BlockRegion class contains all information required for drawing something in the ImageView workspace. It also serves as a link between the user interface of ImageView and ABBYY FlexiCapture Engine blocks (FCEngine.IBlock).

The major properties, methods, and events of the BlockRegion class are listed in the tables below.

Properties

Name | Type | Description
BlockBounds | System.Drawing.Rectangle, read-only | The coordinates of the block relative to the top left corner of the page (scale is ignored). For rectangular blocks, this value coincides with the block coordinates. For non-rectangular blocks, this value corresponds to the FCEngine.IBlock.Region element, which is defined by the Index property.
BlockOffsetScaledBounds | System.Drawing.Rectangle, read-only | The coordinates of the block relative to the top left corner of ImageView, taking the scale into account. Used for drawing a block.
CurrentEngineRegion | FCEngine.IRegion, read-only | The coordinates of the block in ABBYY FlexiCapture Engine format may differ from the value of EngineBlock.Region, if the coordinates of BlockRegion have been changed but the coordinates of EngineBlock have not been updated yet.
EngineBlock | FCEngine.IBlock, read-only | A reference to the FCEngine.IBlock object, which represents a block.
Index | System.Unt32, read-only | For non-rectangular blocks, it contains the index number of the element in the FCEngine.IBlock.Region collection corresponding to the current BlockRegion object.
IsSynchronized | System.Boolean, read-only | It is true if the BlockBounds coordinates are the same as the coordinates of the corresponding ABBYY FlexiCapture Engine block; otherwise it is false.
Offset | System.Drawing.Point, read-only | The offset of the BlockBounds coordinates relative to the top left corner of ImageView.
Scale | System.Single | The scale at which blocks are displayed.
Site | System.ComponentModel.ISite | A reference to the ISite object, which provides access to all the services added to Designer Host.

Methods

Name | Description
CancelUpdateEngineRegion | Cancels the transaction that changes the coordinates of the block. The value of the CurrentEngineRegion is updated based on the coordinates of the ABBYY FlexiCapture Engine block. The method has no input parameters and returns void.
EndUpdateEngineRegion | Ends the transaction that changes the coordinates of the block. The value of the coordinates of the corresponding ABBYY FlexiCapture Engine block is updated based on the value of CurrentEngineRegion. The method has no input parameters and returns void.
Move | Moves the block to the specified location.
IsCurrentEngineRegionValid | Returns true if the value of CurrentEngineRegion represents the correct coordinates of the block (i.e. all the children blocks are inside the block and the block itself is inside its parent block); otherwise returns false.
SetOffset | Specifies the value of the Offset property.
StartUpdateEngineRegion | Starts the transaction that changes the coordinates of the block. The value of CurrentEngineRegion is updated based on the value of BlockBounds. The method has no input parameters and returns void.
UpdateFromEngineRegion | Reads the coordinates of the corresponding ABBYY FlexiCapture Engine and updates the values of the BlockBounds and BlockOffsetScaledBounds properties based on these coordinates. The method has no input parameters and returns void.
UpdateFromScaledOffsetRectangle | Specifies the value of the BlockOffsetScaledBounds property and re-computes BlockBounds based on the new value of BlockOffsetScaledBounds.

Events

Name | Description
EngineRegionChanged | Occurs after the coordinates of the corresponding ABBYY FlexiCapture Engine block are changed. The event does not generate event data and the event handler delegate type is System.EventHandler.

See also

ImageView

Designer Host. BlockHost Class

See sample: Visual Components


Move Method of BlockRegion

Visual Components Reference > DocumentView > ImageView > BlockRegion >

Move Method of BlockRegion

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method moves the block to the specified location.

C# Syntax

public void Move(System.Drawing.Point point);

Parameters

point

[in] Specifies the new coordinates of the top left corner of the block.

See also

BlockRegion

See sample: Visual Components


IsCurrentEngineRegionValid Method of BlockRegion

Visual Components Reference > DocumentView > ImageView > BlockRegion >

IsCurrentEngineRegionValid Method of BlockRegion

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method returns true if the value of BlockRegion.CurrentEngineRegion represents the correct coordinates of the block (i.e. all the children blocks are inside the block and the block itself is inside its parent block); otherwise returns false.

C# Syntax

bool IsCurrentEngineRegionValid();

See also

BlockRegion

See sample: Visual Components


SetOffset Method of BlockRegion

Visual Components Reference > DocumentView > ImageView > BlockRegion >

SetOffset Method of BlockRegion

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method specifies the value of the BlockRegion.Offset property.

C# Syntax

public virtual void SetOffset(System.Drawing.Point point);

Parameters

point

[in] Specifies the new region offset.

See also

BlockRegion

See sample: Visual Components


UpdateFromScaledOffsetRectangle Method of BlockRegion

Visual Components Reference > DocumentView > ImageView > BlockRegion >

UpdateFromScaledOffsetRectangle Method of BlockRegion

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method specifies the value of the BlockRegion.Offset property.

C# Syntax

public virtual void UpdateFromScaledOffsetRectangle(System.Drawing.Rectangle rectangle);

Parameters

rectangle

[in] Specifies the new region size and location.

See also

BlockRegion

See sample: Visual Components


Designers. BlockDesigner Class

Visual Components Reference > DocumentView > ImageView >

Designers. BlockDesigner Class

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Each component has a component designer associated with it. The designer defines how the component looks like when a block is drawn. The designer is also a container for objects that define how the component responds to user actions, such as moving or resizing blocks. In ImageView there are various types of designer for various types of block. However, they are all inherited from the BlockDesigner class.

The major properties and methods of the BlockDesigner class are listed in the tables below.

Properties

Name | Type | Description
Block | IBlockRegion, read-only | A reference to the IBlockRegion object associated with the designer.
MoveBehavior | System.Windows.Forms. Design.Behavior.Behavior, read-only | A reference to the object that defines how the block should respond to moving.
ResizeBehavior | System.Windows.Forms. Design.Behavior.Behavior, read-only | A reference to the object that defines how the block should respond to resizing.

Methods

Name | Description
Initialize | Initializes the designer object and specifies the reference to the component with which the designer is associated.
GetGlyphs | Returns the collection of glyphs making up the block drawn in the workspace of ImageView. This method completely defines how the block looks like.

See also

ImageView

Components. BlockRegion Class

See sample: Visual Components


Initialize Method of BlockDesigner

Visual Components Reference > DocumentView > ImageView > BlockDesigner >

Initialize Method of BlockDesigner

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method initializes the designer object and specifies the reference to the component with which the designer is associated.

C# Syntax

public void Initialize(IComponent component);

Parameters

component

[in] Specifies the component with which the designer is associated. See Components. BlockRegion Class for details.

See also

BlockDesigner

See sample: Visual Components


GetGlyphs Method of BlockDesigner

Visual Components Reference > DocumentView > ImageView > BlockDesigner >

GetGlyphs Method of BlockDesigner

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method returns the collection of glyphs making up the block drawn in the workspace of ImageView. This method completely defines how the block looks like.

C# Syntax

public System.Windows.Forms.Design.Behavior.GlyphCollection GetGlyphs(GlyphSelectionType selectionType);

Parameters

selectionType

[in] Specifies the type of selection for the block (i.e. selected or non-selected).

Remarks

Glyphs may be regarded as constituent components of the frame of the block. The table below lists the various types of glyphs accompanied with their brief descriptions.

Glyph Type | Description
SelectionBorderGlyph | This is a part of the frame of a selected block.
NoResizeSelectionBorderGlyph | This is a part of the frame of a non-selected block.
TableCellBorderGlyph | This is a part of the frame of a block that represents a table cell.
GrabHandleGlyph | This is a marker which can be dragged to resize the block.

See also

BlockDesigner

See sample: Visual Components


Services

Visual Components Reference > DocumentView > ImageView >

Services

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
Services are auxiliary classes that perform certain functions. One important feature of the services is that any component may access any service via the Site property.

The table below lists the major services that are used in ImageView, accompanied with their brief descriptions.

Service Type | Description
ContextMenuCommandService | Implements component pop-up menus.
SelectionService | Controls block selection in the ImageView workspace.
UndoRedoService | Implements the undo/redo feature. This is a wrapper over the similar feature of ABBYY FlexiCapture Engine.
SelectionUIOverlay | Implements block drawing in the ImageView workspace.

See also

ImageView

Components. BlockRegion Class

See sample: Visual Components


SelectionUIOverlay Class and Drawing Blocks

Visual Components Reference > DocumentView > ImageView >

SelectionUIOverlay Class and Drawing Blocks

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The SelectionUIOverlay class inherits from the System.Windows.Forms.Control class and is a transparent control element. On the surface of this element, ImageView blocks (i.e. block glyphs) are drawn. The dimensions of this control element coincide with the dimensions of ImageView, i.e. SelectionUIOverlay is stretched across all ImageView pages.

The tables below list the major methods and events of the SelectionUIOverlay class.

Methods

Name | Description
DrawReversableFrame | Draws a selection rectangle.
SetBlocksScale | Specifies the scale at which the blocks should be displayed.
UpdateBlockGlyphs | Updates the set of glyphs and redraws SelectionUIOverlay. The method has no input parameters and returns void.
UpdateBlockRegionGlyphs | Updates the set of glyphs for the specified block and redraws the block.

Events

Name | Description
RegionClick | Occurs after clicking a block. The event does not generate event data and the event handler delegate type is System.EventHandler.
RegionDoubleClick | Occurs after double-clicking a block. The event does not generate event data and the event handler delegate type is System.EventHandler.
SelectionCompleted | Occurs after block selection ends. The event does not generate event data and the event handler delegate type is System.EventHandler.
SelectionStarted | Occurs after block selection starts (i.e. when the drawing of a selection rectangle begins).

See also

ImageView

See sample: Visual Components


DrawReversableFrame Method of SelectionUIOverlay

Visual Components Reference > DocumentView > ImageView > SelectionUIOverlay >

DrawReversableFrame Method of SelectionUIOverlay

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.

This method draws a selection rectangle.

C# Syntax

public void DrawReversableFrame(Rectangle rectangle, Color backColor, FrameStyle style);

Parameters

rectangle

[in] Specifies the coordinates and size of the selection rectangle.

backColor

[in] Specifies the background color used inside the selection rectangle.

style

[in] Specifies the style of the frame of the selection rectangle (either a solid or dotted line).

See also

SelectionUIOverlay

See sample: Visual Components


SetBlocksScale Method of SelectionUIOverlay

Visual Components Reference > DocumentView > ImageView > SelectionUIOverlay >

SetBlocksScale Method of SelectionUIOverlay

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method specifies the scale at which the blocks should be displayed.

C# Syntax

public void SetBlocksScale(float scale);

Parameters

scale

[in] Specifies the new scale value.

See also

SelectionUIOverlay

See sample: Visual Components


UpdateBlockRegionGlyphs Method of SelectionUIOverlay

Visual Components Reference > DocumentView > ImageView > SelectionUIOverlay >

UpdateBlockRegionGlyphs Method of SelectionUIOverlay

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method updates the set of glyphs for the specified block and redraws the block.

C# Syntax

public void UpdateBlockRegionGlyphs(IBlockRegion blockRegion);

Parameters

blockRegion

[in] Specifies the block (IBlockRegion) to redraw.

See also

SelectionUIOverlay

See sample: Visual Components


SelectionStarted Event of SelectionUIOverlay

Visual Components Reference > DocumentView > ImageView > SelectionUIOverlay >

SelectionStarted Event of SelectionUIOverlay

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after block selection starts (i.e. when the drawing of a selection rectangle begins).

C# Syntax

public event EventHandler<SelectionStartedEventArgs> SelectionStarted;
internal class SelectionStartedEventArgs: EventArgs
{
private Point _selectionStartPoint;
public Point SelectionStart
{
get { return _selectionStartPoint; }
}
public SelectionStartedEventArgs(Point selectionStartPoint)
{
_selectionStartPoint = selectionStartPoint;
}
}

Parameters

SelectionStart

[in] Specifies the point at which selection started.

See also

SelectionUIOverlay

See sample: Visual Components


ScrollToPage Method of ImageView

Visual Components Reference > DocumentView > ImageView >

ScrollToPage Method of ImageView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method scrolls the workspace of the component to display the specified page.

C# Syntax

public void ScrollToPage(FCEngine.IPage page);

Parameters

page

[in] Specifies the page (FCEngine.IPage) to be displayed.

See also

ImageView

See sample: Visual Components


RecognizeBlocks Method of ImageView

Visual Components Reference > DocumentView > ImageView >

RecognizeBlocks Method of ImageView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method recognizes the text of the specified blocks.

C# Syntax

public void RecognizeBlocks(IEnumerable<FCEngine.IBlock> blocks);

Parameters

blocks

[in] Specifies the blocks (FCEngine.IBlock) to be recognized.

See also

ImageView

See sample: Visual Components


CurrentPageChanged Event of ImageView

Visual Components Reference > DocumentView > ImageView >

CurrentPageChanged Event of ImageView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the ImageView.CurrentPage property is changed.

C# Syntax

public event System.EventHandler<PageChangedEventArgs> CurrentPageChanged;
public sealed class PageChangedEventArgs : EventArgs
{
private FCEngine.IPage _page;
public FCEngine.IPage Page
{
get { return _page; }
}
public PageChangedEventArgs(FCEngine.IPage page)
{
_page = page;
}
}

Parameters

Page

[in] Specifies the new active page (FCEngine.IPage) in ImageView.

See also

ImageView

See sample: Visual Components


DocumentView.Commands

Visual Components Reference > DocumentView >

DocumentView.Commands

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
DocumentView.Commands enumeration constants define the commands available in DocumentView.

C# Syntax

public enum Commands
{
Undo,
Redo,
ZoomIn,
ZoomOut,
RecognizeBlock,
AutoRecognizeBlocks
}

Elements

Name | Description
Undo | Cancel the latest action.
Redo | Cancel the latest undone action.
ZoomIn | Zoom into DocumentView.
ZoomOut | Zoom out of DocumentView.
RecognizeBlock | Recognize the selected block.
AutoRecognizeBlocks | Auto re-recognize blocks.

See also

DocumentView.DisableCommand

DocumentView.DoCommand

DocumentView.EnableCommand


CurrentPageChanged Event of DocumentView

Visual Components Reference > DocumentView >

CurrentPageChanged Event of DocumentView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the current document page (DocumentView.Page property) is changed.

C# Syntax

public event System.EventHandler<PageChangedEventArgs> CurrentPageChanged;
public sealed class PageChangedEventArgs : EventArgs
{
private FCEngine.IPage _page;
public FCEngine.IPage Page
{
get { return _page; }
}
public PageChangedEventArgs(FCEngine.IPage page)
{
_page = page;
}
}

Parameters

Page

[in] Specifies the new active page (FCEngine.IPage) in DocumentView.

See also

DocumentView

See sample: Visual Components


VerificationView Component

Visual Components Reference >

VerificationView Component

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The VerificationView component is intended for document verification. It can operate in one of two modes—group verification or context verification. The component switches between the two modes automatically depending on the input data it receives from ABBYY FlexiCapture Engine objects.

cicon2 Group verification mode

cicon2 Context verification mode

The VerificationView control element supports undo/redo functionality. See the description of the UndoRedoManager class for details.

The major properties, methods, and events of the VerificationView Visual Component are listed in the tables below.

Properties

Name | Type | Description
Common properties
Engine | FCEngine.IEngine | A reference to the ABBYY FlexiCapture Engine object. You must specify this property before you start working with VerificationView.
Major properties of VerificationView
Document | FCEngine.IDocument, read-only | The document that is being verified in context verification mode; NULL in group verification mode.
Page | FCEngine.IPage | The page that is being verified in context verification mode; NULL in group verification mode.
VerificationMode | VerificationView.Mode, read-only | Verification mode: group of context verification.

Methods

Name | Description
Common methods
DisableCommand | Disables the specified command.
DoCommand | Executes the specified command.
EnableCommand | Enables the specified command.
Major methods of VerificationView
EndVerification | Stops the verification process, frees up the resources, and clears the working memory of the component, returning it to its initial (empty) state. The method has no input parameters and returns void.
SaveChanges | Saves all the unsaved changes that were made during verification. The method has no input parameters and returns void.
StartVerification | [Overloaded] Starts the verification process.

Events

Name | Description
Common events
CommandExecuting | Occurs before the command is executed. Allows the command to be revoked.
CommandExecuted | Occurs after the command is executed.
Major events of VerificationView
VerificationCompleted | Occurs after the verification process ends.

note Note: In the VisualComponents implementation the CommandExecuting, CommandExecuted events are raised only when DoCommand is called explicitly. These events do not work when you run the command from the VerificationView component toolbar or context menu.

Architecture

In terms of architecture, the VerificationView component is a compound control element which contains two control elements, GroupVerificationControl and ContextVerificationControl, which are displayed or hidden depending on the current verification mode of VerificationView:

See also

GroupVerificationControl/ContextVerificationControl

See sample: Visual Components - Hello, Visual Components - Hello with FlexiCapture Project, Visual Components


GroupVerificationControl and ContextVerificationControl Control Elements

Visual Components Reference > VerificationView >

GroupVerificationControl and ContextVerificationControl Control Elements

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The GroupVerificationControl and ContextVerificationControl control elements implement group and context verification functionality respectively. The controls are displayed or hidden depending on the current verification mode of VerificationView. They serve as containers for all other verification control elements.

The main menu, the toolbar, and the status bar of the current verification mode of VerificationView are implemented via the following control elements:

·GroupVerificationMenuStrip and ContextVerificationMenuStrip for the main menu in the group and context verification modes respectively

·GroupVerificationToolStrip and ContextVerificationToolStrip for the toolbar in the group and context verification modes respectively

·GroupVerificationStatusStrip and ContextVerificationStatusStrip for the status bar in the group and context verification modes respectively

An important feature of the GroupVerificationControl and ContextVerificationControl control elements is that a fairly large number of actions can be performed via the main menu, the pop-up menu, or the button on the toolbar. The mechanism of the GUI commands implemented by the Command class makes use of an abstract command, which means any action performed by the user by means of the GUI. This allows you to associate one and the same command with a menu item and a button on the toolbar and specify the code of the command and the conditions that determine when the command can be enabled. If a command is enabled, all the control elements associated with the commands are also enabled. If a command is disabled, all of its associated control elements are disabled as well.

The major properties, methods, and events of the GroupVerificationControl and ContextVerificationControl control elements are listed in the tables below.

Properties

Name | Type | Description
CurrentVerificationGroup | FCEngine.IVerificationGroup, read-only | A reference to the current FCEngine.IVerificationGroup object, which represents the verification group.
CurrentVerificationObject | FCEngine.IVerificationObject, read-only | A reference to the current FCEngine.IVerificationObject, which represents the verification object.
CurrentVerificationSession | FCEngine.IVerificationSession, read-only | A reference to the current FCEngine.IVerificationSession, which represents the verification session.
CurrentVerificationWorkSet | FCEngine.IVerificationWorkSet, read-only | A reference to the current FCEngine.IVerificationWorkSet, which represents the set of data to verify.

Methods

Name | Description
EndVerification | Ends the verification process, frees up the resources, and clears the working memory of the component, returning it to its initial state. The method has no input parameters and returns void.
StartVerification | Starts the verification process.

Events

Name | Description
VerificationCompleted | Occurs after the verification process ends. The event does not generate event data and the event handler delegate type is System.EventHandler.

See also
VerificationView

ImageControl

FieldViewer

See sample: Visual Components - Hello, Visual Components - Hello with FlexiCapture Project, Visual Components


StartVerification Method of ContextVerificationControl or GroupVerificationControl

Visual Components Reference > VerificationView > GroupVerificationControl and ContextVerificationControl >

StartVerification Method of ContextVerificationControl or GroupVerificationControl

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method starts the verification process.

C# Syntax

public void StartVerification(
FCEngine.IVerificationSession verificationSession,
FCEngine.IVerificationWorkSet verificationWorkSet,
VerificationNavigator navigator)
);

Parameters

verificationSession

[in] Specifies a reference to the FCEngine.IVerificationSession object that represents the verification session.

verificationWorkSet

[in] Specifies a reference to the FCEngine.IVerificationWorkSet object that represents the set of data to verify.

navigator

[in] Specifies a reference to the auxiliary VerificationNavigator object which is used to navigate the verification groups.

See also

GroupVerificationControl and ContextVerificationControl Control Elements

See sample: Visual Components


FieldDescriptionControl Control Element

Visual Components Reference > VerificationView >

FieldDescriptionControl Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The FieldDescriptionControl control element displays additional information about the current character in group verification mode or additional information about the current field in context verification mode.

Properties

Name | Type | Description
Description | System.String | Description of the current character or field.

See also

VerificationView

See sample: Visual Components


ImageControl Control Element

Visual Components Reference > VerificationView >

ImageControl Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The ImageControl control element displays images and blocks on images. For each character selected in group or context verification mode, ImageControl displays the portion of the page where the selected character is located and the block that corresponds to the selected character.

Properties

Name | Type | Description
Blocks | FCEngine.BlockCollectionBase | This list of blocks that are drawn on the workspace of the control element.
Image | System.Drawing.Image | The image displayed in the workspace of ImageControl.
ScaleInPercents | System.UInt32, read-only | The current scale of the image.

Methods

Name | Description
ZoomIn | Zooms into the image. The method has no input parameters and returns void.
ZoomOut | Zooms out of the image. The method has no input parameters and returns void.

See also

GroupVerificationControl and ContextVerificationControl

See sample: Visual Components


FieldViewer Control Element

Visual Components Reference > VerificationView >

FieldViewer Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The GroupFieldViewer and ContextFieldViewer control elements, together with the GroupBlockViewer and ContextBlockViewer control elements, implement the major group and context verification functionality: they display recognized characters and character images and enable text selection, copying, pasting, editing, etc. The inheritance and containment relationships among these classes are shown in the figure below.

The major properties, methods, and events of the FieldViewer control element are listed in the tables below.

Properties

Name | Type | Description
Blocks | BlockCollectionBase | The list of blocks to be displayed.
CurrentBlock | VerificationBlock, read-only | The current block.
NextBlock | VerificationBlock, read-only | The next block relative to the current block.
PreviousBlock | VerificationBlock, read-only | The previous block relative to the current block.
SelectedBlocks | VerificationBlock[], read-only | The list of selected blocks.
SizeMode | SymbolBlockSizeMode | An enumeration that sets the scale at which characters and character images are displayed.
VerificationDescriptor | VerificationDescriptor | A reference to the auxiliary wrapper object that wraps the main ABBYY FlexiCapture Engine verification objects.

Methods

Name | Description
SelectAll | Selects all blocks. The method has no input parameters and returns void.
SelectBlock | Selects the specified block.
SelectFirstBlock | Selects the first block. The method has no input parameters and returns void.
SelectLastBlock | Selects the last block. The method has no input parameters and returns void.
SelectNone | Clears the selection of all blocks. The method has no input parameters and returns void.
ShowError | Displays the specified error text in the workspace of the component.

Events

Name | Description
BlockCollectionChanged | Occurs after an element is added to or removed from the collection of blocks. The event does not generate event data and the event handler delegate type is System.EventHandler.
CurrentBlockChanged | Occurs after the CurrentBlock property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
SizeModeChanged | Occurs after the SizeMode property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.
SymbolStateChanged | Occurs after the status of the character is changed.
SymbolValueChanged | Occurs after the value of the character is changed.
VerificationDescriptorChanged | Occurs after the VerificationDescriptor property is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.

See also

GroupVerificationControl and ContextVerificationControl

See sample: Visual Components


SelectBlock Method of FieldViewer

Visual Components Reference > VerificationView > FieldViewer >

SelectBlock Method of FieldViewer

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method selects the specified block.

C# Syntax

public void SelectBlock(VerificationBlock block);

Parameters

block

[in] Specifies the block to select.

See also

FieldViewer

See sample: Visual Components


ShowError Method of FieldViewer

Visual Components Reference > VerificationView > FieldViewer >

ShowError Method of FieldViewer

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method displays the specified error text in the workspace of the component.

C# Syntax

public void ShowError(string errorText);

Parameters

errorText

[in] Specifies the text of the error.

See also

FieldViewer

See sample: Visual Components


SymbolStateChanged Event of FieldViewer

Visual Components Reference > VerificationView > FieldViewer >

SymbolStateChanged Event of FieldViewer

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the status of the character is changed.

C# Syntax

public event System.EventHandler<SymbolEventArgs> SymbolStateChanged;
internal class SymbolEventArgs : EventArgs
{
private Symbol _symbol;
public SymbolEventArgs(Symbol symbol)
{
if (symbol == null)
{
throw new ArgumentNullException(string.Format(Resources.Localizer.Error_ArgumentNullException, "symbol", "ctor.SymbolEventArgs"));
}
this._symbol = symbol;
}
public Symbol Symbol
{
get
{
return this._symbol;
}
}
}

Parameters

Symbol

[in] Specifies the character, which status has been changed.

See also

FieldViewer

See sample: Visual Components


SymbolValueChanged Event of FieldViewer

Visual Components Reference > VerificationView > FieldViewer >

SymbolValueChanged Event of FieldViewer

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the value of the character is changed.

C# Syntax

public event System.EventHandler<SymbolEventArgs> SymbolValueChanged;
internal class SymbolEventArgs : EventArgs
{
private Symbol _symbol;
public SymbolEventArgs(Symbol symbol)
{
if (symbol == null)
{
throw new ArgumentNullException(string.Format(Resources.Localizer.Error_ArgumentNullException, "symbol", "ctor.SymbolEventArgs"));
}
this._symbol = symbol;
}
public Symbol Symbol
{
get
{
return this._symbol;
}
}
}

Parameters

Symbol

[in] Specifies the character, which value has been changed.

See also

FieldViewer

See sample: Visual Components


BlockViewer Control Element

Visual Components Reference > VerificationView >

BlockViewer Control Element

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The GroupBlockViewer control element displays the image of the character during group verification and supports selecting and changing the value of the character. The ContextBlockViewer control element displays the image of the character in the text of the field and is used for context verification. Additionally, ContextBlockViewer displays the recognized value of the character and supports selecting and copying the character and changing the value of the character.

The major properties of the BlockViewer control element, from which GroupBlockViewer and ContextBlockViewer inherit, are listed in the table below.

Properties

Name | Type | Description
Block | VerificationBlock | A reference to the auxiliary object that represents the block displayed by the control element.
Image | System.Drawing.Image | The image of the block character.
IsCurrent | System.Boolean, read-only | It is true if BlockViewer is current; otherwise it is false.
IsSelected | System.Boolean, read-only | It is true if BlockViewer is selected; otherwise it is false.
NextBlock | VerificationBlock, read-only | The next block relative to the current block.
ShowSpecialSymbols | System.Boolean | It is true if special symbols should be displayed; otherwise it is false (only for ContextBlockViewer).

See also

FieldViewer

See sample: Visual Components


UndoRedoManager Class and Support for Undo/Redo

Visual Components Reference > VerificationView >

UndoRedoManager Class and Support for Undo/Redo

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
The VerificationView control element supports undo/redo functionality, which is implemented in the following classes:

·FCEngine.VisualComponents.UndoRedoFramework.UndoRedoManager

·FCEngine.VisualComponents.UndoRedoFramework.UndoRedo<T>

·FCEngine.VisualComponents.UndoRedoFramework.UndoRedoCollection<T>

·FCEngine.VisualComponents.UndoRedoFramework.Change<T>

·FCEngine.VisualComponents.UndoRedoFramework.Command

The undo/redo functionality is implemented at the properties level. The value of any property of any object may be placed in an undo/redo stack, following which this value can be undone or restored. Multiple changes to several properties are grouped into an undo/redo transaction, which is described by the FCEngine.VisualComponents.UndoRedoFramework.Command class. Each command (transaction) stores the list of changes done to the properties of the objects. Each change is described by the generic class FCEngine.VisualComponents.UndoRedoFramework.Change<T>.

For a property to be written to the undo/redo stack and, as a consequence, become part of an undo/redo transaction, it must be an instance of the generic type FCEngine.VisualComponents.UndoRedoFramework.UndoRedo<T>.

Transactions are controlled by means of the static FCEngine.VisualComponents.UndoRedoFramework.UndoRedoManager class. The major properties, methods, and events of the UndoRedoManager class are listed in the tables below.

Properties

Name | Type | Description
CanUndo | System.Boolean, read-only | It is true if the last action can be undone; otherwise it is false.
CanRedo | System.Boolean, read-only | It is true if the last undone action can be redone; otherwise it is false.

Methods

Name | Description
Cancel | Cancels the transaction that was started by calling Start.
Commit | Ends the transaction that was started by calling Start, if any.
ContinueHistoryTracking | Resumes writing the undo/redo stack. The method has no input parameters and returns void.
FlushHistory | Clears the undo/redo stack. The method has no input parameters and returns void.
PreserveHistoryTracking | Pauses writing the undo/redo stack. Call this method if certain changes should not be placed into the undo/redo stack. The method has no input parameters and returns void.
Redo | Redoes the previously undone action, if any. If there is an unfinished transaction when the method is called, it throws InvalidOperationException. The method has no input parameters and returns void.
Start | Starts writing an undo/redo stack for the new transaction.
Undo | Undoes the previous action, if any. If there is an unfinished transaction when the method is called, it throws InvalidOperationException. The method has no input parameters and returns void.

Events

Name | Description
CommandDone | Occurs after a transaction ends.
CommandStarted | Occurs after a new transaction is started.

See also

VerificationView

See sample: Visual Components


Cancel Method of UndoRedoManager

Visual Components Reference > VerificationView > UndoRedoManager >

Cancel Method of UndoRedoManager

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method cancels the transaction that was started by calling UndoRedoManager.Start.

C# Syntax

public static void Cancel(string commandName);

Parameters

commandName

[in] Specifies the name of the transaction to be canceled.

See also

UndoRedoManager

See sample: Visual Components


Commit Method of UndoRedoManager

Visual Components Reference > VerificationView > UndoRedoManager >

Commit Method of UndoRedoManager

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method ends the transaction that was started by calling UndoRedoManager.Start, if any. If the name of the started transaction does not coincide with commandName, ArgumentException is generated.

C# Syntax

public static void Commit(string commandName);

Parameters

commandName

[in] Specifies the name of the transaction to be ended.

See also

UndoRedoManager

See sample: Visual Components


Start Method of UndoRedoManager

Visual Components Reference > VerificationView > UndoRedoManager >

Start Method of UndoRedoManager

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method starts writing an undo/redo stack for the new transaction.

C# Syntax

public static void Start(string commandName);

Parameters

commandName

[in] Specifies the name of the transaction.

See also

UndoRedoManager

See sample: Visual Components


CommandDone Event of UndoRedoManager

Visual Components Reference > VerificationView > UndoRedoManager >

CommandDone Event of UndoRedoManager

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after a transaction ends.

C# Syntax

public event System.EventHandler<CommandEventArgs> CommandDone;
internal class CommandEventArgs : EventArgs
{
private readonly CommandType _commandType;
public CommandType CommandDoneType
{
get
{
return this._commandType;
}
}
public CommandEventArgs(CommandType type)
{
this._commandType = type;
}
}

Parameters

CommandDoneType

[in] Specifies the type of the UndoRedoManager commands. It can be one of the following: Commit, Undo, Redo.

See also

UndoRedoManager

See sample: Visual Components


CommandStarted Event of UndoRedoManager

Visual Components Reference > VerificationView > UndoRedoManager >

CommandStarted Event of UndoRedoManager

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after a new transaction is started.

C# Syntax

public event System.EventHandler<CommandEventArgs> CommandStarted;
internal class CommandEventArgs : EventArgs
{
private readonly CommandType _commandType;
public CommandType CommandDoneType
{
get
{
return this._commandType;
}
}
public CommandEventArgs(CommandType type)
{
this._commandType = type;
}
}

Parameters

CommandDoneType

[in] Specifies the type of the UndoRedoManager commands. It can be one of the following: Commit, Undo, Redo.

See also

UndoRedoManager

See sample: Visual Components


Command Class and Mechanism of GUI Commands

Visual Components Reference > VerificationView >

Command Class and Mechanism of GUI Commands

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
An important feature of the GroupVerificationControl and ContextVerificationControl control elements is that a fairly large number of actions can be performed via the main menu, the pop-up menu, or the button on the toolbar. The mechanism of the GUI commands implemented by the FCEngine.VisualComponents.Command class makes use of an abstract command, which means any action performed by the user by means of the GUI. This allows you to associate one and the same command with a menu item and a button on the toolbar and specify the code of the command and the conditions that determine when the command can be enabled. If a command is enabled, all the control elements associated with the commands are also enabled. If a command is disabled, all of its associated control elements are disabled as well.

Properties

Name | Type | Description
Enabled | System.Boolean | Specifies whether the command is enabled. It is true if the command is enabled; otherwise it is false.

Methods

The methods do not take input parameters and have return value of void, unless marked otherwise.

Name | Description
ForceExecute | Executes the code of the command. The method has no input parameters and returns void.
ForceCanExecute | Executes the code which checks the conditions that determine whether the command is enabled. The method has no input parameters and returns void.
RegisterExecutingObject | [Overloaded] Registers the object which is to execute the command if a Click event occurs for the object.
UnregisterExecutingObject | [Overloaded] Unregisters the object which is to execute the command.
UnregisterAll | Unregisters all objects which are to execute the command. The method has no input parameters and returns void.

Events

Name | Description
CanExecute | Occurs upon a request to check if the command is enabled. The handler of this event must check the conditions that determine whether the command can be enabled and either enable or disable the command.
Execute | Occurs upon a request to execute the code of the command. The code of the command must be implemented by the developer in this handler. The event does not generate event data and the event handler delegate type is System.EventHandler.
EnabledChanged | Occurs after the Enabled property of the command is changed. The event does not generate event data and the event handler delegate type is System.EventHandler.

See also

GroupVerificationControl and ContextVerificationControl

See sample: Visual Components


RegisterExecutingObject Method of Command

Visual Components Reference > VerificationView > Command >

RegisterExecutingObject Method of Command

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method registers the object which is to execute the command if a Command.Click event occurs for the object. The method is overloaded.

C# Syntax

public void RegisterExecutingObject(Control o);
public void RegisterExecutingObject(ToolStripItem oo);

Parameters

o

[in] Specifies a System.Windows.Forms.Control as an executing object of the current command.

oo

[in] Specifies a System.Windows.Forms.ToolStripItem as an executing object of the current command.

See also

Command

See sample: Visual Components


UnregisterExecutingObject Method of Command

Visual Components Reference > VerificationView > Command >

UnregisterExecutingObject Method of Command

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method unregisters the object which is to execute the command. The method is overloaded.

C# Syntax

public void UnregisterExecutingObject(Control o);
public void UnregisterExecutingObject(ToolStripItem oo);

Parameters

o

[in] Specifies a System.Windows.Forms.Control as an executing object of the current command.

oo

[in] Specifies a System.Windows.Forms.ToolStripItem as an executing object of the current command.

See also

Command

See sample: Visual Components


CanExecute Event of Command

Visual Components Reference > VerificationView > Command >

CanExecute Event of Command

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs upon a request to execute the code of the command. The code of the command must be implemented by the developer in this handler.

C# Syntax

public event System.EventHandler<CanExecuteEventArgs> CanExecute;
internal class CanExecuteEventArgs : EventArgs
{
private bool _canExecute = true;
public bool CanExecute
{
get
{
return this._canExecute;
}
set
{
this._canExecute = value;
}
}
}

Parameters

CanExecute

[in, out] This parameter is true, if the command can be executed; otherwise it is false.

See also

Command

See sample: Visual Components


VerificationView.Commands

Visual Components Reference > VerificationView >

VerificationView.Commands

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
VerificationView.Commands enumeration constants define the commands available in VerificationView.

C# Syntax

public enum Commands
{
NextUncertainCharacter,
PreviousUncertainCharacter,
Confirm,
Postpone,
ConfirmAll,
PostponeAll,
Undo,
Redo
}

Elements

Name | Description
NextUncertainCharacter | Display the next uncertainly recognized character.
PreviousUncertainCharacter | Display the previous uncertainly recognized character.
Confirm | Confirm the character.
Postpone | Postpone the character.
ConfirmAll | Confirm all characters in the current verification group.
PostponeAll | Postpone all characters in the current verification group.
Undo | Cancel the latest action.
Redo | Cancel the latest undone action.

See also

VerificationView.DisableCommand

VerificationView.DoCommand

VerificationView.EnableCommand


StartVerification Method of VerificationView

Visual Components Reference > VerificationView >

StartVerification Method of VerificationView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This method starts the verification process. The method is overloaded. Use the second method for processing with FlexiCapture Processor.

C# Syntax

public void StartVerification(
FCEngine.IBatch batch,
FCEngine.IIntsCollection documentsForVerification
);
public void StartVerification(
FCEngine.IDocumentsCollection DocumentsForVerification
);

Parameters

batch

[in] Specifies the batch (FCEngine.IBatch) whose documents should be verified.

documentsForVerification

[in] Specifies the list of the identifiers of the documents to be verified.

DocumentsForVerification

[in] Specifies the collection of the documents to be verified.

See also

VerificationView

See sample: Visual Components - Hello, Visual Components - Hello with FlexiCapture Project, Visual Components


VerificationCompleted Event of VerificationView

Visual Components Reference > VerificationView >

VerificationCompleted Event of VerificationView

warning Important! This functionality is deprecated and will be removed in future versions. It is strongly recommended to work with the FlexiCapture Processor and its functionality for any required purposes.
This event occurs after the verification process ends.

C# Syntax

public event System.EventHandler<VerificationCompletedEventArgs> VerificationCompleted;
public class VerificationCompletedEventArgs: EventArgs
{
public bool NothingToVerify
{
get;
private set;
}
public VerificationCompletedEventArgs(bool nothingToVerify)
{
this.NothingToVerify = nothingToVerify;
}
}

Parameters

NothingToVerify

[in] This parameter is true, if there is nothing to verify after verification process ends; otherwise it is false.

See also

VerificationView

See sample: Visual Components - Hello, Visual Components - Hello with FlexiCapture Project, Visual Components


Licensing

No topics above this level

Licensing

A special protection technology is used to protect ABBYY FlexiCapture Engine 12 from illegal copying and distribution. This technology effectively excludes unauthorized use of ABBYY products by persons who have not signed a License Agreement with the software copyright owner.

Developer and Runtime Licenses

ABBYY FlexiCapture Engine has two types of licenses:

·Developer License

This license grants an SDK customer the right to use ABBYY FlexiCapture Engine for development purposes only or for internal use of the developed applications only under the terms of Software Developer License Agreement. Developer License does not allow developers to distribute their applications with ABBYY FlexiCapture Engine functions inside or to use the developed applications internally.

·Runtime License

This license grants developers the right to distribute ABBYY FlexiCapture Engine functions inside developer’s applications. Runtime licensing is regulated by Runtime License Agreement with ABBYY.

warning Important! The Runtime License should correspond to the Customer Project ID with which your application was compiled. Customer Project ID is passed to the functions which load FlexiCapture Engine as one of the input parameters.

Each license defines available ABBYY FlexiCapture Engine functionality by the set of included modules. For details about functionality your license includes see the description of ABBYY FlexiCapture Engine 12 Modules.

Standalone and Network Licenses

Both Developer and Runtime Licenses can be used either locally on a single computer or in a network. Consequently, each ABBYY FlexiCapture Engine license can have one of the following types:

·Standalone – for local work on a single computer;

·Network – licenses will be located on the server and passed down to workstations through the network.

Use and management of the licenses is performed with the License Manager utility.

License protection types

ABBYY FlexiCapture Engine 12 supports several protection mechanisms. Each of the license types can use one of the following types of protection:

·Hardware protection
Uses a USB dongle (hardware key) that contains the license parameters. Correct operation of the hardware key requires installing its drivers, which is currently possible only during automatic runtime installation.

·Software protection
Uses an activation file that should be obtained from the ABBYY server during a license activation process. Activation is carried out with the help of a special utility (the License Manager utility) included into the ABBYY FlexiCapture Engine package.

·Cloud protection
This is a special type of software protection that does not need activation but requires a persistent connection to the cloud licensing service. License parameters are contained in a password-protected file.

The details about use of protection keys and license activation you can find in the Activation section.

For additional licensing information, please contact the ABBYY office serving your region. You can find the list of ABBYY offices in the How to Buy section.

See also

Activation

ABBYY FlexiCapture Engine 12 Modules


About ABBYY FlexiCapture Engine Activation

About ABBYY FlexiCapture Engine 12 Activation

Licensing >

About ABBYY FlexiCapture Engine 12 Activation

ABBYY FlexiCapture Engine must be activated before use. If you have a Standalone license, you should activate ABBYY FlexiCapture Engine on the same computer on which ABBYY FlexiCapture Engine is installed. In the case of Network license, you should activate ABBYY FlexiCapture Engine on a network server – a computer which will manage and distribute licenses among workstations in a network. However ABBYY FlexiCapture Engine may be installed both on the network server and on workstations.

Both Standalone and Network licenses require Licensing Service (LicensingService.exe) for correct operation of ABBYY FlexiCapture Engine. The Licensing Service can be installed automatically during the Developer installation and the Runtime installation of the ABBYY FlexiCapture Engine library in automatic mode. If you need to install it manually, see Installing the Licensing Service for details.

note Note: The Licensing Service settings are provided in the LicensingSettings.xml file. The file is required for network installation and for standalone installation if Hardware or Cloud protection key is used. This file is generated automatically during automatic installation. When installing manually, you must specify the correct settings in this file. The XML scheme of the settings is located in the LicensingSettings.xsd file. You can find this file in the Inc folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Include Files Folder). The detailed description of the settings is provided in the Working with the LicensingSettings.xml File section.

For managing licenses ABBYY FlexiCapture Engine provides the License Manager utility. With the help of this utility you can add, remove, activate, deactivate, update licenses and view license properties. The License Manager utility allows you to work with licenses of all protection types:

·Software protection key
Uses an activation file that should be obtained from the ABBYY server during an activation process.

·Hardware protection key
Uses a USB dongle that contains the license parameters. In the case of a hardware protection key, license activation is not required.

·Cloud protection
Uses a password-protected file that contains the license parameters. In this case license activation is not required.

If you choose a hardware protection key

If you choose the hardware protection key, the Wibu CodeMeter drivers must be installed on the computer where the License Service is installed, which is currently possible only during automatic runtime installation. Once the installation is completed, connect the hardware protection key to the USB port of the computer. Make sure that you do it before the first run of the program. No license activation is required. To view license properties, use the License Manager utility.

If you choose cloud protection

If you choose cloud protection, you need to ensure that the Licensing Service installed on your computer can connect to ABBYY cloud licensing services: allow connections to *.abbyy.com on ports 80 and 443.

With cloud protection, license activation is not required, but the Licensing Service synchronizes with cloud in set time intervals. If the connection to the cloud licensing service is lost, there is also a certain timeout during which it can be re-established, otherwise the license is invalidated until the Licensing Service connects to the cloud again. The synchronization and timeout periods are the parameters of your license.

The same Cloud License can be used on multiple computers; no specific actions are required to allow concurrent usage.

If you choose a software protection key

A software protection key requires the activation of its serial number by means of the License Manager utility.

How is activation carried out?

Activation takes very little time and is carried out with the help of an Activation Wizard. This wizard is built into the License Manager utility. The Activation Wizard has a friendly interface and is used for sending the necessary activation information to ABBYY. The same wizard is used for loading the ABBYY License File (*.ABBYY.License file) which you receive from ABBYY during activation.

Activation information is sent as a code (Installation ID) which is generated on the basis of information about the computer on which the program is being installed. No personal information about the user or computer is used for generating this code and this code cannot be used for identifying the user.

Activation methods:

·Via the Internet

Activation is carried out automatically and takes only a few seconds. An Internet connection is required for this type of activation.

·By e-mail

The user needs to send an e-mail message generated by the program and containing information required for activation to product-activation-robot@abbyy.com. To ensure a quick reply from the mail robot, do not alter the information in the message body or Subject field.

·By e-mail from another computer

This method is suitable, if your computer does not have an Internet connection. The program will generate an e-mail message containing information required for activation and offer you to copy the message and send it to ABBYY from another computer.

In the case of activation via the Internet, the whole process is carried out automatically. In the case of activation by e-mail, the user needs to enter the path to the Activation File received from ABBYY in the corresponding field of the Activation Wizard.

Once the activation is complete, the program can be used.

Reactivation

ABBYY FlexiCapture Engine 12 can be reinstalled on one and the same computer an unlimited number of times without reactivation. However, if you make major upgrades, format your hard drive, or reinstall the operating system on the computer where the Licensing Service is installed, an additional activation may be required.

Deactivation

ABBYY FlexiCapture Engine 12 license can be deactivated. The deactivated license can be then activated on another computer. The number of allowed deactivations can be restricted by your license.

Deactivation takes very little time and is carried out with the help of a Deactivation Wizard. This wizard is built into the License Manager utility. During the deactivation the Activation File (*.ABBYY.License file) which you receive from ABBYY during activation is deleted. Any copy of this file cannot be used for activation again.

The deactivation can be performed only via the Internet. Deactivation is carried out automatically and takes only a few seconds. An Internet connection is required. Once the deactivation is complete, the license can be activated on another computer.

License update

If you have purchased additional modules or an additional amount of pages for ABBYY FlexiCapture Engine 12 and your license does not allow you to use them, you need to update the license. The license update process is similar to the activation process. The update process is carried out with the help of the Update Wizard and can be performed via the Internet or by e-mail. Once the update is complete, the newest functionality of the program can be used.

See also

Licensing


License Manager Utility

Licensing >

License Manager Utility

The License Manager utility (LicenseManager.exe) allows you to manage ABBYY FlexiCapture Engine licenses of all types. In the ABBYY SDK 12 License Manager dialog box you can activate, deactivate, or update license and view the properties of an activated license.

The License Manager utility is installed automatically during a Developer installation or during a Runtime ABBYY FlexiCapture Engine library installation in automatic mode together with the Licensing Service. This utility is accessible through Start > Programs > ABBYY FlexiCapture Engine 12 > License Manager or in the Bin folder. This utility is distributed along with other ABBYY FlexiCapture Engine 12 files allowed for distribution and is used for Runtime Licenses activation. Developers can also use the License Manager utility via command line to create their own registration utilities.

ABBYY SDK 12 License Manager dialog box

The following information about your ABBYY FlexiCapture Engine 12 license is available in the ABBYY SDK 12 License Manager dialog box:

Column

Description

Serial number

The ABBYY FlexiCapture Engine 12 serial number.

note Note: The icon in front of the serial number shows whether the license is currently in use:

The license is not in use now, all available CPU cores are free. The license can be used for processing.

The license is in use, but there are some free CPU cores. Some recognition processes can be run with this license.

The license is in use, all available CPU cores are busy. No more recognition processes can be run with this license.

You can view the detailed statistics of license usage in the menu Service > License Use Statistic.

Functionality subset

The functionality subset of the license.

Protection type

The protection type:

·Software (File) — software protection key;

·Hardware — hardware protection key.

·Cloud — cloud protection.

Installation type

The installation type:

·Standalone — the license is used on a local computer;

·Network — the license is located on a network computer.

Expiration date

The expiration date.

More details about the license you can find in the License Parameters table. To show or hide license parameters, use the License Parameters/Hide License Parameters button.

Activating, updating, or deactivating the license

To activate, update, or deactivate the license, press the corresponding button, or select the corresponding item in the menu, and follow the instructions in the dialog box that opens. See details about license activation, deactivation and update in the Activation section.

Buttons

·License Parameters/Hide License Parameters

Shows or hides license parameters.

·Activate license...

Starts the License Activation Wizard.

·Update license...

Starts the License Update Wizard for the selected license.

·Refresh

Updates the license list.

·Close

Closes the License Manager.

Menu items

Item |  | Description
License | Activate... | Starts the License Activation Wizard.
 | Update... | Starts the License Update Wizard for the selected license.
 | Deactivate... | Starts the License Deactivation Wizard for the selected license.
 | Copy Serial Number | Copies the selected license.
 | Close | Closes the License Manager.
Service | License Use Statistic... | Shows the statistics of license usage on the workstations.
 | Refresh | Updates the license list.
Help | Help | Opens the License Manager Help.

See also

Licensing

Activation


License Properties

License Parameters

Licensing > License Manager Utility >

License Parameters

The license parameters are displayed in the table below the list of the licenses in the License Manager. To view or hide license parameters, use the License Parameters/Hide License Parameters button in the main window of the License Manager.

cicon2 License Parameters

The License Parameters table provides information about your license. The following information about your ABBYY FlexiCapture Engine 12 license is available:

·Functionality subset of the license

·Type of protection (software, hardware or cloud protection)

·ABBYY FlexiCapture Engine 12 serial number

·Customer Project ID

·Expiration date for your ABBYY FlexiCapture Engine 12 license

·Performance limitation: CPU core limit (the number of CPU Core which can be used for recognition), minimum number of CPU cores which can be used on a station, performance limit (e.g. characters per second)

·Environment limitation: usage in a network, on virtual machines, on Amazon EC2 and Microsoft Azure.

·List of features that are allowed by your license (text types, export formats, additional modules, etc.)

Runtime license emulation

You can use your Developer's license in the Runtime emulated mode. That allows you to test your application which uses ABBYY FlexiCapture Engine 12 library.

To try emulation, select Emulated mode for license parameters. To change the settings, click Change and in the License Emulation Settings dialog box that appears, select modules that will be enabled for your Runtime License (you can select only those modules which are supported by your Developer License). If some modules are not used for your Runtime License, disable them.

note Note: License emulation is not available for ABBYY FlexiCapture Engine modules.

cicon2 License Emulation Settings

See also

License Manager Utility


Working with the Command Line

Licensing > License Manager Utility >

Working with the Command Line

The current version of the License Manager allows you to activate licenses from the command line. The following command line parameters are supported:

Parameter | Action
/SilentActivation | Use this parameter to activate the license that corresponds to the serial number specified after /SN.
/SN:<serial number> | Use this parameter to specify the serial number of the license to be activated. Specify the serial number in one of the following formats: XXXX-XXXX-XXXX-XXXX-XXXX-XXXX or XXXXXXXXXXXXXXXXXXXXXXXX.
/SaveActivationEMailToFile:<file name> | Use this parameter to save to file the text of the message generated by the program and containing the information required for activation of the number specified in the /SN= parameter.
/LoadActivationFile:<file name> | Loads the ABBYY License File and activates the serial number corresponding to this file.

When launched from the command line, the License Manager may return the following return codes:

Return code | Description
-1 | No command line parameters were specified.
0 | No errors.
1 | Invalid serial number.
2 | The serial number has been already activated.
3 | Unable to activate the serial number via the Internet. Try to activate it by e-mail.
4 | The license with hardware protection cannot be activated by e-mail.
5 | The specified file has not been found or is unavailable.
6 | Incorrect license file.
7 | Unable to load the application.
8 | Unable to save to file the text of the activation request.
9 | Unknown command line parameter.
11 | Unable to find the USB key to activate the license with hardware protection.
12 | Several USB keys have been found. Please, leave only one USB key plugged to the computer.
13 | Unable to connect to Licensing Service.

See also

Activation

License Manager Utility


About the LicensingSettings.xml File

Licensing >

About the LicensingSettings.xml File

The LicensingSettings.xml file contains the ABBYY FlexiCapture Engine protection settings. This file is necessary for correct work of the Licensing Service in the network. When Licensing Service is used on a local computer, this file is required if you use a Hardware protection key.

The file is generated automatically during Developer or Runtime installation in automatic mode. When installing manually, you must specify the correct settings in this file. The XML scheme of the settings is located in the LicensingSettings.xsd file. You can find this file in the Inc folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Include Files Folder).

Changing the Licensing Service settings

The Licensing Service settings include two main parts:

·the settings of the Licensing Service installed on the current computer, which are specified in the <LocalLicenseServer> tag,

·and the parameters of connection with the network server, where the Licensing Service is installed. These parameters are specified in the <LicensingServers>\<MainNetworkLicenseServer> tag.

If ABBYY FlexiCapture Engine is installed on a local computer, you should specify the settings only in the <LocalLicenseServer>, if necessary. While if ABBYY FlexiCapture Engine works in a network, <LocalLicenseServer> parameters are specified on the server, and <LicensingServers>\<MainNetworkLicenseServer> parameters on workstations. If a computer is used both as a server and as a workstation, both <LocalLicenseServer> and <LicensingServers>\<MainNetworkLicenseServer> parameters should be specified. See the descriptions of tags below for details.

cicon2 To change TCP/IP port

The Licensing Service uses 3022 TCP/IP port by default. If this port is closed on the computer where the Licensing Service is installed, the Licensing Service will not work. In this case, specify an open port in EndPointName attribute of <LocalLicenseServer> or <LicensingServers>\<MainNetworkLicenseServer> tag, for example:

<LocalLicenseServer>
<ConnectionProtocol ProtocolType="TCP/IP" EndPointName="1025"/>
</LocalLicenseServer>

or

<LicensingServers>
<MainNetworkLicenseServer ServerAddress="computername" ProtocolType="TCP/IP" EndPointName="1025"/>
</LicensingServers>
cicon2 To disable hardware protection keys

The Licensing Service enables using both hardware and software protection keys by default. If you do not use hardware protection keys, you can disable them. Set the Enable attribute of <LocalLicenseServer>\<EnableCodeMeterLicenses> tag to "no":

<LocalLicenseServer>
<ConnectionProtocol ProtocolType="<Protocol type>" />
<EnableCodeMeterLicenses Enable="no" />
</LocalLicenseServer>

Setting up a cloud license

If you are manually installing the Licensing Service to work with a Cloud License, your LicensingSettings.xml should specify only the <EnableCloud> tag:

<?xml version="1.0" encoding="utf-8"?>
<LicensingSettings xmlns="http://www.abbyy.com/Protection/LicensingSettings">
<LocalLicenseServer>
<EnableCloud Enable="yes" />
</LocalLicenseServer>
</LicensingSettings>

Other settings should be left default.

Setting up a redundant license server configuration

For licenses distributed via the network, you have the option of setting up a two-server configuration which will allow one of the servers to act as a backup to another in the case it goes offline.

In this case you will need Network Runtime Licenses, which will be activated on both license servers. The workstations must specify the addresses of both servers in <LicensingServers>\<MainNetworkLicenseServer> and <LicensingServers>\<BackupNetworkLicenseServer> tags. Each of the servers must specify the address of the other in <LocalLicenseServer>\<RedundancyNetworkLicenseServer>, together with the synchronization settings. While using the license, the workstations will interact with the main license server, sending the license parameters and usage statistics to it. The main license server will regularly synchronize this data with the backup server. The time interval for synchronization is specified by the RedundancySynchronizationTime attribute.

If the main license server fails, the backup server takes over the license management and continues to store information coming from the workstations. When the main server goes online, the license data is synchronized with the backup, and the main server again starts managing the licenses. However, if the main server is not restored during the time specified in the RedundancyLiveTime attribute, the backup server will stop functioning when this time runs out.

If the backup license server fails while the main server is working, the system will continue to work as if there is only one license server. When the backup server is restored, it will be synchronized with the main server and start function as a backup again.

cicon2 Sample of a redundant configuration

For the workstation:

<LicensingServers>
<MainNetworkLicenseServer ServerAddress="mainserver" ProtocolType="TCP/IP" EndPointName="1025"/>
<BackupNetworkLicenseServer ServerAddress="backupserver" ProtocolType="TCP/IP" EndPointName="1025"/>
</LicensingServers>

For the main license server:

<LocalLicenseServer>
<ConnectionProtocol ProtocolType="TCP/IP" EndPointName="1025"/>
<RedundancyNetworkLicenseServer ServerAddress="backupserver" ProtocolType="TCP/IP" EndPointName="1025" RedundancySynchronizationTime="10" RedundancyLiveTime="20"/>
</LocalLicenseServer>

For the backup license server:

<LocalLicenseServer>
<ConnectionProtocol ProtocolType="TCP/IP" EndPointName="1025"/>
<Redundancy NetworkLicenseServer ServerAddress="mainserver" ProtocolType="TCP/IP" EndPointName="1025" RedundancySynchronizationTime="10" RedundancyLiveTime="20"/>
</LocalLicenseServer>

note Note: If you need to use this configuration, please make sure that your license supports it. Contact your sales manager to find out.

Description of Tags

Tag

Type

Multiplicity

Parent Tag

Description

LicensingSettings

LicensingSettings.

Elements:

·LocalLicenseServer

·LicensingServers

1

no

Protection settings.

LocalLicenseServer

LocalLicenseServerSettings.

Elements:

·ConnectionProtocol

·EnableCodeMeterLicenses

·EnableCloud

·RedundancyNetworkLicenseServer

0...1

LicensingSettings

The parameters of the Licensing Service located on the same computer.

ConnectionProtocol

Complex Type.

Attributes:

·ProtocolType — the protocol type: LocalInterprocessCommunication, NamedPipes, TCP/IP, or Sockets.

note Note: This is an additional protocol type for the local Licensing Service. It is not necessary to specify this attribute for a standalone installation, as Standalone licenses are always used with the LocalInterprocessCommunication protocol type.

·EndPointName — (optional) TCP/IP port. By default, "3022".

0...1

LocalLicenseServer

The parameters of the connection protocol.

EnableCloud

Complex Type.

Attributes:

·Enable — specifies whether cloud licenses can be used on the computer (set it to "yes" or "no"). By default, "yes".

0...1

LocalLicenseServer

Specifies whether cloud licenses can be used on the computer.

EnableCodeMeterLicenses

Complex Type.

Attributes:

·Enable — specifies whether CodeMeter protection keys can be used on the computer (set it to "yes" or "no"). By default, "yes".

0...1

LocalLicenseServer

Specifies whether CodeMeter protection keys can be used on the computer.

RedundancyNetworkLicenseServer

NetworkServerAddress.

Attributes:

·ServerAddress — the DNS name or IP address of another server in the redundant configuration.

·ProtocolType — the protocol type: LocalInterprocessCommunication, NamedPipes, TCP/IP, or Sockets.

·EndPointName — (optional) TCP/IP port. By default, "3022".

·RedundancySynchronizationTime — the time (in seconds) in which the license information changes are to be synchronized between the main and the backup server. The value must be the same for both servers. Possible values: from 10 to 300. By default, 30.

·RedundancyLiveTime — the time (in hours) during which the backup server can function without a connection to the main server. The value must be the same for both servers. Possible values: from 1 to 48. By default, 24.

0...1

LocalLicenseServer

Specifies the settings of connection to another server and synchronization with it for each of the network license servers which work together in a redundant two-server configuration.

LicensingServers

Complex Type.

Elements:

·MainNetworkLicenseServer

·BackupNetworkLicenseServer

0...1

LicensingSettings

The list of network servers where the Licensing Service is installed.

MainNetworkLicenseServer

NetworkServerAddress.

Attributes:

·ServerAddress — the DNS name or IP address of the computer where the Licensing Service is installed.

·ProtocolType — the protocol type: LocalInterprocessCommunication, NamedPipes, TCP/IP, or Sockets.

·EndPointName — (optional) TCP/IP port. By default, "3022".

1

LicensingServers

The parameters of the connection with the main network server where the Licensing Service is installed.

BackupNetworkLicenseServer

NetworkServerAddress.

Attributes:

·ServerAddress — the DNS name or IP address of the computer where the Licensing Service is installed.

·ProtocolType — the protocol type: LocalInterprocessCommunication, NamedPipes, TCP/IP, or Sockets.

·EndPointName — (optional) TCP/IP port. By default, "3022".

0...1

LicensingServers

The parameters of the connection with the backup network license server.

Samples

The sample below shows a simple LicensingSettings.xml file for a standalone installation. Local inter-process communication is used. Hardware protection keys are disabled.

<?xml version="1.0" encoding="utf-8"?>
<LicensingSettings xmlns="http://www.abbyy.com/Protection/LicensingSettings">
<LocalLicenseServer>
<ConnectionProtocol ProtocolType="LocalInterprocessCommunication" />
<EnableCodeMeterLicenses Enable="no" />
</LocalLicenseServer>
</LicensingSettings>

The samples below show simple LicensingSettings.xml files for a network installation: a file for workstations and a file for a server. Licensing Service is located on the computer with the name "computername". The TCP/IP protocol is used for communication between the server and workstations.

For a workstation:

<?xml version="1.0" encoding="utf-8"?>
<LicensingSettings xmlns="http://www.abbyy.com/Protection/LicensingSettings">
<LicensingServers>
<MainNetworkLicenseServer ServerAddress="computername" ProtocolType="TCP/IP" />
</LicensingServers>
</LicensingSettings>

For a server:

<?xml version="1.0" encoding="utf-8"?>
<LicensingSettings xmlns="http://www.abbyy.com/Protection/LicensingSettings">
<LocalLicenseServer>
<ConnectionProtocol ProtocolType="TCP/IP" />
</LocalLicenseServer>
</LicensingSettings>

The sample below shows the LicensingSettings.xml that should be used with a Cloud License. Note that when you enable cloud licensing, other settings should be left default.

<?xml version="1.0" encoding="utf-8"?>
<LicensingSettings xmlns="http://www.abbyy.com/Protection/LicensingSettings">
<LocalLicenseServer>
<EnableCloud Enable="yes" />
</LocalLicenseServer>
</LicensingSettings>

See also

ABBYY FlexiCapture Engine Distribution Kit

Distribution of Applications Which Use the ABBYY FlexiCapture Engine Library

Installing the Licensing Service


Modules

ABBYY FlexiCapture Engine 12 Modules

Licensing >

ABBYY FlexiCapture Engine 12 Modules

The functionality of ABBYY FlexiCapture Engine 12 is represented by a set of modules. Each module is a group of Engine functions. Some modules can be included in ABBYY FlexiCapture Engine licenses as predefined modules and others as additional ones.

For additional licensing information, please contact the ABBYY office serving your region. You can find the list of ABBYY offices in the How to Buy section.

An ABBYY FlexiCapture Engine 12 License allows you to process a certain number of pages per period (usually per month). This means that the user can process (analyze, recognize, or export to any format) no more pages than is allowed by the user's license. The counter is incremented by 1 when processing an A4 page or smaller. When processing a page which is n times larger than A4, the counter will be incremented by n.

The modules available in ABBYY FlexiCapture Engine 12 are listed in the table below.

Module | Description
FlexiLayouts | Allows you to work with flexible descriptions (created with ABBYY FlexiLayout Studio).
Number of fields | Specifies the maximum number of fields, which can be recognized in a document. note Note: If the license contains this restriction, the Document Definitions, which contain table blocks, cannot be applied.
Verification | Provides access to the verification-related objects, extended character information, and some features of export to XML format.
Searchable PDF | Allows you to export electronic copies of documents to searchable PDF (IImageExportParams::CreateSearchablePDF).
Licensed custom components only | This module allows you to use either both protected and unprotected custom components, or only protected custom components.
Additional languages (OCR)
Chinese | This module provides access to the Chinese (PRC), Chinese (Taiwan) recognition languages.
Korean | This module provides access to the Korean, Korean (Hangul) recognition languages.
Japanese | This module provides access to the Japanese and Japanese (Modern)recognition language.
Thai | This module provides access to Thai recognition language.
Vietnamese | This module provides access to Vietnamese recognition language.
Arabic | This module provides access to Arabic recognition language.
Additional languages (ICR)
Cyrillic | This module allows you to recognize Cyrillic hand-printed texts.

License-related errors

When unavailable method is called, unsupported value is assigned to an object property or passed as an argument to an object method, the operation will fail, and the CO_E_NOT_SUPPORTED error code will be returned.

When number of processed pages exceeds the value allowed by Limited modification, the recognition methods will fail, and the E_FAIL error code will be returned.

When the license has been expired or not loaded, all methods of the Engine object will fail and return CLASS_E_NOTLICENSED error code.

See also

Licensing


Acknowledgements

Copyright and Trademark Notices

Licensing >

Copyright and Trademark Notices

ABBYY FlexiCapture Engine 12 is a version of ABBYY FlexiCapture intended for developers.

© 2017 ABBYY Production LLC. ABBYY, FLEXICAPTURE and FLEXILAYOUT are either registered trademarks or trademarks of ABBYY Software Ltd. SAMPLES code is property of ABBYY, exclusive rights are reserved. DEVELOPER is allowed to incorporate SAMPLES into his own APPLICATION and modify it under the terms of License Agreement between ABBYY and DEVELOPER.

This program is built on proprietary ABBYY technologies but also includes a number of third-party solutions.

·zlib

zlib.h -- interface of the 'zlib' general purpose compression library

version 1.2.8, April 28th, 2013

Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

Jean-loup Gailly Mark Adler

jloup@gzip.org

madler@alumni.caltech.edu

·OpenSSL

Copyright (c) 1998-2017 The OpenSSL Project. All rights reserved
This product includes cryptographic software written by Eric Young
(eay@cryptsoft.com)
. This product includes software written by Tim Hudson
(tjh@cryptsoft.com)
Copyright (C) 1995-1998 Eric Young
(eay@cryptsoft.com)

OpenSSL License
---------------
/* ====================================================================
* Copyright (c) 1998-2017 The OpenSSL Project. All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (
http://www.openssl.org/
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
*
openssl-core@openssl.org
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (
http://www.openssl.org/
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
* This product includes cryptographic software written by Eric Young
(eay@cryptsoft.com)
. This product includes software written by Tim
* Hudson
(tjh@cryptsoft.com)
Original SSLeay License
-----------------------
/* Copyright (C) 1995-1998 Eric Young
(eay@cryptsoft.com)
* All rights reserved.
* This package is an SSL implementation written
* by Eric Young
(eay@cryptsoft.com)
* The implementation was written so as to conform with Netscapes SSL.
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson
(tjh@cryptsoft.com)
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young
(eay@cryptsoft.com)
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson
(tjh@cryptsoft.com)
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]

·FreeType
Copyright 2006, 2007, 2008, 2009 by David Turner, Robert Wilhelm, and Werner Lemberg.

FreeType font driver for BDF fonts
Francesco Zappa Nardelli
<
francesco.zappa.nardelli@ens.fr
License
*******
Copyright (C) 2001-2002 by Francesco Zappa Nardelli
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*** Portions of the driver (that is, bdflib.c and bdf.h):
Copyright 2000 Computing Research Labs, New Mexico State University
Copyright 2001-2002 Francesco Zappa Nardelli
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
THE USE OR OTHER DEALINGS IN THE SOFTWARE.
FreeType font driver for PCF fonts
Francesco Zappa Nardelli
<
francesco.zappa.nardelli@ens.fr
License
*******
Copyright (C) 2000 by Francesco Zappa Nardelli
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
The FreeType Project LICENSE
----------------------------
2006-Jan-27
Copyright 1996-2002, 2006 by
David Turner, Robert Wilhelm, and Werner Lemberg
Introduction
============
The FreeType Project is distributed in several archive packages;
some of them may contain, in addition to the FreeType font engine,
various tools and contributions which rely on, or relate to, the
FreeType Project.
This license applies to all files found in such packages, and
which do not fall under their own explicit license. The license
affects thus the FreeType font engine, the test programs,
documentation and makefiles, at the very least.
This license was inspired by the BSD, Artistic, and IJG
(Independent JPEG Group) licenses, which all encourage inclusion
and use of free software in commercial and freeware products
alike. As a consequence, its main points are that:
o We don't promise that this software works. However, we will be
interested in any kind of bug reports. (`as is' distribution)
o You can use this software for whatever you want, in parts or
full form, without having to pay us. (`royalty-free' usage)
o You may not pretend that you wrote this software. If you use
it, or only parts of it, in a program, you must acknowledge
somewhere in your documentation that you have used the
FreeType code. (`credits')
We specifically permit and encourage the inclusion of this
software, with or without modifications, in commercial products.
We disclaim all warranties covering The FreeType Project and
assume no liability related to The FreeType Project.
Finally, many people asked us for a preferred form for a
credit/disclaimer to use in compliance with this license. We thus
encourage you to use the following text:
"""
Portions of this software are copyright © <year> The FreeType
Project (
www.freetype.org
). All rights reserved.
"""
Please replace <year> with the value from the FreeType version you
actually use.
Legal Terms
===========
0. Definitions
--------------
Throughout this license, the terms `package', `FreeType Project',
and `FreeType archive' refer to the set of files originally
distributed by the authors (David Turner, Robert Wilhelm, and
Werner Lemberg) as the `FreeType Project', be they named as alpha,
beta or final release.
`You' refers to the licensee, or person using the project, where
`using' is a generic term including compiling the project's source
code as well as linking it to form a `program' or `executable'.
This program is referred to as `a program using the FreeType
engine'.
This license applies to all files distributed in the original
FreeType Project, including all source code, binaries and
documentation, unless otherwise stated in the file in its
original, unmodified form as distributed in the original archive.
If you are unsure whether or not a particular file is covered by
this license, you must contact us to verify this.
The FreeType Project is copyright (C) 1996-2000 by David Turner,
Robert Wilhelm, and Werner Lemberg. All rights reserved except as
specified below.
1. No Warranty
--------------
THE FREETYPE PROJECT IS PROVIDED `AS IS' WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. IN NO EVENT WILL ANY OF THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY DAMAGES CAUSED BY THE USE OR THE INABILITY TO
USE, OF THE FREETYPE PROJECT.
2. Redistribution
-----------------
This license grants a worldwide, royalty-free, perpetual and
irrevocable right and license to use, execute, perform, compile,
display, copy, create derivative works of, distribute and
sublicense the FreeType Project (in both source and object code
forms) and derivative works thereof for any purpose; and to
authorize others to exercise some or all of the rights granted
herein, subject to the following conditions:
o Redistribution of source code must retain this license file
(`FTL.TXT') unaltered; any additions, deletions or changes to
the original files must be clearly indicated in accompanying
documentation. The copyright notices of the unaltered,
original files must be preserved in all copies of source
files.
o Redistribution in binary form must provide a disclaimer that
states that the software is based in part of the work of the
FreeType Team, in the distribution documentation. We also
encourage you to put an URL to the FreeType web page in your
documentation, though this isn't mandatory.
These conditions apply to any software derived from or based on
the FreeType Project, not just the unmodified files. If you use
our work, you must acknowledge us. However, no fee need be paid
to us.
3. Advertising
--------------
Neither the FreeType authors and contributors nor you shall use
the name of the other for commercial, advertising, or promotional
purposes without specific prior written permission.
We suggest, but do not require, that you use one or more of the
following phrases to refer to this software in your documentation
or advertising materials: `FreeType Project', `FreeType Engine',
`FreeType library', or `FreeType Distribution'.
As you have not signed this license, you are not required to
accept it. However, as the FreeType Project is copyrighted
material, only this license, or another one contracted with the
authors, grants you the right to use, distribute, and modify it.
Therefore, by using, distributing, or modifying the FreeType
Project, you indicate that you understand and accept all the terms
of this license.
4. Contacts
-----------
There are two mailing lists related to FreeType:
o
freetype@nongnu.org
Discusses general use and applications of FreeType, as well as
future and wanted additions to the library and distribution.
If you are looking for support, start in this list if you
haven't found anything to help you in the documentation.
o
freetype-devel@nongnu.org
Discusses bugs, as well as engine internals, design issues,
specific licenses, porting, etc.
Our home page can be found at
http://www.freetype.org
--- end of FTL.TXT ---

·Adobe Glyph List License (MIT)
Copyright (c) 1997,1998,2002,2007 Adobe Systems Incorporated
Permission is hereby granted, free of charge, to any person obtaining a copy of this documentation file to use, copy, publish, distribute, sublicense, and/or sell copies of the documentation, and to permit others to do the same, provided that:
- No modification, editing or other alteration of this document is allowed; and
- The above copyright notice and this permission notice shall be included in all copies of the documentation.
Permission is hereby granted, free of charge, to any person obtaining a copy of this documentation file, to create their own derivative works from the content of this document to use, copy, publish, distribute, sublicense, and/or sell the derivative works, and to permit others to do the same, provided that the derived work is not represented as being a copy or version of this document.
Adobe shall not be liable to any party for any loss of revenue or profit or for indirect, incidental, special, consequential, or other similar damages, whether based on tort (including without limitation negligence or strict liability), contract or other legal or equitable grounds even if Adobe has been advised or had reason to know of the possibility of such damages.Ê The Adobe materials are provided on an "AS IS" basis.Ê Adobe specifically disclaims all express, statutory, or implied warranties relating to the Adobe materials, including but not limited to those concerning merchantability or fitness for a particular purpose or non-infringement of any third party rights regarding the Adobe materials.

·APDFL
© 2000-2012 Datalogics, Inc.
Datalogics®, The DL Logo®, PDF2IMG™ and DLE™ are trademarks of Datalogics, Inc.
© 1984-2012 Adobe Systems Incorporated and its licensors. All rights reserved.
Adobe®, The Adobe Logo®, Adobe® PDF Library™, Powered by Adobe PDF Library logo, Reader® are either registered trademarks or trademarks of Adobe Systems Incorporated in the United States and/or other countries.

·zlib-CRC32 constants
zlib.h -- interface of the 'zlib' general purpose compression library
version 1.2.8, April 28th, 2013
Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Jean-loup Gailly Mark Adler
jloup@gzip.org

madler@alumni.caltech.edu

·MD5 message digest algorithm reference implementation

Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.

License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.

·little cms (MIT)

Copyright (c) 1998-2013 Marti Maria Saguer
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

·Kakadu
Portions of this software are copyright © 2013 University of New South Wales All rights reserved.

·Jasper
JasPer License Version 2.0
Copyright (c) 2001-2006 Michael David Adams
Copyright (c) 1999-2000 Image Power, Inc.
Copyright (c) 1999-2000 The University of British Columbia
All rights reserved.
Permission is hereby granted, free of charge, to any person (the
"User") obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge,
publish, distribute, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:
1. The above copyright notices and this permission notice (which
includes the disclaimer below) shall be included in all copies or
substantial portions of the Software.
2. The name of a copyright holder shall not be used to endorse or
promote products derived from the Software without specific prior
written permission.
THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
"AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
​

·DjVu
Portions of this computer program are copyright © 2008 Celartem, Inc. All rights reserved.
Portions of this computer program are copyright © 2011 Caminova, Inc. All rights reserved.
Portions of this computer program are copyright © 2013 Cuminas, Inc. All rights reserved.
DjVu is protected by U.S. Patent No. 6,058,214. Foreign Patents Pending.
Powered by AT&T Labs Technology.

License.DjVu.txt, which contains the terms of Expat, Release 2.0.1 License and of Jasper License Version 2.0:
Expat, Release 2.0.1 Copyright © 1998, 1999, 2000 Thai Open Source Software Center Ltd and Clark Cooper
Copyright © 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
JasPer License Version 2.0 Copyright © 2001-2006 Michael David Adams Copyright © 1999-2000 Image Power, Inc. Copyright © 1999-2000 The University of British Columbia All rights reserved. Permission is hereby granted, free of charge, to any person (the "User") obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notices and this permission notice (which includes the disclaimer below) shall be included in all copies or substantial portions of the Software. The name of a copyright holder shall not be used to endorse or promote products derived from the Software without specific prior written permission. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY. EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.

·haval

Copyright (c) 2003 Calyptix Security Corporation * All rights reserved. * * This code is derived from software contributed to Calyptix Security * Corporation by Yuliang Zheng.
* Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * 3. Neither the name of Calyptix Security Corporation nor the * names of its contributors may be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE.

·rhash
Copyright (c) 2005-2014 Aleksey Kravchenko <
rhash.admin@gmail.com

·WIBU SDK

WIBU, CodeMeter, SmartShelter, SmartBind are registered trademarks of Wibu-Systems.
German export regulations apply in the event of an export of Wibu-Systems products.

·Ikey
Copyright © 2005. SafeNet, Inc. All rights reserved.
SafeNet, Inc.4690 Millennium Drive, Belcamp, MD 21017 U.S.A.
SafeNet™ is a trademark of SafeNet, Inc.

·libmv (SURF detector)
Copyright (c) 2007, 2008, 2009 libmv authors.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

·FAST detector

Copyright (c) 2006, 2008, 2009, 2010 Edward Rosten
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
*Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
*Neither the name of the University of Cambridge nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

·AGAST++
Copyright (c) 2010, Elmar Mair All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the owner nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

·BRISK
BRISK - Binary Robust Invariant Scalable KeypointsReference implementation of[1] Stefan Leutenegger,Margarita Chli and Roland Siegwart, BRISK: Binary Robust Invariant Scalable Keypoints, in Proceedings of the IEEE International Conference on Computer Vision (ICCV2011).
Copyright (C) 2011 The Autonomous Systems Lab (ASL), ETH Zurich,Stefan Leutenegger, Simon Lynen and Margarita Chli.
Redistribution and use in source and binary forms, with or withoutmodification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the ASL nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ANDANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIEDWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AREDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANYDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED ANDON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THISSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE

·Razor Engine

Copyright © RazorEngine Project 2011-2017
Apache License

Version 2.0, January 2004
<http://www.apache.org/licenses/>

Terms and Conditions for use, reproduction, and distribution

1. Definitions

“License” shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.

“Licensor” shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.

“Legal Entity” shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, “control” means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.

“You” (or “Your”) shall mean an individual or Legal Entity exercising permissions granted by this License.

“Source” form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.

“Object” form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.

“Work” shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).

“Derivative Works” shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.

“Contribution” shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, “submitted” means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as “Not a Contribution.”

“Contributor” shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.

2. Grant of Copyright License

Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.

3. Grant of Patent License

Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.

4. Redistribution

You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
•(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
•(b) You must cause any modified files to carry prominent notices stating that You changed the files; and
•(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
•(d) If the Work includes a “NOTICE” text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.

You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.

5. Submission of Contributions

Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.

6. Trademarks

This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty

Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.

8. Limitation of Liability

In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability

While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

·LibJPEG

(C) 1991-1998, Thomas G. Lane
1. We don't promise that this software works. (But if you find any bugs,
please let us know!)
2. You can use this software for whatever you want. You don't have to pay us.
3. You may not pretend that you wrote this software. If you use it in a
program, you must acknowledge somewhere in your documentation that
you've used the IJG code.
In legalese:
The authors make NO WARRANTY or representation, either express or implied,
with respect to this software, its quality, accuracy, merchantability, or
fitness for a particular purpose. This software is provided "AS IS", and you,
its user, assume the entire risk as to its quality and accuracy.
This software is copyright (C) 1991-1998, Thomas G. Lane.
All Rights Reserved except as specified below.
Permission is hereby granted to use, copy, modify, and distribute this
software (or portions thereof) for any purpose, without fee, subject to these
conditions:
(1) If any part of the source code for this software is distributed, then this
README file must be included, with this copyright and no-warranty notice
unaltered; and any additions, deletions, or changes to the original files
must be clearly indicated in accompanying documentation.
(2) If only executable code is distributed, then the accompanying
documentation must state that "this software is based in part on the work of
the Independent JPEG Group".
(3) Permission for use of this software is granted only if the user accepts
full responsibility for any undesirable consequences; the authors accept
NO LIABILITY for damages of any kind.
These conditions apply to any software derived from or based on the IJG code,
not just to the unmodified library. If you use our work, you ought to
acknowledge us.
Permission is NOT granted for the use of any IJG author's name or company name
in advertising or publicity relating to this software or products derived from
it. This software may be referred to only as "the Independent JPEG Group's
software".
We specifically permit and encourage the use of this software as the basis of
commercial products, provided that all warranty or liability claims are
assumed by the product vendor.

·Intel Integrated Performance Primitives
Copyright © 2002-2008 Intel Corporation.

·LZMA SDK
LZMA SDK is placed in the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute the original LZMA SDK code, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.

·7-Zip Command line
7-Zip Copyright (C) 1999-2015 Igor Pavlov.
http://www.7-zip.org/license.txt
7-Zip
~~~~~
License for use and distribution
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7-Zip Copyright (C) 1999-2015 Igor Pavlov.
Licenses for files are:
1) 7z.dll: GNU LGPL + unRAR restriction
2) All other files: GNU LGPL
The GNU LGPL + unRAR restriction means that you must follow both
GNU LGPL rules and unRAR restriction rules.
Note:
You can use 7-Zip on any computer, including a computer in a commercial
organization. You don't need to register or pay for 7-Zip.
GNU LGPL information
--------------------
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You can receive a copy of the GNU Lesser General Public License from
http://www.gnu.org/

·jsoncpp
Copyright (c) 2007-2010 Baptiste Lepilleur
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

·LibPNG
libpng versions 1.0.7, July 1, 2000 through 1.6.23, June 9, 2016 are
Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are
derived from libpng-1.0.6, and are distributed according to the same
disclaimer and license as libpng-1.0.6 with the following individuals
added to the list of Contributing Authors:
Simon-Pierre Cadieux
Eric S. Raymond
Mans Rullgard
Cosmin Truta
Gilles Vollant
James Yu
and with the following additions to the disclaimer:
There is no warranty against interference with your enjoyment of the
library or against infringement. There is no warranty that our
efforts or the library will fulfill any of your particular purposes
or needs. This library is provided with all faults, and the entire
risk of satisfactory quality, performance, accuracy, and effort is with
the user.
Some files in the "contrib" directory and some configure-generated
files that are distributed with libpng have other copyright owners and
are released under other open source licenses.

libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
libpng-0.96, and are distributed according to the same disclaimer and
license as libpng-0.96, with the following individuals added to the list
of Contributing Authors:
Tom Lane
Glenn Randers-Pehrson
Willem van Schaik

libpng versions 0.89, June 1996, through 0.96, May 1997, are
Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
and are distributed according to the same disclaimer and license as
libpng-0.88, with the following individuals added to the list of
Contributing Authors:
John Bowler
Kevin Bracey
Sam Bushell
Magnus Holmgren
Greg Roelofs
Tom Tanner
Some files in the "scripts" directory have other copyright owners
but are released under this license.

libpng versions 0.5, May 1995, through 0.88, January 1996, are
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
For the purposes of this copyright and license, "Contributing Authors"
is defined as the following set of individuals:
Andreas Dilger
Dave Martindale
Guy Eric Schalnat
Paul Schmidt
Tim Wegner
COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
If you modify libpng you may insert additional notices immediately following
this sentence.
This code is released under the libpng license.

The PNG Reference Library is supplied "AS IS". The Contributing Authors
and Group 42, Inc. disclaim all warranties, expressed or implied,
including, without limitation, the warranties of merchantability and of
fitness for any purpose. The Contributing Authors and Group 42, Inc.
assume no liability for direct, indirect, incidental, special, exemplary,
or consequential damages, which may result from the use of the PNG
Reference Library, even if advised of the possibility of such damage.
Permission is hereby granted to use, copy, modify, and distribute this
source code, or portions hereof, for any purpose, without fee, subject
to the following restrictions:
1. The origin of this source code must not be misrepresented.
2. Altered versions must be plainly marked as such and must not
be misrepresented as being the original source.
3. This Copyright notice may not be removed or altered from any
source or altered source distribution.
The Contributing Authors and Group 42, Inc. specifically permit, without
fee, and encourage the use of this source code as a component to
supporting the PNG file format in commercial products. If you use this
source code in a product, acknowledgment is not required but would be
appreciated.
END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.

·libyaml
Copyright (c) 2006-2016 Kirill Simonov
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

·Intel Math Kernel Library 2017 Update 2
Copyright © 2017 Intel Corporation.
Intel Simplified Software License
(version January 2017)
This license applies to the following products:
Intel® Math Kernel Library (intel® MKL)
Intel® Integrated Performance Primitives (Intel® IPP)
Intel® Distribution for Python
Intel® Machine Learning Scaling Library (Intel® MLSL)
Copyright © 2017 Intel Corporation.
Use and Redistribution. You may use and redistribute the software (the "Software"), without modification, provided the following conditions are met:
Redistributions must reproduce the above copyright notice and the following terms of use in the Software and in the documentation and/or other materials provided with the distribution.
Neither the name of Intel nor the names of its suppliers may be used to endorse or promote products derived from this Software without specific prior written permission.
No reverse engineering, decompilation, or disassembly of this Software is permitted.
Limited patent license. Intel grants you a world-wide, royalty-free, non-exclusive license under patents it now or hereafter owns or controls to make, have made, use, import, offer to sell and sell ("Utilize") this Software, but solely to the extent that any such patent is necessary to Utilize the Software alone. The patent license shall not apply to any combinations which include this software. No hardware per se is licensed hereunder.
Third party and other Intel programs. "Third Party Programs" are the files listed in the "third-party-programs.txt" text file that is included with the Software and may include Intel programs under separate license terms. Third Party Programs, even if included with the distribution of the Materials, are governed by separate license terms and those license terms solely govern your use of those programs.
DISCLAIMER. THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE DISCLAIMED. THIS SOFTWARE IS NOT INTENDED NOR AUTHORIZED FOR USE IN SYSTEMS OR APPLICATIONS WHERE FAILURE OF THE SOFTWARE MAY CAUSE PERSONAL INJURY OR DEATH.
LIMITATION OF LIABILITY. IN NO EVENT WILL INTEL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. YOU AGREE TO INDEMNIFIY AND HOLD INTEL HARMLESS AGAINST ANY CLAIMS AND EXPENSES RESULTING FROM YOUR USE OR UNAUTHORIZED USE OF THE SOFTWARE.
No support. Intel may make changes to the Software, at any time without notice, and is not obligated to support, update or provide training for the Software.
Termination. Intel may terminate your right to use the Software in the event of your breach of this Agreement and you fail to cure the breach within a reasonable period of time.
Feedback. Should you provide Intel with comments, modifications, corrections, enhancements or other input ("Feedback") related to the Software Intel will be free to use, disclose, reproduce, license or otherwise distribute or exploit the Feedback in its sole discretion without any obligations or restrictions of any kind, including without limitation, intellectual property rights or licensing obligations.
Compliance with laws. You agree to comply with all relevant laws and regulations governing your use, transfer, import or export (or prohibition thereof) of the Software.
Governing law. All disputes will be governed by the laws of the United States of America and the State of Delaware without reference to conflict of law principles and subject to the exclusive jurisdiction of the state or federal courts sitting in the State of Delaware, and each party agrees that it submits to the personal jurisdiction and venue of those courts and waives any objections. The United Nations Convention on Contracts for the International Sale of Goods (1980) is specifically excluded and will not apply to the Software.
*Other names and brands may be claimed as the property of others.

·TWAIN Header
The TWAIN Toolkit is
distributed as is. The developer and distributors of the TWAIN Toolkit expressly disclaim all implied, express or
statutory warranties including, without limitation, the implied warranties of merchantability, noninfringement of
third party rights and fitness for a particular purpose. Neither the developers nor the distributors will be liable
for damages, whether direct, indirect, special, incidental, or consequential, as a result of the reproduction,
modification, distribution or other use of the TWAIN Toolkit.

·OpenCV
© Copyright 2018, OpenCV team
For Open Source Computer Vision Library
(3-clause BSD License)
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
•Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
•Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
•Neither the names of the copyright holders nor the names of the contributors may be used to endorse or promote products derived from this software without specific prior written permission.
This software is provided by the copyright holders and contributors “as is” and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall copyright holders or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage.


Distribution of Applications Which Use the ABBYY FlexiCapture Engine Library

No topics above this level

Distribution of Applications Which Use the ABBYY FlexiCapture Engine Library

You developed an application using the ABBYY FlexiCapture Engine functions inside and you want to distribute this application. In this case you need a Runtime License for distribution. If you plan your application to work locally on a single computer, you must have a Standalone Runtime License. If your applications work in a network, you will need a Network Runtime License. The Runtime License should correspond to the Customer Project ID with which your application was compiled. Customer Project ID is passed to the functions which load FlexiCapture Engine as one of the input parameters.

Distribution of applications using the ABBYY FlexiCapture Engine library includes two steps:

1.Installing the application and the ABBYY FlexiCapture Engine library on the local disk of the workstation

2.Activating the ABBYY FlexiCapture Engine Library with the Runtime License

The ABBYY FlexiCapture Engine distribution package includes the System Administrator's Guide. This guide contains complete information about local and network distribution of applications which use the ABBYY FlexiCapture Engine library.

See also

ABBYY FlexiCapture Engine Distribution Kit

Licensing


Installing the ABBYY FlexiCapture Engine Library

Distribution >

Installing the ABBYY FlexiCapture Engine Library

The first step of distribution of applications using the ABBYY FlexiCapture Engine library is installation of the application and the ABBYY FlexiCapture Engine library on the local disk of the workstation.

After installing your application on a workstation, you should install the ABBYY FlexiCapture Engine library. It may be installed in automatic or manual mode. See for details:

·Installing the ABBYY FlexiCapture Engine Library in Automatic Mode

·Installing the ABBYY FlexiCapture Engine Library in Manual Mode

On the workstation, Microsoft® Internet Explorer 5.0 or higher should be installed:

The following registry branches should be accessible from the workstation:

o"HKEY_CURRENT_USER\Software\ABBYY\SDK\12\FlexiCapture Engine" — full control

o"HKEY_CURRENT_USER\Software\ABBYY\SDK\12" — full control for installation only

o"HKEY_LOCAL_MACHINE\Software\ABBYY\SDK\12" — full control for installation only

The following folders should be accessible from the workstation:

oFolder with ABBYY FlexiCapture Engine binary files — access for reading

o%TEMP% folder — full control access

ofolder %ProgramData%\ABBYY\SDK\12\FlexiCapture Engine – full control access;

ofolder %ProgramData%\ABBYY\SDK\12\Licenses – full control access

warning Important! Never redistribute the files with ABBYY FlexiCapture Engine API description (FCEngine.h, FCEngine_i.c).

See also

Installing the ABBYY FlexiCapture Engine Library in Automatic Mode

Installing the ABBYY FlexiCapture Engine Library in Manual Mode

ABBYY FlexiCapture Engine Distribution Kit

Licensing


Installing the ABBYY FlexiCapture Engine Library in Automatic Mode

Distribution > Installing the Library >

Installing the ABBYY FlexiCapture Engine Library in Automatic Mode

The runtime installation of the ABBYY FlexiCapture Engine library in automatic mode can be performed only from the command line in silent mode. Run the setup.exe file from the installation DVD-ROM with the command line options described below.

Option

Default Value

Description

INSTALLDIR="<destination path>"

The path to the folder where the ABBYY FlexiCapture Engine library will be installed.

warning Important! This parameter is required.

DeinstallRuntime=Yes | No

No

Specifies if the existing runtime installation of the library must be uninstalled.

ARCH=x86 | x64 | Auto

Auto

Specifies whether 32-bit or 64-bit files should be installed. If ARCH=Auto, the set of files is selected depending on the operating system architecture.

note Note: On a 64-bit operating system, the 64-bit version of License Manager is always installed, even if you specify ARCH=x86.

ADDITIONALLANGUAGES=<list of languages> | No

CJK, Thai, Vietnamese, Arabic

The list of recognition language modules that you want to install. The following additional languages are available: CJK, Thai, Vietnamese, Arabic. The language names must be separated with commas (,). For example, ADDITIONALLANGUAGES=CJK,Thai,Vietnamese. If you do not want to install any of these modules, set this option to No.

PDF=Yes | No

Yes

Specifies whether the modules, which are necessary for PDF opening, should be installed.

FRE=Yes | No

No

Set the value to "Yes", if you want ABBYY FineReader Engine 12 to be installed.

WIBUDR=Yes | No

No

Specifies whether hardware key drivers (CodeMeter) must be installed.

LICENSESRV=Yes | No

Yes

Specifies whether Licensing Service must be installed. If WIBUDR=Yes, the Licensing Service is installed automatically and cannot be excluded from the installation. The Licensing Service is installed to the %ProgramFiles%\Common Files\ABBYY\SDK\12\Licensing folder on a 32-bit operating system, and %ProgramFiles(x86)%\Common Files\ABBYY\SDK\12\Licensing folder on a 64-bit operating system.

warning Important! Licensing Service is required for working with ABBYY FlexiCapture Engine library, and for correct installation you must do one of the following:

·If you have a Standalone or a Cloud license, you should install the Licensing Service on the same computer on which ABBYY FlexiCapture Engine is installed. Set this parameter to Yes.

·In the case of Network license, you should install the Licensing Service beforehand on a network server — a computer which will manage and distribute licenses among workstations in a network. Set this parameter to No and specify the address of the server in the SERVERNAME parameter during installation on your workstation. If you set this parameter to No and omit the server address, an error will be returned and installation will not be completed.

SERVERNAME=<the DNS name or IP address>

The DNS name or IP address of the computer where the Licensing Service is installed.

BCPATTERNS=Yes

Selects bytecode modules and patterns for installation. If this option is not used, standard files are installed.

RegisterCOM=Yes | No | Force

Yes

Specifies whether the COM wrappers should be registered. The registration is performed by calling the DllRegisterServer function from FCEngine.dll. If the library is already registered with the different path:

·if this option is set to Yes, an error is returned;

·if this option is set to Force, the library is re-registered to the new path and the installation is continued.

If the MODULES option contains VC or is set to All, the library must be registered. Setting this option to No will cause an error and the installation will not be completed.

/v

Indicates the beginning of the list of installation parameters.

/q

Silent mode. This is mandatory option because the runtime installation can be performed only in silent mode. Use the /qb option if you want a progress bar to be displayed during the installation. No other dialog boxes will be displayed.

note Notes:

·When you use silent mode, the /q option must precede the /v option, for example: setup.exe /q /v or setup.exe /qb /v

·If setup.exe is run in silent mode without parameters, full developer installation is performed.

For example

setup.exe /q /v WIBUDR=Yes INSTALLDIR="C:\MyFolder"

This command line will install (in silent mode) ABBYY FlexiCapture Engine into the C:\MyFolder folder. The hardware key drivers will be installed.

setup.exe /qb /v INSTALLDIR="C:\MyFolder"

This command line will install (in silent mode) all library modules into the C:\MyFolder folder, a progress bar will be displayed.

setup.exe /q /v SERVERNAME=MyServer INSTALLDIR="C:\MyFolder" LICENSESRV=No

This command line will install all library modules into the C:\MyFolder folder in silent mode. License Service will not be installed and ABBYY FlexiCapture Engine will be configured to use Network Licenses from the server located on the MyServer computer.

See also

Distribution

ABBYY FlexiCapture Engine Distribution Kit

Modules


Installing the ABBYY FlexiCapture Engine Library in Manual Mode

Distribution > Installing the Library >

Installing the ABBYY FlexiCapture Engine Library in Manual Mode

To install the ABBYY FlexiCapture Engine library in manual mode:

1.Copy the following files:

oFiles marked as "mandatory" in the table of the ABBYY FlexiCapture Engine Distribution Kit section. They are system modules and main recognition databases.

oRecognition databases for handprinted text, if you want to recognize handprinted text.

oResource files for interface languages that will be used in your application.

oDictionary support files for recognition languages that your application will support. If the recognition languages include languages with the Latin alphabet, make sure that you copy the Univers.amd and Univers.amm files.

oScanning modules, scanning-specific resources and Twain modules if your application will perform scanning via the ABBYY FlexiCapture Engine interface.

oFineReader Engine modules, if your application will use FineReader Engine functionality.

note Note: You can use the FCEngine12_Distribution.csv file to generate the list of files required for your application to function.

2.Install MSXML 6.0, if your application performs export to XML format. You can install MSXML from the MSXML folder of the distribution package.

3.Install Microsoft Visual C++ 2015 Redistributable.

4.Create the folders:

o%ProgramData%\ABBYY\SDK\12\FlexiCapture Engine

o%ProgramData%\ABBYY\SDK\12\Licenses

Everyone must have full control access to these folders.

After you have copied all necessary ABBYY FlexiCapture Engine library files, you need to activate the library.

See also

Distribution

Installing the ABBYY FlexiCapture Engine Library

Activating the Runtime License


Activating the ABBYY FlexiCapture Engine Library with the Runtime License

Distribution >

Activating the ABBYY FlexiCapture Engine Library with the Runtime License

The second step of distribution of applications using the ABBYY FlexiCapture Engine library is activation of the library with the Runtime License.

If you use a Standalone Runtime License, activation is performed on the workstation where the ABBYY FlexiCapture Engine library is installed. If you use a Network Runtime License, you should activate ABBYY FlexiCapture Engine on a network server – a computer which will manage and distribute licenses among workstations in a network.If you use a Cloud Runtime License, no activation is required but you should verify that connections to the ABBYY cloud licensing services are allowed.

You will need to use one of the variants described in the table below. The selection depends on the type of your protection key and the mode of the ABBYY FlexiCapture Engine library installation.

Protection Key | Mode of Library Installation
 | Automatic | Manual
software | 1.Run the License Manager utility. 2.Activate a license. | 1.Install the Licensing Service. 2.Run the License Manager utility and activate a license.
hardware | License activation is not required. Connect the hardware protection key to the USB port of the computer. You can view license properties with the License Manager utility. | warning Important! If you use Wibu CodeMeter keys, you will need to install the drivers during automatic runtime installation. CodeMeter key drivers currently cannot be installed separately.
cloud | License activation is not required. Verify that you allow connections to *.abbyy.com on ports 80 and 443. | 1.Install the Licensing Service. 2.Verify that you allow connections to *.abbyy.com on ports 80 and 443. License activation is not required.

Changing the Type of the Protection Key

If you changed a software protection key to a hardware protection key (CodeMeter), you will need to re-run the automatic installation and install CodeMeter drivers. CodeMeter key drivers currently cannot be installed separately.

See also

Installing the ABBYY FlexiCapture Engine Library in Automatic Mode

Installing the ABBYY FlexiCapture Engine Library in Manual Mode

ABBYY FlexiCapture Engine Distribution Kit

Licensing


Installing the Licensing Service

Distribution > Activating the Library >

Installing the Licensing Service

For correct operation of applications using the ABBYY FlexiCapture Engine 12 library, the Licensing Service (LicensingService.exe) is required.

The Licensing Service is installed automatically during the Developer and Runtime installation in automatic mode. If you use manual installation, follow the instructions below. After the installation of the Licensing Service is complete, run the License Manager to manage licenses.

The Licensing Service settings are provided in the LicensingSettings.xml file. This file is generated automatically during automatic installation. When installing manually, you must specify the correct settings in this file. The XML scheme of the settings is located in the LicensingSettings.xsd file. You can find the XML scheme file in the Inc folder (Start > Programs > ABBYY FlexiCapture Engine 12 > Installation Folders > Include Files Folder). The detailed description of the settings is provided in the Working with the LicensingSettings.xml File section.

note Notes:

·We recommend that you install (uninstall) the Licensing Service in manual mode only during Runtime installation (deinstallation). For development purposes use the standard installation and deinstallation.

·Use ABBYY FlexiCapture Engine and Licensing Service from the same package. Otherwise, compatibility is not guaranteed.

Installing in manual mode

warning Important! Administrator access rights are necessary for the installation.

For Standalone installation:

1.Copy the files for the Licensing Service and the License Manager utility on the workstation: AbbyyZlib.dll, Awl.dll, FineNet.dll, FineObj.dll, FObjEventSrc.dll, Protection.dll, LicensingSchema.xe, ProductLicensingSchema.xe, LicensingService.exe, LicenseManager.exe, LicensingSettings.xml, ProtectionRes0.dll, and ProtectionResShared.dll. See the ABBYY FlexiCapture Engine Distribution Kit for details.

note Note: You may omit the LicensingSettings.xml file if you do not use hardware protection and need not specify any additional parameters.

2.Install Microsoft Visual C++ 2015 Redistributable, or copy the vcruntime140.dll file.

3.Create the %ProgramData%\ABBYY\SDK\12\Licenses folder. Everyone must have read and write permissions to this folder.

4.If necessary, specify parameters of the LocalLicenseServer in the LicensingSettings.xml file.

5.Run LicensingService.exe with the "/install" parameter: LicensingService.exe /install.

For Network installation:

1.Copy the files for the Licensing Service and the License Manager utility on the computer which will be used as a license server: AbbyyZlib.dll, Awl.dll, FineNet.dll, FineObj.dll, FObjEventSrc.dll, Protection.dll, LicensingSchema.xe, ProductLicensingSchema.xe, LicensingService.exe, LicenseManager.exe, LicensingSettings.xml, ProtectionRes0.dll, and ProtectionResShared.dll. See the ABBYY FlexiCapture Engine Distribution Kit for details.

2.Install Microsoft Visual C++ 2015 Redistributable, or copy vcruntime140.dll file.

3.Create the %ProgramData%\ABBYY\SDK\12\Licenses folder. Everyone must have read and write permissions to this folder.

4.In the LicensingSettings.xml file specify:

othe ProtocolType attribute of the ConnectionProtocol element of the LocalLicenseServer tag;

othe ServerAddress and ProtocolType attributes of the MainNetworkLicenseServer tag.

5.Copy the LicensingSettings.xml file with the specified settings into the Bin folder of the FlexiCapture Engine library installation on all the workstations.

6.Run LicensingService.exe with the "/install" parameter: LicensingService.exe /install.

Uninstalling in manual mode

To uninstall the Licensing Service in manual mode, run LicensingService.exe with the "/uninstall" parameter: LicensingService.exe /uninstall. Then remove the directory with the Licensing Service files.

See also

Activation

Distribution of Applications Using the ABBYY FlexiCapture Engine Library


ABBYY FlexiCapture Engine Distribution Kit

Distribution >

ABBYY FlexiCapture Engine Distribution Kit

ABBYY FlexiCapture Engine library is implemented as a set of dynamic link libraries (DLL) and additional modules. After you’ve installed the library with Developer License, its type library is registered in the system registry.

The description of the files of the library is given in the tables below. The list of files supplied in different ABBYY FlexiCapture Engine distribution kits may not be the same as in the list below and may vary depending on the product’s version. These tables also specify what files should be distributed as a part of your application, and what should not.

Include files folder and code samples folder

You can find the Inc and Samples folders in the FlexiCapture Engine data folder: %ProgramData%\ABBYY\SDK\12\FlexiCapture Engine.

Folder

File name

Description

Distribution

Inc

FCEngine.tlb

ABBYY FlexiCapture Engine type library description.

Redistribute this file if you load the Engine object to your application using COM loaders.

FCEngine.h, FCEngine_i.c

ABBYY FlexiCapture Engine API declaration files.

Never distribute these files. They are intended for developer purposes only.

FREngine.tlb

ABBYY FineReader Engine type library description.

Redistribute this file if you load the Engine object of FineReader Engine library to your application using COM loaders.

FREngine.h, FREngine_i.c

ABBYY FineReader Engine API declaration files.

Never distribute these files. They are intended for developer purposes only.

LicensingSettings.xsd

XML schema for the LicensingSettings.xml file.

No.

Inc\.NET interops

The folder contains .NET wrappers for FlexiCapture Engine type library, FlexiCapture Engine Visual Components type library and and FineReader Engine type library. These wrappers are generated for Microsoft .NET Framework version 2.0, 3.5, 4.0, and 4.5. The wrappers corresponding to each version are placed in the v2.0, v3.5, v4.0, and v4.5 subfolders, respectively.

Redistribute the Interop.FCEngine.dll file for suitable .NET Framework version, if you use .NET developer tools.

Redistribute the Interop.FREngine.dll file for suitable .NET Framework version, if you use .NET developer tools and you intend your application to use ABBYY FineReader Engine functionality.

Redistribute the FCEngine.VisualComponents.dll files for suitable .NET Framework version, if you use .NET developer tools and you intend your application to use ABBYY FlexiCapture Engine Visual Components. The Visual Components wrapper is not available for 4.5 version.

Inc\Java

com.abbyy.FCEngine.jar

Java class library for FlexiCapture Engine.

Redistribute the file, if your application is written in Java.

com.abbyy.FREngine.jar

Java class library for FineReader Engine.

Redistribute the file, if your application is written in Java.

Samples

This folder contains sample code illustrating ABBYY FlexiCapture Engine usage in C++ with and without Native COM support, in C#, Visual Basic .NET, Java, and in Delphi.

No.

Samples (FREngine)

The ABBYY FineReader Engine 12 code samples.

No.

ABBYY FlexiCapture Engine 12 folder

All paths are given as relative to the root folder of the ABBYY FlexiCapture Engine distribution package. The root folder is set up during ABBYY FlexiCapture Engine installation.

Folder

File name

Description

Distribution

ReadMe.htm

Readme file.

No.

EULA0.rtf

EULA file in English.

No.

Installation Guide

FCEngine12AdminGuide.pdf

System administrator's guide for standalone installation.

No.

Help

FCEngine12_Distribution.csv

The list of ABBYY FlexiCapture Engine files in the Bin, Bin64, Data and Licenses folders saved in CSV format. Can be used to generate the list of files for distribution.1

No.

FREngineDistribution.csv

The list of ABBYY FineReader Engine files in the Bin, Bin64 and Data folders saved in the CSV format.

FCEngine12.chm

Developer's Help.

No.

FCEngine12UserGuide.pdf, FREngine12UserGuide.pdf

ABBYY FlexiCapture Engine and ABBYY FineReader Engine user's guides.

No.

FREngine12AdminGuide.pdf

ABBYY FineReader Engine system administrator's guide.

No.

Help\HTML

ABBYY FineReader Engine Developer's Help.

No.

Bin, Bin64

ABBYYSQLite.dll, AbbyyZlib.dll, Awl.dll, AwlGdi.dll, AwlOle.dll, Barcode.dll, BlockCorrection.dll, BusinessCard.Analyser.dll, Controller.dll, ControllerInterop.dll, DaForms.dll, DAForms.HighLevel.dll, AutoClassifier.dll, FlexibleDescription.dll, DatabaseCache.dll, DocumentAnalysis.BarcodesFinder.dll, Barcodes.Classification.dll, DocumentAnalysis.Classification.dll, DocumentAnalysis.Objects.dll, DocumentAnalysis.ObjectsExtraction.dll, DocumentAnalysis.PageServices.dll, DocumentAnalysis.Segmentation.dll, DocumentProcessing.dll, DotNetScriptingSupport.dll, EndToEndRecognition.dll, Export.Common.dll, Export.PictureProcessor.dll, FineMachineLearning.dll, FineMachineLearningExt.dll, FineNet.dll, FineFormats.dll, FineObj.dll, FObjEventSrc.dll, FontSupport.dll, FormsExport.dll, Image.Analysis.dll, libiomp5md.dll, LangInfoUnicode.dll, LanguageDatabase.dll, Morphology.dll, NLCLexicalEngine.dll, OfficeConverter.dll, Recognizer.dll, RecPage.dll, Icr.RecPage.dll, RegExp.dll, Rules.dll, Splrt.dll, ServerLib.dll, StandaloneProperties.dll, Synthesis.dll, Text.dll, TextClassifier.dll, TextClassifier.Core.dll, TextClassifier.Manager.dll, TextClassifier.Text.dll, TextLayout.dll, Training.dll, TRS.dll

ABBYY FlexiCapture Engine system modules.

Mandatory.

FCEngine.dll, FCEngine.dlp, FCEngine.exe

ABBYY FlexiCapture Engine system module.

Mandatory.

Image.Codec.AbbyyLossless.dll, Image.Codec.Ccitt.dll, Image.Codec.Jbig2.dll, Image.Codec.Jpeg.dll, Image.Codec.Lzw.dll, Image.Codec.Packbits.dll, Image.Codec.Zip.dll, Image.Format.Bmp.dll, Image.Format.Gif.dll, Image.Format.Pcx.dll, Image.Format.Png.dll, Image.Format.Tiff.dll, Image.Format.Wdp.dll, Image.Format.Wic.dll, Image.Services.Core.dll, Image.Services.Advanced.dll, Image.Services.Transforms.dll, Image.Helper.CMS.dll

ABBYY FlexiCapture Engine system modules for processing image files.

Mandatory.

Image.Format.Jbig2.dll

ABBYY FlexiCapture Engine system module for processing JBIG2 image files and saving images in JBIG2 format.

This file is necessary if you intend your application to process image files in JBIG2 format, or export any documents with pictures using the JBIG2 image codec.

Image.Format.Jpeg.dll

ABBYY FlexiCapture Engine system module for processing JPEG image files and saving images in JPEG format.

This file is necessary if you intend your application to process image files in JPEG format, or export any documents with pictures using the JPEG image codec.

Image.Format.Jpeg2k.dll

ABBYY FlexiCapture Engine system module for processing JPEG 2000 image files.

This file is necessary if you intend your application to process image files in JPEG 2000 format, or export any documents with pictures using JPEG 2000 image codec.

Image.Format.DjVu.dll, Image.Helper.DjVuCaminova.dll

ABBYY FineReader Engine system modules for processing DjVu image files.

The files are necessary if you intend your application to process image files in DjVu format.

Image.Helper.Kakadu.dll

ABBYY FineReader Engine system module for processing JPEG 2000 image files.

The file is necessary if you intend your application to process image files in JPEG 2000 format.

FCEngine0.dll, FCEngine1.dll, FCEngine2.dll, FCEngine3.dll, FCEngine5.dll, FCEngine6.dll, FCEngine15.dll, FCEngine16.dll, FCEngine17.dll, FCEngine27.dll

Controller0.dll, Controller1.dll, Controller2.dll, Controller3.dll, Controller5.dll, Controller6.dll, Controller15.dll, Controller16.dll, Controller17.dll, Controller27.dll

DatabaseCache0.dll, DatabaseCache1.dll, DatabaseCache2.dll, DatabaseCache3.dll, DatabaseCache5.dll, DatabaseCache6.dll, DatabaseCache15.dll, DatabaseCache16.dll, DatabaseCache17.dll, DatabaseCache27.dll

Export0.dll, Export1.dll, Export2.dll, Export3.dll, Export5.dll, Export6.dll, Export15.dll, Export16.dll, Export17.dll, Export27.dll

Rules0.dll, Rules1.dll, Rules2.dll, Rules3.dll, Rules5.dll, Rules6.dll, Rules15.dll, Rules16.dll, Rules17.dll, Rules27.dll

MorphoRes0.dll, MorphoRes1.dll, MorphoRes2.dll, MorphoRes3.dll, MorphoRes5.dll, MorphoRes6.dll, MorphoRes15.dll, MorphoRes16.dll, MorphoRes17.dll, MorphoRes27.dll

TechResources0.dll, TechResources1.dll, TechResources2.dll, TechResources3.dll, TechResources5.dll, TechResources6.dll, TechResources15.dll, TechResources16.dll, TechResources17.dll, TechResources27.dll

TrainingUI0.dll, TrainingUI1.dll, TrainingUI2.dll, TrainingUI3.dll, TrainingUI5.dll, TrainingUI6.dll, TrainingUI15.dll, TrainingUI16.dll, TrainingUI17.dll, TrainingUI27.dll

ABBYY FlexiCapture Engine resource modules. Each module name has number as a postfix. The meaning of these numbers is:

0 — for English interface language

1 — for Russian interface language

2 — for German interface language

3 — for French interface language

5 — for Spanish interface language

6 — for Italian interface language

15 — for Polish interface language

16 — for Czech interface language

17 — for Hungarian interface language

27 — for Portuguese (Brazil) interface language

Resource files are only necessary if you intend your application to display messages in a certain language. You may redistribute only resource modules corresponding to the interface language you want to use.

​FineUI.dll, FineUIRes.dll

ABBYY FineReader Engine system modules for dictionary editing and scanning with GUI.

The file is only necessary if you intend your application to use ABBYY FineReader Engine dictionary editing or scanning with GUI.

LicensingSchema.xe, ProductLicensingSchema.xe

ABBYY FlexiCapture Engine licensing and protection modules.

Mandatory.

Protection.dll

ABBYY FlexiCapture Engine licensing and protection module. It is used for Runtime licenses only.

Mandatory.

Protection.Developer.dll

ABBYY FlexiCapture Engine licensing and protection module. It is used for developer purpose only.

No.

LicensingSettings.xml

This file includes the ABBYY FlexiCapture Engine activation and protection settings.

note Note: The file is generated automatically during Developer or Runtime installation in automatic mode.

Distribution of this file is mandatory, if your application works with a network license, or with a standalone license with hardware protection.

note Note: See detailed description of LicensingSettings.xml file in Working with the LicensingSettings.xml file section.

ProtectionResShared.dll

ABBYY FlexiCapture Engine licensing and protection resource module for all interface languages.

Mandatory.

ProtectionRes0.dll, ProtectionRes1.dll, ProtectionRes2.dll, ProtectionRes3.dll, ProtectionRes5.dll, ProtectionRes6.dll, ProtectionRes15.dll, ProtectionRes16.dll, ProtectionRes17.dll, ProtectionRes27.dll

ABBYY FlexiCapture Engine licensing and protection resource modules. Each module name has number as a postfix. The meaning of these numbers is the same as that for the FCEngine*.dll.

note Note: All these files contain resources in English language.

Resource files are only necessary if you intend your application to display messages in a certain language. You may redistribute only resource modules corresponding to the interface languages you want to use.

ScanManager.dll, ScanTwain.exe, ScanWia.exe, twain.dat, wia.dat, FREngine.GUI.dll

These files are necessary for scanning.

Redistribute only if you intend to use scanning.

Scan0.dll, Scan1.dll, Scan2.dll, Scan3.dll, Scan5.dll, Scan6.dll, Scan15.dll, Scan16.dll, Scan17.dll, Scan27.dll

ServerScan0.dll, ServerScan1.dll, ServerScan2.dll, ServerScan3.dll, ServerScan5.dll, ServerScan6.dll, ServerScan15.dll, ServerScan16.dll, ServerScan17.dll, ServerScan27.dll

Scanning resource modules. The codes of the interface languages are the same as those for the FCEngine*.dll.

Redistribute only if you intend to use scanning and only for the interface languages you want to use.

FineUI0.dll, FineUI1.dll, FineUI2.dll, FineUI3.dll, FineUI5.dll, FineUI6.dll, FineUI15.dll, FineUI16.dll, FineUI17.dll, FineUI27.dll

ABBYY FlexiCapture Engine resource modules for scanning. Each module name has number as a postfix. The meaning of these numbers is the same as that for the FCEngine*.dll.

Redistribute only if you intend to use scanning and only for the interface languages you want to use.

LicenseManager.exe, LicenseManager12.chm, ProtectionUI.dll

The License Manager utility.

Used for activation of Runtime licenses. If you do not need the end user of your application to activate any licenses, you may use the utility during installation of your software and remove it afterwards.

FREngine.dll, FREngine.dlp, FREngine.exe, FREngineProcessor.exe, FREngineProcessor.dlp

ABBYY FineReader Engine system modules.

Redistribute only if you intend to use FineReader Engine functionality.

TextRendering.dll

ABBYY FlexiCapture Engine system module responsible for text rendering.

This file is necessary for export to PDF format.

SharedFiles.ini

The file contains paths to resource files.

This file is necessary if the distribution kit of your application will have the same folder structure.

warning Important! If you remove this file, you should do the following to ensure that FlexiCapture Engine can find the resource files:

·Copy the Data\Resource folder with all subfolders into Bin folder.

·Copy contents of the Data\ExtendedDictionaries folder directly into Bin folder.

·Copy other files contained in the Data folder into Bin folder.

FREngine0.dll, FREngine1.dll, FREngine2.dll, FREngine3.dll, FREngine5.dll, FREngine6.dll, FREngine15.dll, FREngine16.dll, FREngine17.dll, FREngine27.dll,

FREngineProcessor0.dll, FREngineProcessor1.dll, FREngineProcessor2.dll, FREngineProcessor3.dll, FREngineProcesor5.dll, FREngineProcessor6.dll, FREngineProcessor15.dll, FREngineProcessor16.dll, FREngineProcessor17.dll, FREngineProcessor27.dll

ABBYY FineReader Engine resource modules. Each module name has number as a postfix. The meaning of these numbers is the same as that for the FCEngine*.dll.

Resource files are only necessary if you intend your application to display messages in a certain language and if you are going to use FineReader Engine functionality. You may redistribute only resource modules corresponding to the interface language you want to use.

DL150ACE.dll, DL150AdobeXMP.dll, DL150AGM.dll, DL150ARE.dll, DL150AXE8SharedExpat.dll, DL150BIB.dll, DL150BIBUtils.dll, DL150CoolType.dll, DL150JP2KLib.dll, DL150PDFL.dll, DL150pdfport.dll, DL150pdfsettings.dll, icucnv40.dll, icudt40.dll, Image.Format.Pdf.dll, PdfTools.APDFLWrapper.dll, PdfTools.APDFLToolkit.dll, PdfTools.APDFLAuxInfo.dll, PdfTools.PdfToolsAuxInfo.dll

ABBYY FineReader Engine and ABBYY FlexiCapture Engine system modules for processing files in PDF format.

These files are only necessary if you intend your application to process PDF files.

note Note: See detailed list of files required for PDF processing in the ABBYY FlexiCapture Engine Distribution Kit: PDF article.

PdfTools.AdobeSupport.dll, Export.Pdf.dll, PdfTools.Encryption.dll, PdfTools.Crypto.dll, PdfTools.Heuristics.dll, PdfToolkit.dll, PdfService.dll, PdfTools.CommonInstruments.dll, OpenTypeSubsetter.dll

ABBYY FineReader Engine and ABBYY FlexiCapture Engine system modules for PDF export.

The files are necessary if you intend your application to export to PDF format.

Export.ALTO.dll, Export.Djvu.dll, Export.Exact.dll, Export.Excel.dll, Export.FineXML.dll, Export.HtmlEbooks.dll, Export.Pptx.dll, Export.Txt.dll, Export.WP.dll, Export.Xps.dll

ABBYY FlexiCapture Engine files for export to various formats.

Redistribute the files if your application uses the export functionality.

Bin\BCPatterns

ABBYY FlexiCapture Engine system modules for working with bytecode patterns. FlexiCapture Engine with bytecode patterns takes less of RAM, but may work slower.

You can redistribute these files instead of corresponding files in the Bin folder.

Bin\FontCache

Contains files with font metrics.

We recommend that you redistribute these files, but they may be excluded to save space. If the files are excluded, they will be generated during the first recognition process. First recognition, however, will slow down.

Bin\Support

AInfo.exe, AInfo.ini

The utility, which allows you to save all necessary diagnostic information about ABBYY FlexiCapture Engine to a ZIP file. Please provide a ZIP file which is created by the utility when contacting the technical support service.

The utility is only necessary for saving diagnostic information.

AInfo0.dll, AInfo1.dll, AInfo2.dll, AInfo3.dll, AInfo5.dll, AInfo6.dll, AInfo15.dll, AInfo16.dll, AInfo17.dll, AInfo27.dll

The resource modules for AInfo utility. Each resource module name has number as a postfix. The meaning of these numbers is the same as that for the FCEngine*.dll.

Redistribute only if you intend to use AInfo utility and only for the interface languages you want to use.

Data\Resource

ABBYY FlexiCapture Engine system modules for processing files in PDF format.

Resource files are only necessary if you intend your application to process PDF files.

See detailed list of files at ABBYY FlexiCapture Engine Distribution Kit: PDF article.

Data\BCPatterns

Bytecode patterns for FineReader Engine. FineReader Engine with bytecode patterns takes less of RAM, but may work slower.

You can redistribute these patterns instead of corresponding patterns in the Data folder. These files can be useful, if you intend to use FineReader Engine functionality.

Data\

AllData.dmi, Bold.pat, Bold.ptc, Bold.rseg, Bold.str, Italic.pat, Italic.ptc, Italic.pts, Italic.rseg, Italic.str, LineQualities.clc, MultyColumn.clc, Normal.cnn, Normal.hl, Normal.kcnn, Normal.rseg, Normal.pat, Normal.pdi, Normal.ptc, Normal.pts, Normal.spt, Normal.str, Normal.rseg, Part.pat, Part.ptc, Part.pts, Underlin.pat, Underlin.ptc, Underlin.rseg, Underlin.str, Pictures.clc, TextGraphicsTypeDetection.clc, GTD.cjk, GTD.slp, Generated.gtt, translations.gtt, substitutions.gst, Handwrite.clc, TextBlockBuilder.clc, TextColumnAnalysis.clc, EmptyPage.clc, CompanySet.icc, Shadow.clc, Tables.clc, fastconvnet.cnnmodel, resnet18scans.cnnmodel, SimilarLetters.dfe, DANet.clc, EuropeanClassifier.clc, Monospace.clc, Ranking.clc

Recognition databases.

Redistribute these files if your application uses recognition processing stage.

BcrSimilarLetters.dfe
BusinessCardFieldsQualityModels1.bfqm
BusinessCardFieldsQualityModels1p.bfqm
BusinessCardFieldsQualityModels2.bfqm
BusinessCardFieldsQualityModels2p.bfqm
BusinessCardFieldsQualityModels3.bfqm
BusinessCardFieldsQualityModels3p.bfqm
BusinessCardFieldsQualityModels4.bfqm
BusinessCardFieldsQualityModels4p.bfqm
BusinessCardFieldsQualityModels5.bfqm
BusinessCardFieldsQualityModels5p.bfqm
BusinessCardFieldsQualityModels6.bfqm
BusinessCardFieldsQualityModels6p.bfqm
BusinessCardFieldsQualityModels7.bfqm
BusinessCardFieldsQualityModels7p.bfqm
BusinessCardFieldsQualityModels8.bfqm
BusinessCardFieldsQualityModels8p.bfqm
BusinessCardFieldsQualityModels9.bfqm
BusinessCardFieldsQualityModels9p.bfqm
BusinessCardFieldsSubsetsQualityCorrectorModels.bfsqcm
BusinessCardKeywords.makw

ABBYY FineReader Engine recognition databases for business card recognition.

These files are only necessary if you intend your application to recognize business cards.

Helvetica.0.2.fch, Helvetica-Bold.0.2.fch, Helvetica-BoldOblique.0.2.fch, Helvetica-Oblique.0.2.fch, Symbol.0.2.fch, Times-Bold.0.2.fch, Times-BoldItalic.0.2.fch, Times-Italic.0.2.fch, Times-Roman.0.2.fch, Courier.0.2.fch, Courier-Bold.0.2.fch, Courier-BoldOblique.0.2.fch, Courier-Oblique.0.2.fch, StdAdbFnt.mtr, ZapfDingbats.0.2.fch, AbbyyStdFnt.fonts

Font metrics.

Redistribute these files if your application uses recognition processing stage.

Printer.pat, Printer.ptc, Printer.pts, Printer.rseg, Printer.spt, Printer.str

Recognition databases.

The files are only necessary if you intend your application to recognize text printed on a dot-matrix printer.

warning Important! This includes two cases:

·IRecognizerParams::TextTypes of ABBYY FineReader Engine contains the TT_Matrix constant, or

·IObjectsExtractionParams::DetectMatrixPrinter of ABBYY FineReader Engine is set to TRUE. Please note that this property is TRUE by default, but if you wish, you may set it to FALSE and omit this file from the distribution.

Typewrit.pat, Typewrit.ptc, Typewrit.pts, Typewrit.rseg, Typewrit.str

Recognition databases.

The files are only necessary if you intend your application to recognize text printed on a typewriter.

E13B.pat, E13B.ptc, E13B.pts, E13B.rseg, E13B.spt, E13B.str

Recognition databases.

For recognition of MICR (Magnetic Ink Character Recognition) characters only.

CMC7.pat, CMC7.ptc, CMC7.pts, CMC7.rseg, CMC7.spt, CMC7.str

Recognition databases.

For recognition of MICR CMC-7 characters only.

OCR_A.pat, OCR_A.ptc, OCR_A.pts, OCR_A.rseg, OCR_A.spt, OCR_A.str

Recognition databases.

For recognition of OCR-A font only.

OCR_B.pat, OCR_B.ptc, OCR_B.pts, OCR_B.rseg, OCR_B.spt, OCR_B.str

Recognition databases.

For recognition of OCR-B font only.

Handprin.ptc, Handprin.pte, Handprin.pto, Handprin.pts, Handprin.ptv, Handprin.rseg, Handprin.spt, Handprin.str, Erasure.spt, Erasure.str

Recognition databases for handprinted text.

Redistribute these files if you only intend to support handprint recognition in your application.

Fax.pat, Fax.ptc, Fax.pts, Fax.rseg, Fax.str

Recognition databases.

For recognition of faxes. Currently this functionality is not supported.

Index.pat, Index.ptc, Index.pts, Index.rseg, Index.spt, Index.str

Recognition databases.

Resource files are only necessary if you intend your application to recognize Index text type.

Gothic.pat, Gothic.pdi, Gothic.ptc, Gothic.pts, Gothic.rseg, Gothic.spt, Gothic.str

Recognition databases.

For recognition of Gothic fonts only.

Receipt.pat, Receipt.ptc, Receipt.pts, Receipt.rseg, Receipt.spt, Receipt.str

Recognition databases.

The files are only necessary if you intend your application to recognize Receipt text type.

Checkmark.ptc, Checkmark.pts, Checkmark.ptv, Checkmark.spt, Checkmark.str

Recognition databases.

For checkmark recognition only.

Arabic.oce, Arabic.ssc, Arabic.slp, Arabic.wrd, Arabic.clc, Arabic.hl

Recognition databases.

The files are only necessary if you want your application to recognize texts in Arabic.

Burmese.clc

Recognition database.

This file is only necessary if your application recognizes texts in Burmese.

Normal.mpp

Recognition databases.

The files are only necessary if you intend your application to recognize text printed on a dot-matrix printer, in Chinese, Japanese, and Korean.

Normal.ccjk, Normal.cjk, Normal.ecjk, Normal.fcjk, Normal.ssc, Normal.slp, NrmlPart.ssc, NrmlPart.slp, Normal.pp, CjkWordFragments.clc, Chnslm.kcnn, Gray.tscnn, Japanese.cjkdmcnn, Japanese.cnn, Japanese.hl, Japanese.tscnn

Recognition databases.

The files are only necessary if you want your application to recognize texts in Chinese, Japanese, and Korean.

FastNrml.ccjk, FastNrml.cjk, FastNrml.ecjk, FastNrml.slp, FastNrml.ssc, FastPart.slp, FastPart.ssc, FastNrml.pp

Recognition databases.

The files are only necessary if you want your application to recognize texts in Chinese, Japanese, and Korean in fast mode.

KrnPart.slp, KrnPart.ssc, Korean.ccjk, Korean.cjk, Korean.ecjk, Korean.fcjk, Korean.slp, Korean.ssc, Korean.pp, Korean.hl, Korean.dmd

Recognition databases.

The files are only necessary if you want your application to recognize texts in Korean.

FastKorn.ccjk, FastKorn.cjk, FastKorn.ecjk, FastKorn.slp, FastKorn.ssc, FastKorn.pp

Recognition databases.

The files are only necessary if you want your application to recognize texts in Chinese, Japanese, and Korean in fast mode.

OD.cjk, OD.slp

Recognition databases.

These files are only necessary if you want your application to recognize texts in Chinese, Japanese and Korean.

DefaultFont.2.fontdata, DefaultMetricsBoldFont.2.fontdata, DefaultMetricsFont.2.fontdata, DefaultMetricsItalicBoldFont.2.fontdata, DefaultMetricsItalicFont.2.fontdata, DefaultFont.fnt

Font metrics for page/document synthesis and for export to PDF.

The files are necessary if you intend your application to perform synthesis or export to PDF format.

Compound.clc Compound_X.clc, Synthesis.FSEmergency.pat, Synthesis.FSMerge.pat, Synthesis.FSSpacing.pat, Synthesis.OverflowedParagraphs.pat, Synthesis.RunningTitles.pat, Synthesis.SimpleList.pat, Synthesis.ParagraphAlignment.pat, Synthesis.ParagraphIndents.pat, Synthesis.Paragraphs.pat, Synthesis.ParagraphClusters.pat

Recognition databases.

These files are only necessary if you intend your application to perform synthesis.

CropClassifier.imodel, CropClassifierGeneric.imodel​

Recognition databases.

These files are only necessary if you intend your application to perform preprocessing.

DefaultProfiles.peps

ABBYY FlexiCapture Engine and FineReader Engine system module for PDF export.

The file is necessary if you intend your application to export to PDF format.

Asian.imagedoc, European.imagedoc

The files are used by the IEngine::LoadModule method.

Redistribute only if your application uses the IEngine::LoadModule method.

Data\ExtendedDictionaries

Abkhaz.amd

Abkhaz language support.

For recognition of Abkhaz language only.

Adyghe.amd

Adyghe language support.

For recognition of Adyghe language only.

Afrikns.amd

Afrikaans language support.

For recognition of Afrikaans language only.

Agul.amd

Agul language support.

For recognition of Agul language only.

Albanian.amd

Albanian language support.

For recognition of Albanian language only.

Altaic.amd

Altaic language support.

For recognition of Altaic language only.

Arabic.amd, Arabic.amm, Arabic.amt

Arabic language support.

For recognition of Arabic language only.

ArmEast.amd, ArmEast.amm, ArmEast.amt

Armenian (Eastern) language support.

For recognition of Armenian (Eastern) language only.

ArmGrab.amd, ArmGrab.amm, ArmGrab.amt

Armenian (Grabar) language support.

For recognition of Armenian (Grabar) language only.

ArmWest.amd, ArmWest.amm, ArmWest.amt

Armenian (Western) language support.

For recognition of Armenian (Western) language only.

Awar.amd

Awar language support.

For recognition of Awar language only.

Aymara.amd

Aymara language support.

For recognition of Aymara language only.

AzeriCyr.amd

Azerbaijani (Cyrillic) language support.

For recognition of Azerbaijani (Cyrillic) language only.

AzeriLatin.amd, AzeriLatin.amm, AzeriLatin.amt

Azererbaijani (Latin) language support.

For recognition of Azererbaijani (Latin) language only.

Bashkir.amd, Bashkir.amm, Bashkir.amt

Bashkir language support.

For recognition of Bashkir language only.

Basic.amd

Basic programming language support.

For recognition of Basic programming language only.

Basque.amd

Basque language support.

For recognition of Basque language only.

Bemba.amd

Bemba language support.

For recognition of Bemba language only.

Blackft.amd

Blackfoot language support.

For recognition of Blackfoot language only.

Breton.amd

Breton language support.

For recognition of Breton language only.

Bugotu.amd

Bugotu language support.

For recognition of Bugitu language only.

Bulgar.amd, Bulgar.amm, Bulgar.amt

Bulgarian language support.

For recognition of Bulgarian language only.

Burmese.amd

Burmese language support.

For recognition of Burmese language only.

Buryat.amd

Buryat language support.

For recognition of Buryat language only.

Byelorus.amd

Belarussian language support.

For recognition of Belarussian language only.

C.amd

C/C++ programming language support.

For recognition of C/C++ programming language only.

Catalan.amd, Catalan.amm, Catalan.amt

Catalan language support.

For recognition of Catalan language only.

Chamorro.amd

Chamorro language support.

For recognition of Chamorro language only.

Chechen.amd

Chechen language support.

For recognition of Chechen language only.

Chemistry.amd

"Simple chemical formulas" language support.

For recognition of simple chemical formulas only.

ChinesePRC.afd

Chinese (PRC) language support for document classification.

For classification of documents in Chinese (PRC) language only.

ChinesePRC.amd

Chinese (PRC) language support.

For recognition of Chinese (PRC) language only.

ChineseTaiwan.afd

Chinese (Taiwan) language support for document classification.

For classification of documents in Chinese (Taiwan) language only.

ChineseTaiwan.amd

Chinese (Taiwan) language support.

For recognition of Chinese (Taiwan) language only.

Chukcha.amd

Chukchee language support.

For recognition of Chukchee language only.

Chuvash.amd

Chuvash language support.

For recognition of Chuvash language only.

CMC7.amd

MICR CMC-7 language support.

For recognition of MICR CMC-7 language only.

Cobol.amd

Cobol programming language support.

For recognition of Cobol programming language only.

Corsican.amd

Corsican language support.

For recognition of Corsican language only.

CrimTat.amd

Crimean Tatar language support.

For recognition of Crimean Tatar language only.

Croatian.amd, Croatian.amm, Croatian.amt

Croatian language support.

For recognition of Croatian language only.

Crow.amd

Crow language support.

For recognition of Crow language only.

Czech.afd

Czech language support for document classification.

For classification of documents in Czech language only.

Czech.amd, Czech.amm, Czech.amt

Czech language support.

For recognition of Czech language only.

Danish.amd, Danish.amm, Danish.amt

Danish language support.

For recognition of Danish language only.

Dargwa.amd

Dargwa language support.

For recognition of Dargwa language only.

Dungan.amd

Dungan language support.

For recognition of Dungan language only.

Dutch.afd

Dutch language support for document classification.

For classification of documents in Dutch language only.

Dutch.amd, Dutch.amm, Dutch.amt

Dutch language support.

For recognition of Dutch language only.

E13B.amd

Support of the language for MICR text type.

For recognition of language for MICR text type.

English.afd

English language support for document classification.

For classification of documents in English language only.

English.amd, English.amm, English.amt

English language support.

For recognition of English language only.

EskimoC.amd

Eskimo (Cyrillic) language support.

For recognition of Eskimo (Cyrillic) language only.

EskimoL.amd

Eskimo (Latin) language support.

For recognition of Eskimo (Latin) language only.

Esperan.amd

Esperanto language support.

For recognition of Esperanto language only.

Eston.amd, Eston.amm, Eston.amt

Estonian language support.

For recognition of Estonian language only.

Even.amd

Even language support.

For recognition of Even language only.

Evenki.amd

Evenki language support.

For recognition of Evenki language only.

Faeroese.amd

Faroese language support.

For recognition of Faroese language only.

Farsi.amd, Farsi.amm

Farsi language support.

For recognition of Farsi language only.

Fijian.amd

Fijian language support.

For recognition of Fijian language only.

Finnish.amd, Finnish.amm, Finnish.amt

Finnish language support.

For recognition of Finnish language only.

Flemmish.amd

Dutch (Belgium) language support.

For recognition of Dutch (Belgium)language only.

Fortran.amd

Fortran language support.

For recognition of Fortran language only.

French.afd

French language support for document classification.

For classification of documents in French language only.

French.amd, French.amm, French.amt

French language support.

For recognition of French language only.

Frisian.amd

Frisian language support.

For recognition of Frisian language only.

Friulian.amd

Friulian language support.

For recognition of Friulian language only.

GaelicSc.amd

Scottish Gaelic language support.

For recognition of Scottish Gaelic language only.

Gagauz.amd

Gagauz language support.

For recognition of Gagauz language only.

Galician.amd

Galician language support.

For recognition of Galician language only.

Ganda.amd

Ganda language support.

For recognition of Ganda language only.

Georgian.amd

Georgian language support.

For recognition of Georgian language only.

German.afd

German language support for document classification.

For classification of documents in German language only.

German.amd, German.amm, German.amt

German language support.

For recognition of German language only.

GermanLx.amd

German (Luxembourg) language support.

For recognition of German (Luxembourg) language only.

GermanNS.amd

German (new spelling) language support.

For recognition of German (new spelling) language only.

Greek.amd, Greek.amm, Greek.amt

Greek language support.

For recognition of Greek language only.

Guarani.amd

Guarani language support.

For recognition of Guarani language only.

Hani.amd

Hani language support.

For recognition of Hani language only.

Hausa.amd

Hausa language support.

For recognition of Hausa language only.

Hawaiian.amd

Hawaiian language support.

For recognition of Hawaiian language only.

Hebrew.amd, Hebrew.amm, Hebrew.amt

Hebrew language support.

For recognition of Hebrew language only.

Hungar.amd, Hungar.amm, Hungar.amt

Hungarian language support.

For recognition of Hungarian language only.

Iceland.amd

Icelandic language support.

For recognition of Icelandic language only.

Ido.amd

Ido language support.

For recognition of Ido language only.

Indonesian.amd, Indonesian.amm, Indonesian.amt

Indonesian language support.

For recognition of Indonesian language only.

Ingush.amd

Ingush language support.

For recognition of Ingush language only.

Interlin.amd

Interlingua language support.

For recognition of Interlingua language only.

Irish.amd

Irish language support.

For recognition of Irish language only.

Italian.afd

Italian language support for document classification.

For classification of documents in Italian language only.

Italian.amd, Italian.amm, Italian.amt

Italian language support.

For recognition of Italian language only.

Japanese.afd

Japanese language support for document classification.

For classification of documents in Japanese language only.

Japanese.amd, Japanese.amm

Japanese language support.

For recognition of Japanese language only.

JapaneseModern.amd

Japanese (Modern) language support.

For recognition of Japanese (Modern) language only.

Java.amd

Java programming language support.

For recognition of Java programming language only.

Kabard.amd

Kabardian language support.

For recognition of Kabardian language only.

Kalmyk.amd

Kalmyk language support.

For recognition of Kalmyk language only.

Karachay.amd

Karachay-balkar language support.

For recognition of Karachay-balkar language only.

Karakalp.amd

Karakalpak language support.

For recognition of Karakalpak language only.

Kasub.amd

Kasub language support.

For recognition of Kasub language only.

Kawa.amd

Kawa language support.

For recognition of Kawa language only.

Kazakh.amd

Kazakh language support.

For recognition of Kazakhage language only.

Khakas.amd

Khakass language support.

For recognition of Khakass language only.

Khanty.amd

Khanty language support.

For recognition of Khanty language only.

Kikuyu.amd

Kikuyu language support.

For recognition of Kikuyu language only.

Kirgiz.amd

Kirgiz language support.

For recognition of Kirgiz language only.

Kongo.amd

Kongo language support.

For recognition of Kongo language only.

Korean.afd

Korean language support for document classification.

For classification of documents in Korean language only.

Korean.amd, Korean.amm

Korean and Korean (Hangul) language support.

For recognition of Korean and Korean (Hangul) languages only.

Koryak.amd

Koryak language support.

For recognition of Koryak language only.

Kpelle.amd

Kpelle language support.

For recognition of Kpelle language only.

Kumyk.amd

Kumyk language support.

For recognition of Kumyk language only.

KurdishL.amd

Kurdish language support.

For recognition of Kurdish language only.

Lak.amd

Lak language support.

For recognition of Lak language only.

Lappish.amd

Sami (Lappish) language support.

For recognition of Sami (Lappish) language only.

Latin.amd, Latin.amm, Latin.amt

Latin language support.

For recognition of Latin language only.

Latvian.amd, Latvian.amm, Latvian.amt

Latvian language support.

For recognition of Latvian language only.

LatvianGothic.amd

Support of Latvian language written in Gothic script.

For recognition of Latvian language written in Gothic script only.

Lezgin.amd

Lezgi language support.

For recognition of Lezgi language only.

Lithuan.amd, Lithuan.amm, Lithuan.amt

Lithuanian language support.

For recognition of Lithuanian language only.

Luba.amd

Luba language support.

For recognition of Luba language only.

Macedon.amd

Macedonian language support.

For recognition of Macedonian language only.

Malagasy.amd

Malagasy language support.

For recognition of Malagasy language only.

Malay.amd

Malay (Malaysian) language support.

For recognition of Malay language only.

Malinke.amd

Malinke language support.

For recognition of Malinke language only.

Maltese.amd

Maltese language support.

For recognition of Maltese language only.

Mansi.amd

Mansi language support.

For recognition of Mansi language only.

Maori.amd

Maori language support.

For recognition of Maori language only.

Mari.amd

Mari language support.

For recognition of Mari language only.

Maya.amd

Maya language support.

For recognition of Maya language only.

Miao.amd

Miao language support.

For recognition of Miao language only.

Minankab.amd

Minangkabau language support.

For recognition of Minangkabau language only.

Mohawk.amd

Mohawk language support.

For recognition of Mohawk language only.

Moldav.amd

Romanian (Moldavia) language support.

For recognition of Romanian (Moldavia) language only.

Mongol.amd

Mongol language support.

For recognition of Mongol language only.

Mordvin.amd

Mordvin language support.

For recognition of Mordvin language only.

Nahuatl.amd

Nahuatl language support.

For recognition of Nahuatl language only.

Nenets.amd

Nenets language support.

For recognition of Nenets language only.

Nivkh.amd

Nivkh language support.

For recognition of Nivkh language only.

Nogay.amd

Nogay language support.

For recognition of Nogay language only.

NorwBok.amd, NorwBok.amm, NorwBok.amt

Norwegian (Bokmal) language support.

For recognition of Norwegian (Bokmal) language only.

NorwNyn.amd, NorwNyn.amm, NorwNyn.amt

Norwegian (Nynorsk) language support.

For recognition of Norwegian (Nynorsk) language only.

Numbers.amd

Digits language support.

For recognition of digits.

Nyanja.amd

Nyanja language support.

For recognition of Nyanja language only.

Occident.amd

Occidental language support.

For recognition of Occidental language only.

OcrA.amd

Support of the language for OCR-A text type.

For recognition of the language for OCR-A text type.

OcrB.amd

Support of the language for OCR-B text type.

For recognition of the language for OCR-B text type.

Ojibway.amd

Ojibway language support.

For recognition of Ojibway language only.

OldEnglish.amd, OldEnglish.amm, OldEnglish.amt

Old English language support.

For recognition of Old English language only.

OldFrench.amd, OldFrench.amm, OldFrench.amt

Old French language support.

For recognition of Old French language only.

OldGerman.amd, OldGerman.amm, OldGerman.amt

Old German language support.

For recognition of Old German language only.

OldItalian.amd, OldItalian.amm, OldItalian.amt

Old Italian language support.

For recognition of Old Italian language only.

OldSlavonic.amd

Old Slavonic language support.

For recognition of Old Slavonic language only.

OldSpanish.amd, OldSpanish.amm, OldSpanish.amt

Old Spanish language support.

For recognition of Old Spanish language only.

Ossetic.amd

Ossetian language support.

For recognition of Ossetian language only.

Papiamen.amd

Papiamento language support.

For recognition of Papiamento language only.

Pascal.amd

Pascal programming language support.

For recognition of Pascal programming language only.

Pidgin.amd

Tok Pisin language support.

For recognition of Tok Pisin language only.

Polish.afd

Polish language support for document classification.

For classification of documents in Polish language only.

Polish.amd, Polish.amm, Polish.amt

Polish language support.

For recognition of Polish language only.

Portug.afd

Portuguese language support for document classification.

For classification of documents in Portuguese language only.

Portug.amd, Portug.amm, Portug.amt

Portuguese language support.

For recognition of Portuguese language only.

PortugueseBrazilian.amd, PortugueseBrazilian.amm, PortugueseBrazilian.amt

Portuguese (Brazilian) language support.

For recognition of Portuguese (Brazilian) language only.

Provenc.amd

Provencal language support.

For recognition of Provencal language only.

Quechua.amd

Quechua language support.

For recognition of Quechua language only.

Rhaetian.amd

Rhaeto-Romanic language support.

For recognition of Rhaeto-Romanic language only.

Roman.afd

Romanian language support for document classification.

For classification of documents in Romanian language only.

Roman.amd, Roman.amm, Roman.amt

Romanian language support.

For recognition of Romanian language only.

Romany.amd

Romany language support.

For recognition of Romany language only.

Ruanda.amd

Rwanda language support.

For recognition of Rwanda language only.

Rundi.amd

Rundi language support.

For recognition of Rundi language only.

RusOS.amd, RusOS.amm, RusOS.amt

Russian (Old Spelling) language support.

For recognition of Russian (Old Spelling) language only.

Russian.afd

Russian language support for document classification.

For classification of documents in Russian language only.

Russian.amd, Russian.amm, Russian.amt

Russian language support.

For recognition of Russian language only.

RussianWithAccent.amd

Russian with accent language support.

For recognition of Russian language, with accents marking the stress position.

Samoan.amd

Samoan language support.

For recognition of Samoan language only.

Selkup.amd

Selkup language support.

For recognition of Selkup language only.

Serbian.amd

Serbian (Cyrillic) language support.

For recognition of Serbian (Cyrillic) language only.

SerbianL.amd

Serbian (Latin) language support.

For recognition of Serbian (Latin) language only.

Shona.amd

Shona language support.

For recognition of Shona language only.

Sioux.amd

Sioux language support.

For recognition of Sioux language only.

Slovak.amd, Slovak.amm, Slovak.amt

Slovak language support.

For recognition of Slovak language only.

Sloven.amd, Sloven.amm, Sloven.amt

Slovenian language support.

For recognition of Slovenian language only.

Somali.amd

Somali language support.

For recognition of Somali language only.

Sorbian.amd

Sorbian language support.

For recognition of Sorbian language only.

Sotho.amd

Sotho language support.

For recognition of Sotho language only.

Spanish.afd

Spanish language support for document classification.

For classification of documents in Spanish language only.

Spanish.amd, Spanish.amm, Spanish.amt

Spanish language support.

For recognition of Spanish language only.

Sunda.amd

Sunda language support.

For recognition of Sunda language only.

Swahili.amd

Swahili language support.

For recognition of Swahili language only.

Swazi.amd

Swazi language support.

For recognition of Swazi language only.

Swedish.afd

Swedish language support for document classification.

For classification of documents in Swedish language only.

Swedish.amd, Swedish.amm, Swedish.amt

Swedish language support.

For recognition of Swedish language only.

Tabassar.amd

Tabasaran language support.

For recognition of Tabasaran language only.

Tagalog.amd

Tagalog language support.

For recognition of Tagalog language only.

Tahitian.amd

Tahitian language support.

For recognition of Tahitian language only.

Tajik.amd

Tajik language support.

For recognition of Tajik language only.

Tatar.amd, Tatar.amm, Tatar.amt

Tatar language support.

For recognition of Tatar language only.

Thai.amd, Thai.amm, Thai.amt, Thai.clc

Thai language support.

For recognition of Thai language only.

Tinpo.amd

Jingpo language support.

For recognition of Jingpo language only.

Tongan.amd

Tongan language support.

For recognition of Tongan language only.

Tswana.amd

Tswana language support.

For recognition of Tswana language only.

Tun.amd

Tun language support.

For recognition of Tun language only.

Turkish.amd, Turkish.amm, Turkish.amt

Turkish language support.

For recognition of Turkish language only.

Turkmen.amd

Turkmen language support.

For recognition of Turkmen language only.

TurkmenLatin.amd

Turkmen (Latin) language support.

For recognition of Turkmen (Latin) language only.

Tuvin.amd

Tuvinian language support.

For recognition of Tuvinian language only.

Udmurt.amd

Udmurt language support.

For recognition of Udmurt language only.

UighurC.amd

Uighur (Cyrillic) language support.

For recognition of Uighur (Cyrillic) language only.

UighurL.amd

Uighur (Latin) language support.

For recognition of Uighur (Latin) language only.

Ukrainian.amd, Ukrainian.amm, Ukrainian.amt

Ukrainian language support.

For recognition of Ukrainian language only.

Univers.amd, Univers.amm

Additional for all languages that include Latin letters.

Redistribute these files if you use at least one recognition language with Latin letters.

UzbekCyr.amd

Uzbek (Cyrillic) language support.

For recognition of Uzbek (Cyrillic) language only.

UzbekLat.amd

Uzbek (Latin) language support.

For recognition of Uzbek (Latin) language only.

Vietnamese.amd, Vietnamese.amm

Vietnamese language support.

For recognition of Vietnamese language only.

Visayan.amd

Cebuano language support.

For recognition of Cebuano language only.

Welsh.amd

Welsh language support.

For recognition of Welsh language only.

Wolof.amd

Wolof language support.

For recognition of Wolof language only.

Xhosa.amd

Xhosa language support.

For recognition of Xhosa language only.

Yakut.amd

Yakut language support.

For recognition of Yakut language only.

Yiddish.amd

Yiddish language support.

For recognition of Yiddish language only.

Zapotec.amd

Zapotec language support.

For recognition of Zapotec language only.

Zulu.amd

Zulu language support.

For recognition of Zulu language only.

FormsDataTypes.amd

Additional file for special language units.

For recognition of all languages.

{V0-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}.amd

Additional files with key words for different languages.

See FCEngine12_Distribution.csv for details on which file is intended for which language.

Bulgarian_Address.amd,

Bulgarian_Address_City.amd,

Bulgarian_Address_Country.amd,

Bulgarian_Address_PhoneNumber.amd,

Bulgarian_Address_PhonePrefixes.amd,

Bulgarian_Address_Region.amd,

Bulgarian_Address_ZipCode.amd,

Bulgarian_Currency_ByDigits.amd,

Bulgarian_Currency_ByWords.amd,

Bulgarian_Currency_Names.amd,

Bulgarian_DateTime_MonthByWords.amd,

Bulgarian_HumanProperName.amd,

Bulgarian_HumanProperName_Initial.amd,

Bulgarian_HumanProperName_Name.amd,

Bulgarian_HumanProperName_Surname.amd,

Bulgarian_Number.amd,

Bulgarian_Number_ByWords.amd

Bulgarian language support for special language units (e.g. addresses, numbers, human names, etc.).

For recognition of Bulgarian language only.

Croatian_Address.amd,

Croatian_Address_City.amd,

Croatian_Address_Country.amd,

Croatian_Address_PhoneNumber.amd,

Croatian_Address_PhonePrefixes.amd,

Croatian_Address_Region.amd,

Croatian_Address_Street.amd,

Croatian_Address_ZipCode.amd,

Croatian_Currency_ByDigits.amd,

Croatian_Currency_Names.amd,

Croatian_DateTime_MonthByWords.amd,

Croatian_HumanProperName.amd,

Croatian_HumanProperName_Initial.amd,

Croatian_HumanProperName_Name.amd,

Croatian_HumanProperName_Surname.amd,

Croatian_Number_ByWords.amd

Croatian language support for special language units (e.g. addresses, names, etc.).

For recognition of Croatian language only.

Czech_Address.amd,

Czech_Address_City.amd,

Czech_Address_CityDistricts.amd,

Czech_Address_PhoneNumber.amd,

Czech_Address_PhonePrefixes.amd,

Czech_Address_Street.amd,

Czech_Address_ZipCode.amd,

Czech_Currency_ByDigits.amd,

Czech_Currency_Names.amd,

Czech_DateTime_MonthByWords.amd,

Czech_DateTime_WeekDayByWords.amd,

Czech_HumanProperName.amd,

Czech_HumanProperName_Initial.amd,

Czech_HumanProperName_Name.amd,

Czech_HumanProperName_Surname.amd

Czech language support for special language units (e.g. addresses, names, etc.).

For recognition of Czech language only.

English_Address.amd,

English_Address_Abbreviation.amd,

English_Address_CityOfWorld.amd,

English_Address_Country.amd,

English_Address_PhoneNumber.amd,

English_Address_PhonePrefixes.amd,

English_Address_ZipCode.amd,

English_Canada_Address_ZipCode.amd,

English_DateTime_MonthByWords.amd,

English_HumanProperName.amd,

English_HumanProperName_Initial.amd,

English_HumanProperName_Name.amd,

English_HumanProperName_Surname.amd,

English_Number.amd,

English_Number_ByWords.amd

English language support for special language units (e.g. addresses, names, etc.).

For recognition of English language only.

English_UK_Address_City.amd,

English_UK_Address_Region.amd,

English_UK_Address_Zipcode.amd,

English_UK_Currency_ByDigits.amd,

English_UK_Currency_Names.amd

English (United Kingdom) language support for special language units (e.g. addresses, names, etc.).

For recognition of English (United Kingdom) language only.

English_US_Address.amd,

English_US_Address_City.amd,

English_US_Address_PhoneNumber.amd

English_US_Address_State.amd,

English_US_Address_Street.amd,

English_US_Address_ZipCode.amd,

English_US_Currency_Abbreviation.amd,

English_US_Currency_ByDigits.amd,

English_US_Currency_ByWords.amd,

English_US_WellKnownCode_EIN.amd

English_US_WellKnownCode_SSN.amd

English (United States) language support for special language units (e.g. addresses, names, etc.).

For recognition of English (United States) language only.

Extra.amd

French_Address.amd,

French_Address_City.amd,

French_Address_PhoneNumber.amd,

French_Address_PhonePrefixes.amd,

French_Address_ZipCode.amd,

French_Currency_ByDigits.amd,

French_Currency_Names.amd,

French_DateTime_MonthByWords.amd,

French_HumanProperName.amd,

French_HumanProperName_Initial.amd,

French_HumanProperName_Name.amd,

French_HumanProperName_Surname.amd

French language support for special language units (e.g. addresses, names, etc.).

For recognition of French language only.

German_Abbreviation.amd,

German_Address.amd,

German_Address_City.amd,

German_Address_PhoneNumber.amd,

German_Address_PhonePrefixes.amd,

German_Address_Region.amd,

German_Address_Street.amd,

German_Address_ZipCode.amd,

German_Currency_ByDigits.amd,

German_Currency_Names.amd,

German_DateTime_MonthByWords.amd,

German_Firms.amd,

German_HumanProperName.amd,

German_HumanProperName_Initial.amd,

German_HumanProperName_Name.amd,

German_HumanProperName_Surname.amd

German language support for special language units (e.g. addresses, names, etc.).

For recognition of German language only.

Greek_Address.amd,

Greek_Address_City.amd,

Greek_Address_PhoneNumber.amd,

Greek_Address_PhonePrefixes.amd,

Greek_Address_Region.amd,

Greek_Address_Street.amd,

Greek_Address_ZipCode.amd,

Greek_Currency_ByDigits.amd,

Greek_Currency_Names.amd,

Greek_DateTime_MonthByWords.amd,

Greek_HumanProperName.amd,

Greek_HumanProperName_Name.amd,

Greek_HumanProperName_Surname.amd

Greek language support for special language units (e.g. addresses, names, etc.).

For recognition of Greek language only.

Hungarian_Address.amd,

Hungarian_Address_City.amd,

Hungarian_Address_Country.amd,

Hungarian_Address_PhoneNumber.amd,

Hungarian_Address_PhonePrefix.amd,

Hungarian_Address_Street.amd,

Hungarian_Address_ZipCode.amd,

Hungarian_Currency_ByDigits.amd,

Hungarian_Currency_Names.amd,

Hungarian_DateTime_MonthByWords.amd,

Hungarian_HumanProperName.amd,

Hungarian_HumanProperName_Initial.amd,

Hungarian_HumanProperName_Name.amd,

Hungarian_HumanProperName_Surname.amd,

Hungarian_Number_ByWords.amd

Hungarian language support for special language units (e.g. addresses, names, etc.).

For recognition of Hungarian language only.

Italian_Address.amd,

Italian_Address_City.amd,

Italian_Address_PhoneNumber.amd,

Italian_Address_PhonePrefix.amd,

Italian_Address_Street.amd,

Italian_Address_ZipCode.amd,

Italian_Currency_ByDigits.amd,

Italian_Currency_Names.amd,

Italian_DateTime_MonthByWords.amd,

Italian_HumanProperName.amd,

Italian_HumanProperName_Initial.amd,

Italian_HumanProperName_Name.amd,

Italian_HumanProperName_Surname.amd

Italian language support for special language units (e.g. addresses, names, etc.).

For recognition of Italian language only.

Neutral_Address_Email.amd,

Neutral_Address_TopLevelDomain.amd,

Neutral_ArabicIndianDigits.amd,

Neutral_Currency_Abbreviation.amd,

Neutral_Currency_International.amd,

Neutral_Currency_Prefixes.amd,

Neutral_Currency_Suffixes.amd,

Neutral_DateTime.amd,

Neutral_DateTime_DayByDigits.amd,

Neutral_DateTime_DD_MM_YY.amd,

Neutral_DateTime_DD_MM_YYYY.amd,

Neutral_DateTime_MM_DD_YY.amd,

Neutral_DateTime_MM_DD_YYYY.amd,

Neutral_DateTime_MonthByDigits.amd,

Neutral_DateTime_YearByDigits.amd,

Neutral_Number_Integer.amd,

Neutral_Number_Real.amd,

Neutral_Number_Roman.amd,

Neutral_Number_TwoDigits.amd,

Neutral_Number_UnsignedInteger.amd,

Neutral_Time_12hours.amd,

Neutral_Time_12_24hours.amd,

Neutral_Time_24hours.amd,

Neutral_WellKnownCode_ISBN.amd

Support for language units similar for majority of languages (e.g. addresses, names, etc.).

For recognition of all languages.

Polish_Abbreviation.amd,

Polish_Address.amd,

Polish_Address_City.amd,

Polish_Address_PhoneNumber.amd,

Polish_Address_PhonePrefix.amd,

Polish_Address_Streets.amd,

Polish_Address_ZipCode.amd,

Polish_Currency.amd,

Polish_Currency_Local.amd,

Polish_DateTime_MonthByWords.amd,

Polish_Firm.amd,

Polish_HumanProperName.amd,

Polish_HumanProperName_Initial.amd,

Polish_HumanProperName_Name.amd,

Polish_HumanProperName_Surname.amd

Polish language support for special language units (e.g. addresses, names, etc.).

For recognition of Polish language only.

Russian_Address.amd,

Russian_Address_City.amd,

Russian_Address_Country.amd,

Russian_Address_PhoneNumber.amd,

Russian_Address_Region.amd,

Russian_Address_Street.amd,

Russian_Address_ZipCode.amd,

Russian_Currency_ByDigits.amd,

Russian_Currency_Names.amd,

Russian_DateTime_Month.amd,

Russian_DateTime_MonthByRomanDigits.amd,

Russian_DateTime_MonthByWords.amd,

Russian_DateTime_YearByWords.amd,

Russian_HumanProperName.amd,

Russian_HumanProperName_Name.amd,

Russian_HumanProperName_Patronymic.amd,

Russian_HumanProperName_Surname.amd,

Russian_Number.amd,

Russian_WellKnownCode_BIC.amd,

Russian_WellKnownCode_INN.amd,

Russian_WellKnownCode_Passport.amd

Russian language support for special language units (e.g. addresses, names, etc.).

For recognition of Russian language only.

Serbian_Cyrillic_Address_District.amd

Serbian_Cyrillic_Address_Municipalities.amd

Serbian_Cyrillic_Address_Streets.amd

Serbian_Cyrillic_Address_Towns.amd

Serbian_Cyrillic_HumanProperName_Name.amd

Serbian_Cyrillic_HumanProperName_Surname.amd

Serbian_Cyrillic_Industry.amd

Serbian (Cyrillic) language support for special language units (names).

For recognition of Serbian (Cyrillic) language only.

Serbian_Latin_Address_District.amd

Serbian_Latin_Address_Municipalities.amd

Serbian_Latin_Address_Streets.amd

Serbian_Latin_Address_Towns.amd

Serbian_Latin_HumanProperName_Name.amd

Serbian_Latin_HumanProperName_Surname.amd

Serbian_Latin_Industry.amd

Serbian (Latin) language support for special language units (names).

For recognition of Serbian (Latin) language only.

Slovak_AcademicDegree.amd,

Slovak_Activity.amd,

Slovak_Address.amd,

Slovak_Address_City.amd,

Slovak_Address_Country.amd,

Slovak_Address_PhoneNumber.amd,

Slovak_Address_PhonePrefix.amd,

Slovak_Address_Region.amd,

Slovak_Address_Street.amd,

Slovak_Address_ZipCode.amd,

Slovak_Currency_ByDigits.amd,

Slovak_Currency_Names.amd,

Slovak_DateTime_MonthByWords.amd,

Slovak_DateTime_WeekDay.amd,

Slovak_Firm.amd,

Slovak_HumanProperName.amd,

Slovak_HumanProperName_Initial.amd,

Slovak_HumanProperName_Name.amd,

Slovak_HumanProperName_Surname.amd,

Slovak_TaxOffice.amd

Slovak language support for special language units (e.g. addresses, names, etc.).

For recognition of Slovak language only.

Spanish_HumanProperName_Name.amd

Spanish language support for special language units (names).

For recognition of Spanish language only.

Ukrainian_Address.amd,

Ukrainian_Address_Abbreviation.amd,

Ukrainian_Address_City.amd,

Ukrainian_Address_District.amd,

Ukrainian_Address_KievStreet.amd,

Ukrainian_Address_Region.amd,

Ukrainian_Address_ZIPcode.amd,

Ukrainian_Currency_ByDigits.amd,

Ukrainian_Currency_Names.amd,

Ukrainian_DateTime.amd,

Ukrainian_DateTime_MonthByWords.amd,

Ukrainian_HumanProperName.amd,

Ukrainian_HumanProperName_Initial.amd,

Ukrainian_HumanProperName_Name.amd,

Ukrainian_HumanProperName_Surname.amd

Ukrainian language support for special language units (e.g. addresses, names, etc.).

For recognition of Ukrainian language only.

Licenses\

License.JasPer.txt

JasPer Software License (JPEG2000).

Mandatory.

License.7-zip.txt

7zip license.

Mandatory.

png.h

libpng license file.

Mandatory.

BDF_Driver_License.txt, PCF_Driver_License.txt

License files for FreeType font library.

You must redistribute these files because of FreeType licensing requirements.

EULA FOR MICROSOFT SOFTWARE.txt

The end-user license agreement for Microsoft software.

No.

AngleSharp_license.txt

AngleSharp library license.

Mandatory.

Apache_OpenOffice_Notice.txt

Apache OpenOffice notice file.

Mandatory.

License.Apache.2.0.txt

Apache license file.

Mandatory.

License.Expat.txt

Expat license included in DjVu DSDK.

Mandatory.

License.Fast_detector.txt

FAST detector license.

Mandatory.

License.HAVAL.txt

Haval (Calyptix) license.

Mandatory.

License.Libmv.txt

Libmv license.

Mandatory.

License.Littlecms.txt

little cms (MIT) license.

Mandatory.

License.OpenCV.txt

OpenCV license.

Mandatory.

License.OpenSSL.txt

OpenSSL license.

Mandatory.

License.PCRE2.txt

PCRE license.

Mandatory.

License.RazorEngine.md

RazorEngine license.

Mandatory.

License.DjVu.txt

Expat license included in DjVu SDK.

You must redistribute this file because of DjVu library licensing requirements.

1 — The FCEngine12_Distribution.csv file can be used to generate the list of files required for your application to function. The FCEngine12_Distribution.csv file provides the following data for each file of the Bin, Bin64, Data, and Licenses folders:

·Path — file path in the root installation folder,

·FileName — file name,

·RequiredByModule — module that uses this file,

·RequiredByLanguage — language, for working with which this file is used,

·Responsibility — file’s area of responsibility providing additional information on file usage (for example, in the case of a file used for working with a language, it may be stated whether this file is used to display messages in this language or to recognize texts),

·Optional — whether the file is required for the current module or language.

To generate the list of files for your application, first of all decide which modules you need in order your application to work correctly (see RequiredByModule). Check, whether the file is mandatory for this module (see Optional). If the file is optional, check the RequiredByLanguage and Responsibility fields. These fields provide additional information, which allows you to decide whether to include the file in your distribution package or not. There are some files, which are optional but do not have the responsibility field, — these are files, which we recommend for redistribution, but they may be excluded to save space.

See also

List of the predefined languages in ABBYY FlexiCapture Engine

ABBYY FlexiCapture Engine Distribution Kit: PDF


ABBYY FlexiCapture Engine Distribution Kit: PDF

Distribution > Distribution Kit >

ABBYY FlexiCapture Engine Distribution Kit: PDF

Resource files listed below are only necessary if you intend your application to process PDF files.

Folder | File name | Distribution
Bin, Bin64 | DL150ACE.dll DL150AdobeXMP.dll DL150AGM.dll DL150ARE.dll DL150AXE8SharedExpat.dll DL150BIB.dll DL150BIBUtils.dll DL150CoolType.dll DL150JP2KLib.dll DL150PDFL.dll DL150pdfport.dll DL150pdfsettings.dll icucnv40.dll icudt40.dll PdfTools.APDFLToolkit.dll Image.Format.Pdf.dll PdfTools.APDFLAuxInfo.dll, PdfTools.PdfToolsAuxInfo.dll, PdfTools.APDFLWrapper.dll, OpenTypeSubsetter.dll, | Mandatory for PDF opening.
 | PdfTools.AdobeSupport.dll, Export.Pdf.dll, PdfTools.Encryption.dll, PdfToolkit.dll, PdfTools.CommonInstruments.dll, TextRendering.dll, PdfService.dll, PdfTools.Crypto.dll. PdfTools.Heuristics.dll, PdfTools.PdfToolsAuxInfo.dll | Mandatory for PDF export.
 | Image.Format.Jbig2.dll | This file is necessary for PDF export if you are saving pictures into the document using the JBIG2 image codec.
 | Image.Format.Jpeg.dll | This file is necessary for PDF export if you are saving pictures into the document using the JPEG image codec.
 | Image.Format.Jpeg2k.dll | This file is necessary for PDF export if you are saving pictures into the document using the JPEG 2000 image codec.
Data | DefaultProfiles.peps, DefaultFont.2.fontdata, DefaultMetricsBoldFont.2.fontdata, DefaultMetricsFont.2.fontdata, DefaultMetricsItalicBoldFont.2.fontdata, DefaultMetricsItalicFont.2.fontdata, DefaultFont.fnt | Mandatory for PDF export.
Data\Resources\Color\Profiles | All files in this folder. | Mandatory for PDF opening.
Data\Resources\CMap | Adobe-GB1-2 Adobe-GB1-4 Adobe-CNS1-0 Adobe-CNS1-3 Adobe-Japan1-2 Adobe-Japan1-4 Adobe-Korea1-1 UniGB-UCS2-H UniGB-UCS2-V UniCNS-UCS2-H UniCNS-UCS2-V UniJIS-UCS2-H UniJIS-UCS2-V UniKS-UCS2-H UniKS-UCS2-V Identity-H Identity-V | Mandatory for PDF export.
 | The files in the CMap folder which are not listed above | Mandatory for PDF opening and export.
Data\Resource\Font | AdobeArabic-Bold.otf AdobeArabic-BoldItalic.otf AdobeArabic-Italic.otf AdobeArabic-Regular.otf AdobeFanHeitiStd-Bold.otf AdobeGothicStd-Bold.otf AdobeHebrew-Bold.otf AdobeHebrew-BoldItalic.otf AdobeHebrew-Italic.otf AdobeHebrew-Regular.otf AdobePiStd.otf AdobeThai-Bold.otf AdobeThai-BoldItalic.otf AdobeThai-Italic.otf AdobeThai-Regular.otf CourierStd.otf CourierStd-Bold.otf CourierStd-BoldOblique.otf CourierStd-Oblique.otf MinionPro-Regular.otf MyriadPro-Regular.otf sy______.afm sy______.inf sy______.pfb sy______.pfm zx______.mmm zx______.pfb zx______.pfm zy______.mmm zy______.pfb zy______.pfm | Mandatory.
 | AdobeHeitiStd-Regular.otf AdobeMingStd-Light.otf AdobeMyungjoStd-Medium.otf AdobeSongStd-Light.otf KozGoPr6N-Medium.otf KozMinPr6N-Regular.otf | Necessary for opening PDF files in Chinese, Japanese, or Korean.
Data\Resources\joboptions | Standard.joboptions | Mandatory for PDF opening.
Data\Resources\Unicode\* | All files in this folder and subfolders. | Mandatory for PDF opening.

See also

ABBYY FlexiCapture Engine Distribution Kit


Specifications

No topics above this level

Specifications

This section contains the descriptions of ABBYY FlexiCapture Engine 12 general features:

·Supported Image Formats

·List of the Predefined Languages

·List of the Special Predefined Languages

·Text Types

·Barcode Types

·Export File Formats

·System Requirements

·Backward Compatibility Issues


Supported Image Formats

Specifications >

Supported Image Formats

ABBYY FlexiCapture Engine 12 opens and saves image files in the following formats:

Format | Extension | Open | Save
BMP: uncompressed black and white, uncompressed gray, uncompressed color | bmp | + | +
DCX: 2-bit — black and white 4- and 8-bit — gray TrueColor | dcx | + | +
PCX: 2-bit — black and white 4- and 8-bit — gray TrueColor | pcx | + | +
PNG: black and white, gray, color | png | + | +
JPEG 2000: gray, 8-bit color, RGB or YCC colorspace, 8 bit per channel color, encoded using 8-bit palette in RGB colorspace | jp2, jpc | + | +
JPEG: gray, color | jpg, jpeg, jfif | + | +
PDF (Version 1.7 or earlier) | pdf | + | +
TIFF: black and white — uncompressed, CCITT4, Packbits, ZIP, LZW gray — uncompressed, Packbits, JPEG, ZIP, LZW TrueColor — uncompressed, JPEG, ZIP, LZW Palette — uncompressed, Packbits, ZIP multi image TIFF | tif, tiff | + | +
GIF: black and white — LZW-compressed gray — LZW-compressed TrueColor — LZW-compressed | gif | + |
DjVu: black and white, gray, color | djvu, djv | + |
JBIG2 | jb2 | + |
WDP | wdp | + |

note Note: ABBYY FlexiCapture Engine will not open images larger than 32512*32512 pixels.


Predefined Languages in ABBYY FlexiCapture Engine

Specifications >

Predefined Languages in ABBYY FlexiCapture Engine

Here is the list of internal names of the predefined languages that are supported in ABBYY FlexiCapture Engine. Availability of this or that predefined recognition language depends on the availability of the corresponding modules among ABBYY FlexiCapture Engine files. See the Installation section to know which recognition languages correspond to which ABBYY FlexiCapture Engine modules.

ABBYY FlexiCapture Engine provides core recognition languages for OCR and ICR with full built-in dictionary support. Some recognition languages are available only for OCR, or do not have full built-in dictionary support. See details in the table below.

ABBYY FlexiCapture Engine additionally provides a set of specific recognition languages. These languages contain special language units (e.g. addresses, date and time, human names, ets.). Such languages can be used for field recognition. See the list of special predefined languages for more information.

Internal name | Recognition language | Can be used for OCR | Can be used for ICR | Full dictionary support available
Abkhaz | Abkhaz | + |  |
Adyghe | Adyghe | + |  |
Afrikaans | Afrikaans | + | + |
Agul | Agul | + |  |
Albanian | Albanian | + | + |
Altaic | Altaic | + |  |
Arabic | Arabic (Saudi Arabia) | + |  | +
ArmenianEastern | Armenian (Eastern) | + |  | +
ArmenianGrabar | Armenian (Grabar) | + |  | +
ArmenianWestern | Armenian (Western) | + |  | +
Awar | Avar | + |  |
Aymara | Aymara | + | + |
AzeriCyrillic | Azerbaijani (Cyrillic) | + |  |
AzeriLatin | Azerbaijani (Latin) | + | + | +
Bashkir | Bashkir | + |  | +
Basic | Basic programming language | + |  |
Basque | Basque | + | + |
Belarusian | Belarussian | + |  |
Bemba | Bemba | + | + |
Blackfoot | Blackfoot | + | + |
Breton | Breton | + | + |
Bugotu | Bugotu | + | + |
Bulgarian | Bulgarian | + | + | +
Burmese | Burmese | + |  |
Buryat | Buryat | + | + |
C++ | C/C++ programming language | + |  |
Catalan | Catalan | + |  | +
Chamorro | Chamorro | + | + |
Chechen | Chechen | + |  |
Chemistry | Simple chemical formulas | + |  |
ChinesePRC | Chinese (PRC) | + |  |
ChineseTaiwan | Chinese (Taiwan) | + |  |
Chukcha | Chukcha | + |  |
Chuvash | Chuvash | + |  |
CMC7 | For MICR CMC-7 text type | + | + |
Cobol | Cobol programming language | + |  |
Corsican | Corsican | + | + |
CrimeanTatar | Crimean Tatar | + | + |
Croatian | Croatian | + | + | +
Crow | Crow | + | + |
Czech | Czech | + | + | +
Danish | Danish | + | + | +
Dargwa | Dargwa | + |  |
Digits | Numbers | + | + |
Dungan | Dungan | + |  |
Dutch | Dutch (Netherlands) | + | + | +
DutchBelgian | Dutch (Belgium) | + | + | +
E13B | For MICR (E-13B) text type | + |  |
English | English | + | + | +
EskimoCyrillic | Eskimo (Cyrillic) | + |  |
EskimoLatin | Eskimo (Latin) | + |  |
Esperanto | Esperanto | + |  |
Estonian | Estonian | + | + | +
Even | Even | + | + |
Evenki | Evenki | + | + |
Faeroese | Faeroese | + |  |
Farsi | Farsi | + |  | +
Fijian | Fijian | + | + |
Finnish | Finnish | + | + | +
Fortran | Fortran programming language | + |  |
French | French | + | + | +
Frisian | Frisian | + | + |
Friulian | Friulian | + | + |
GaelicScottish | Scottish Gaelic | + | + |
Gagauz | Gagauz | + |  |
Galician | Galician | + | + |
Ganda | Ganda | + | + |
German | German | + | + | +
GermanLuxembourg | German (Luxembourg) | + | + |
GermanNewSpelling | German (new spelling) | + | + | +
Georgian | Georgian | + |  |
Greek | Greek | + | + | +
Guarani | Guarani | + | + |
Hani | Hani | + | + |
Hausa | Hausa | + |  |
Hawaiian | Hawaiian | + | + |
Hebrew | Hebrew | + |  | +
Hungarian | Hungarian | + | + | +
Icelandic | Icelandic | + |  |
Ido | Ido | + | + |
Indonesian | Indonesian | + | + | +
Ingush | Ingush | + |  |
Interlingua | Interlingua | + | + |
Irish | Irish | + | + |
Italian | Italian | + | + | +
Japanese | Japanese | + |  | +
JapaneseModern | Japanese (Modern) | + |  | +
Java | Java programming language | + |  |
Kabardian | Kabardian | + |  |
Kalmyk | Kalmyk | + |  |
KarachayBalkar | Karachay-Balkar | + | + |
Karakalpak | Karakalpak | + |  |
Kasub | Kasub | + | + |
Kawa | Kawa | + | + |
Kazakh | Kazakh | + | + |
Khakas | Khakas | + |  |
Khanty | Khanty | + |  |
Kikuyu | Kikuyu | + |  |
Kirgiz | Kirghiz | + | + |
Kongo | Kongo | + | + |
Korean | Korean | + |  | +
KoreanHangul | Korean (Hangul) | + |  | +
Koryak | Koryak | + |  |
Kpelle | Kpelle | + | + |
Kumyk | Kumyk | + | + |
Kurdish | Kurdish | + | + |
Lak | Lak | + |  |
Lappish | Sami (Lappish) | + | + |
Latin | Latin | + | + | +
Latvian | Latvian | + | + | +
LatvianGothic | Latvian language written in Gothic script | + |  |
Lezgin | Lezgin | + |  |
Lithuanian | Lithuanian | + | + | +
Luba | Luba | + | + |
Macedonian | Macedonian | + |  |
Malagasy | Malagasy | + | + |
Malay | Malay | + |  |
Malinke | Malinke | + | + |
Maltese | Maltese | + |  |
Mansi | Mansi | + |  |
Maori | Maori | + | + |
Mari | Mari | + |  |
Maya | Maya | + | + |
Miao | Miao | + | + |
Minankabaw | Minangkabau | + | + |
Mohawk | Mohawk | + | + |
Mongol | Mongol | + | + |
Mordvin | Mordvin | + | + |
Nahuatl | Nahuatl | + | + |
Nenets | Nenets | + | + |
Nivkh | Nivkh | + | + |
Nogay | Nogay | + | + |
Norwegian | NorwegianNynorsk + NorwegianBokmal | + | + | +
NorwegianBokmal | Norwegian (Bokmal) | + | + | +
NorwegianNynorsk | Norwegian (Nynorsk) | + | + | +
Nyanja | Nyanja | + | + |
Occidental | Occidental | + |  |
OcrA | For OCR-A text type | + |  |
OcrB | For OCR-B text type | + |  |
Ojibway | Ojibway | + | + |
OldEnglish | Old English | + | + | +
OldFrench | Old French | + | + | +
OldGerman | Old German | + | + | +
OldItalian | Old Italian | + | + | +
OldSlavonic | Old Slavonic | + |  |
OldSpanish | Old Spanish | + | + | +
Ossetic | Ossetian | + |  |
Papiamento | Papiamento | + | + |
Pascal | Pascal programming language | + |  |
PidginEnglish | Tok Pisin | + | + |
Polish | Polish | + | + | +
PortugueseBrazilian | Portuguese (Brazil) | + | + | +
PortugueseStandard | Portuguese (Portugal) | + | + | +
Provencal | Provencal | + |  |
Quechua | Quechua | + | + |
RhaetoRomanic | Rhaeto-Romanic | + | + |
Romanian | Romanian | + | + | +
RomanianMoldavia | Romanian (Moldavia) | + | + |
Romany | Romany | + | + |
Ruanda | Ruanda | + | + |
Rundi | Rundi | + | + |
Russian | Russian | + | + | +
RussianOldSpelling | Russian (old spelling) | + |  | +
RussianWithAccent | Russian (with accents marking stress position) | + |  | +
Samoan | Samoan | + | + |
Selkup | Selkup | + | + |
SerbianCyrillic | Serbian (Cyrillic) | + | + |
SerbianLatin | Serbian (Latin) | + | + |
Shona | Shona | + |  |
Sioux | Sioux (Dakota) | + | + |
Slovak | Slovak | + | + | +
Slovenian | Slovenian | + | + | +
Somali | Somali | + | + |
Sorbian | Sorbian | + |  |
Sotho | Sotho | + | + |
Spanish | Spanish | + | + | +
Sunda | Sunda | + |  |
Swahili | Swahili | + | + |
Swazi | Swazi | + | + |
Swedish | Swedish | + | + | +
Tabassaran | Tabassaran | + |  |
Tagalog | Tagalog | + | + |
Tahitian | Tahitian | + | + |
Tajik | Tajik | + | + |
Tatar | Tatar | + |  | +
Thai | Thai | + |  | +
Tinpo | Jingpo | + | + |
Tongan | Tongan | + | + |
Tswana | Tswana | + | + |
Tun | Tun | + | + |
Turkish | Turkish | + | + | +
Turkmen | Turkmen | + |  |
TurkmenLatin | Turkmen (Latin) | + | + |
Tuvin | Tuvan | + | + |
Udmurt | Udmurt | + |  |
UighurCyrillic | Uighur (Cyrillic) | + |  |
UighurLatin | Uighur (Latin) | + | + |
Ukrainian | Ukrainian | + | + | +
UzbekCyrillic | Uzbek (Cyrillic) | + |  |
UzbekLatin | Uzbek (Latin) | + | + |
Vietnamese | Vietnamese | + |  | +
Visayan | Cebuano | + | + |
Welsh | Welsh | + |  |
Wolof | Wolof | + | + |
Xhosa | Xhosa | + | + |
Yakut | Yakut | + |  |
Yiddish | Yiddish | + |  |
Zapotec | Zapotec | + | + |
Zulu | Zulu | + |  |

See also

LanguageIdEnum


Special Predefined Languages in ABBYY FlexiCapture Engine

Specifications >

Special Predefined Languages in ABBYY FlexiCapture Engine

Here is the list of internal names of the special predefined languages that are supported in ABBYY FlexiCapture Engine. These languages contain special language units, e.g. addresses, date and time, human names, etc. The special predefined languages are available for Handprint recognition, and can be used for field recognition. Availability of this or that language depends on the availability of the corresponding modules among ABBYY FlexiCapture Engine files. See the Installation section to know which recognition languages correspond to which ABBYY FlexiCapture Engine files.

Internal name | Description
Bulgarian_Address | Address (Bulgarian)
Bulgarian_Address_City | City, village, settlement (Bulgarian), e.g. "Алеко-Константиново", "Сопот", "Старо село"
Bulgarian_Address_Country | Country (Bulgarian), e.g. "Аржентина", "Обединени Арабски Емирства", "Сан-Марино", "Кокосови Острови"
Bulgarian_Address_PhoneNumber | Phone number (Bulgarian), e.g. "Тел. +359 123 456 789", "00359123456789", "Факс:123-456-789"
Bulgarian_Address_PhonePrefixes | Phone prefix (Bulgarian), e.g. "Тел.", "Факс", "дом."
Bulgarian_Address_Region | Region (Bulgarian), e.g. "Монтана", "Стара Загора"
Bulgarian_Address_ZipCode | Zip code (Bulgarian), e.g. 3500, 6000, 6155
Bulgarian_Currency_ByDigits | Currency in numerals (Bulgarian) e.g. "3.40 лев", "340 лв"
Bulgarian_Currency_ByWords | Currency in words (Bulgarian), e.g. "осемдесет хиляди четиристотин и дванадесет лева и деветдесет и пет стотинки", "нула лева и шестдесет стотинки"
Bulgarian_Currency_Names | Currency name (Bulgarian), e.g. "лев", "лв", "ст"
Bulgarian_DateTime_MonthByWords | Month spelled out (Bulgarian), e.g. "Декември", "Дек"
Bulgarian_HumanProperName | Full name (Bulgarian), e.g. "Йордан Йовков", "Вангелия Пандева Гуштерова"
Bulgarian_HumanProperName_Initial | Initial (Bulgarian), e.g. "А.", "А"
Bulgarian_HumanProperName_Name | Name (Bulgarian), e.g. "Агна", "Агнеса", "Агнесия", "Юра", "Юрий", "Юрка"
Bulgarian_HumanProperName_Surname | Surname (Bulgarian), e.g. "Иванов", "Иванова"
Bulgarian_Number | Number (Bulgarian), e.g. 80412, "осемдесет хиляди четиристотин и дванадесет"
Bulgarian_Number_ByWords | Number spelled out (Bulgarian), e.g. "осемдесет хиляди четиристотин и дванадесет"
Croatian_Address | Address (Croatian)
Croatian_Address_City | City (Croatian), e.g. "GRAD ZAGREB", "ZAGREB", "OSIJEK"
Croatian_Address_Country | Country (Croatian), e.g. "Hrvatska", "Francuska Republika"
Croatian_Address_PhoneNumber | Phone number (Croatian), e.g. "Tel. 091 123 4567", "+385-1-2345678"
Croatian_Address_PhonePrefixes | Phone prefix (Croatian), e.g. "Tel.", "Mobile"
Croatian_Address_Region | Region (Croatian)
Croatian_Address_Street | Street (Croatian), e.g. "Ljubljanska avenija", "Ljubljanska av."
Croatian_Address_ZipCode | Zip code (Croatian), e.g. 10000, 31000, 31512
Croatian_Currency_ByDigits | Currency in numerals (Croatian), e.g. "100 kn", "1200 kune"
Croatian_Currency_Names | Currency name (Croatian), e.g. "kuna", "lipa"
Croatian_DateTime_MonthByWords | Month spelled out (Croatian), e.g. "Prosinac", "Decembar"
Croatian_HumanProperName | Full name (Croatian), e.g. "Vladimir Prelog", "Mira Furlan"
Croatian_HumanProperName_Initial | Initial (Croatian), e.g. "А.", "А"
Croatian_HumanProperName_Name | Name (Croatian), e.g. "Vladimir", "Mira"
Croatian_HumanProperName_Surname | Surname (Croatian), e.g. "Prelog", "Furlan"
Croatian_Number_ByWords | Number spelled out (Croatian), e.g. "dvadeset i jedan"
Czech_Address | Address (Czech)
Czech_Address_City | City, village, settlement (Czech), e.g. "Praha"
Czech_Address_CityDistricts | City district (Czech), e.g. "Stare Mesto", "Butovice"
Czech_Address_PhoneNumber | Phone number (Czech), e.g. "Tel. 5-12345678", "420-5-12345678", "(+420)5 12345678", "Mobile: 602 123456"
Czech_Address_PhonePrefixes | Phone prefix (Czech), e.g. "Tel.", "Mobile"
Czech_Address_Street | Street (Czech), e.g. "Dvorakovo Nabrezi", "Celetna"
Czech_Address_ZipCode | Zip code (Czech), e.g. 190 00, 75361
Czech_Currency_ByDigits | Currency in numerals (Czech)
Czech_Currency_Names | Currency name (Czech), e.g. "Kc", "korun"
Czech_DateTime_MonthByWords | Month spelled out (Czech), e.g. "prosinec"
Czech_DateTime_WeekDayByWords | Day of week spelled out (Czech), e.g. "sobota"
Czech_HumanProperName | Full name (Czech), e.g. "Milan Kundera", "Karel Zeman", "Petra Kvapilova"
Czech_HumanProperName_Initial | Initial (Czech), e.g. "А.", "А"
Czech_HumanProperName_Name | Name (Czech), e.g. "Milan", "Karel", "Petra"
Czech_HumanProperName_Surname | Surname (Czech), e.g. "Kundera", "Zeman", "Kvapilova"
English_Address | Address (English)
English_Address_Abbreviation | Abbreviation (English), e.g. "ave", "Rd", "BLVD"
English_Address_CityOfWorld | City in the world (English), e.g. "Moscow", "Paris", "Plymouth"
English_Address_Country | Country (English), e.g. "Armenia", "Brazil", "UK", "United Kingdom", "England"
English_Address_PhoneNumber | Phone number (English), e.g. "Mob. +44(0)7123 456 789", "Tel: 01234-567890", "1(123)123-4567", "Fax: +1 123 123 4567"
English_Address_PhonePrefixes | Phone prefix (English), e.g. "Mob.", "Tel"
English_Address_ZipCode | Zip code (English), e.g. 01234, "A0B1C2"
English_Canada_Address_ZipCode | Canadian zip code (English), e.g. "A0B1C2"
English_DateTime_MonthByWords | Month spelled out (English), e.g. "Jan", "January"
English_HumanProperName | Full name (English), e.g. "Mr. John Smith Jr", "Norman McCoy", "Mary Smith-Jones"
English_HumanProperName_Initial | Initial (English), e.g. "A."
English_HumanProperName_Name | Name (English), e.g. "John", "Norman", "Mary"
English_HumanProperName_Surname | Surname (English), e.g. "Smith", "McCoy", "Smith-Jones"
English_Number | Number (English), e.g. 24, 1001, "twenty-four", "One thousand and one"
English_Number_ByWords | Number spelled out (English), e.g. "twenty-four", "One thousand and one"
English_UK_Address_City | City, village, settlement (English, United Kingdom), e.g. "London", "Greater London", "Plymouth"
English_UK_Address_Region | Region (English, United Kingdom), e.g. "Gloucestershire", "West Sussex", "Isle of Wight"
English_UK_Address_Zipcode | Zip code (English, United Kingdom), e.g. "WC1 1AA", "BS12BB"
English_UK_Currency_ByDigits | Currency in numerals (English, United Kingdom), e.g. "GBP 19.95", "100 Pounds", "99 p"
English_UK_Currency_Names | Currency name (English, United Kingdom), e.g. "GBP", "Pounds", "p"
English_US_Address | Address (English, United States), e.g. "PO Box 99 Independence str. #57 2nd Flr"
English_US_Address_City | City, village, settlement (English, United States), e.g. "New York", "Los Angeles", "St. Petersburg", "St. Pete"
English_US_Address_PhoneNumber | Phone number (English, United States).
English_US_Address_State | State (English, United States), e.g. "WA", "Washington"
English_US_Address_Street | Street (English, United States), e.g. "Fifth Avenue", "Wall st", "Times Square"
English_US_Address_ZipCode | Zip code (English, United States), e.g. 01234
English_US_Currency_Abbreviation | Currency abbreviation (English, United States), e.g. "USD", "Dollars", "d"
English_US_Currency_ByDigits | Currency in numerals (English, United States), e.g. "19.95 USD", "100 Dollars", "99 c"
English_US_Currency_ByWords | Currency in words (English, United States), e.g. "Nineteen dollars ninety-five cents", "One hundred dollars", "ninety nine cents"
English_US_WellKnownCode_EIN | Employer Identification Number (English, United States).
English_US_WellKnownCode_SSN | Social security number (English, United States), e.g. 078-05-1120
French_Address | Address (French)
French_Address_City | City, village, settlement (French), e.g. "Paris", "Cannes", "Saint-Denis"
French_Address_PhoneNumber | Phone number (French), e.g. "Tel: 08 12 34 56 78", "+33(1) 12 34 56 78"
French_Address_PhonePrefixes | Phone prefix (French), e.g. "Tel", "Fax"
French_Address_ZipCode | Zip code (French), e.g. 01234
French_Currency_ByDigits | Currency in numerals (French), e.g. "EUR 19.95", "100 euro", "99 c"
French_Currency_Names | Currency name (French), e.g. "EUR", "euro", "c"
French_DateTime_MonthByWords | Month spelled out (French), e.g. "janvier", "janv."
French_HumanProperName | Full name (French)
French_HumanProperName_Initial | Initial (French), e.g. "A."
French_HumanProperName_Name | Name (French)
French_HumanProperName_Surname | Surname (French)
German_Abbreviation | Abbreviation (German), e.g. "GmbH", "BASF", "BverwG"
German_Address | Address (German)
German_Address_City | City, village, settlement (German), e.g. "Berlin", "Prenzlauer Berg", "Prien Am Chiemsee"
German_Address_PhoneNumber | Phone number (German), e.g. "Tel: (089)123-45678", "+49 30 12345678"
German_Address_PhonePrefixes | Phone prefix (German), e.g. "Tel", "Fax"
German_Address_Region | Region (German), e.g. "Baden-Wuerttemberg", "Berlin"
German_Address_Street | Street (German), e.g. "Alexanderplatz", "Alexander Platz"
German_Address_ZipCode | Zip code (German), e.g. 01234
German_Currency_ByDigits | Currency in numerals (German), e.g. "EUR 19.95", "100 euro", "99 c"
German_Currency_Names | Currency name (German), e.g. "EUR", "euro", "c"
German_DateTime_MonthByWords | Month spelled out (German), e.g. "Januar", "Jan."
German_Firms | Firm name (German), e.g. "Deutscher Akademischer Austauschdienst", "DAAD"
German_HumanProperName | Full name (German), e.g. "Werner Herzog", "Marie Magdalene Dietrich"
German_HumanProperName_Initial | Initial (German), e.g. "A."
German_HumanProperName_Name | Name (German), e.g. "Werner", "Marie", "Magdalene"
German_HumanProperName_Surname | Surname (German), e.g. "Herzog", "Dietrich"
Greek_Address | Address (Greek)
Greek_Address_City | City, village, settlement (Greek)
Greek_Address_PhoneNumber | Phone number (Greek)
Greek_Address_PhonePrefixes | Phone prefix (Greek)
Greek_Address_Region | Region (Greek)
Greek_Address_Street | Street (Greek)
Greek_Address_ZipCode | Zip code (Greek)
Greek_Currency_ByDigits | Currency in numerals (Greek), e.g. "EUR 19.95", "100 euro", "99 c"
Greek_Currency_Names | Currency name (Greek), e.g. "EUR", "euro", "c"
Greek_DateTime_MonthByWords | Month spelled out (Greek)
Greek_HumanProperName | Full name (Greek)
Greek_HumanProperName_Name | Name (Greek)
Greek_HumanProperName_Surname | Surname (Greek)
Hungarian_Address | Address (Hungarian)
Hungarian_Address_City | City, village, settlement (Hungarian)
Hungarian_Address_Country | Country (Hungarian)
Hungarian_Address_PhoneNumber | Phone number (Hungarian)
Hungarian_Address_PhonePrefix | Phone prefix (Hungarian)
Hungarian_Address_Street | Street (Hungarian)
Hungarian_Address_ZipCode | Zip code (Hungarian)
Hungarian_Currency_ByDigits | Currency in numerals (Hungarian)
Hungarian_Currency_Names | Currency name (Hungarian)
Hungarian_DateTime_MonthByWords | Month spelled out (Hungarian)
Hungarian_HumanProperName | Full name (Hungarian)
Hungarian_HumanProperName_Initial | Initial (Hungarian)
Hungarian_HumanProperName_Name | Name (Hungarian)
Hungarian_HumanProperName_Surname | Surname (Hungarian)
Hungarian_Number_ByWords | Number spelled out (Hungarian)
Italian_Address | Address (Italian)
Italian_Address_City | City, village, settlement (Italian)
Italian_Address_PhoneNumber | Phone number (Italian)
Italian_Address_PhonePrefix | Phone prefix (Italian)
Italian_Address_Street | Street (Italian)
Italian_Address_ZipCode | Zip code (Italian)
Italian_Currency_ByDigits | Currency in numerals (Italian)
Italian_Currency_Names | Currency name (Italian)
Italian_DateTime_MonthByWords | Month spelled out (Italian)
Italian_HumanProperName | Full name (Italian)
Italian_HumanProperName_Initial | Initial (Italian)
Italian_HumanProperName_Name | Name (Italian)
Italian_HumanProperName_Surname | Surname (Italian)
Neutral_Address_Email | E-mail address, e.g. "support@abbyy.com"
Neutral_Address_TopLevelDomain | Top level domain, e.g. "com", "net", "ru"
Neutral_ArabicIndianDigits | Arabic numerals
Neutral_Currency_Abbreviation | Currency abbreviation, e.g. "EUR", "USD", "RUR"
Neutral_Currency_International | Currency, e.g. "EUR 19.95", "100 Dollars", "99 c"
Neutral_Currency_Prefixes | Currency prefix, e.g. "EUR", "USD"
Neutral_Currency_Suffixes | Currency suffix, e.g. "p", "c"
Neutral_DateTime | Date, e.g. 31:12:99, 31:12:1999, 12.31.99, 12.31.1999
Neutral_DateTime_DayByDigits | Day, e.g. 1, 01
Neutral_DateTime_DD_MM_YY | Date in the format: <day>.<month>.<year (2 digits)>, e.g. 31:12:99
Neutral_DateTime_DD_MM_YYYY | Date in the format: <day>.<month>.<year (4 digits)>, e.g. 31:12:1999
Neutral_DateTime_MM_DD_YY | Date in the format: <month>.<day>.<year (2 digits)>, e.g. 12.31.99
Neutral_DateTime_MM_DD_YYYY | Date in the format: <month>.<day>.<year (4 digits)>, e.g. 12.31.1999
Neutral_DateTime_MonthByDigits | Month, e.g. 1, 01
Neutral_DateTime_YearByDigits | Year, e.g. 08, 2008
Neutral_Number_Integer | Integer, e.g. 19, 1995
Neutral_Number_Real | Decimal number, e.g. 19.95
Neutral_Number_Roman | Roman numeral, e.g. VIII, IX
Neutral_Number_TwoDigits | Two-figure number, e.g. 01, 19
Neutral_Number_UnsignedInteger | Unsigned integer, e.g. 19, 1995
Neutral_Time_12_24hours | Time, e.g. "11:59 am", "23:59"
Neutral_Time_12hours | Time in 12 hours format, e.g. "11:59 am"
Neutral_Time_24hours | Time in 24 hours format, e.g. "23:59"
Neutral_WellKnownCode_ISBN | International Standard Book Number, e.g. 5-02-028169-7, 5-9900114-1-5
Polish_Abbreviation | Abbreviation (Polish)
Polish_Address | Address (Polish)
Polish_Address_City | City, village, settlement (Polish)
Polish_Address_PhoneNumber | Phone number (Polish)
Polish_Address_PhonePrefix | Phone prefix (Polish)
Polish_Address_Streets | Streets (Polish)
Polish_Address_ZipCode | Zip code (Polish)
Polish_Currency | Currency (Polish)
Polish_Currency_Local | Local currency (Polish)
Polish_DateTime_MonthByWords | Month spelled out (Polish)
Polish_Firm | Firm name (Polish)
Polish_HumanProperName | Full name (Polish)
Polish_HumanProperName_Initial | Initial (Polish)
Polish_HumanProperName_Name | Name (Polish)
Polish_HumanProperName_Surname | Surname (Polish)
Russian_Address | Full address (Russian), e.g. "141069 Моск.Обл., г.Королев, мкрн.Первомайский, ул.Речная, д.4, кв.114"
Russian_Address_City | City, village, settlement (Russian), e.g. "г.Москва", "д. Сосновка", "Петропавловск-Камчатский", "Арзамас-16"
Russian_Address_Country | Country (Russian), e.g. "Россия", "Российская Федерация", "Великобритания", "Англия"
Russian_Address_PhoneNumber | Phone number (Russian), e.g. "Тел: (495)123-45-67", "Моб. 8-903-1234567", "Моб. (903)1234567"
Russian_Address_Region | Region (Russian), e.g. "Моск.Обл.", "Самарская Обл.", "Кабардино-Балкарская Республика", "Кабардино-Балкария"
Russian_Address_Street | Street (Russian), e.g. "ул. Покровка", "Пречистенская наб.", "Невский пр."
Russian_Address_ZipCode | Zip code (Russian), e.g. 141069
Russian_Currency_ByDigits | Currency in numerals (Russian), e.g. "19 р. 95 к.", "100 руб."
Russian_Currency_Names | Currency name (Russian), e.g. "рублей", "руб."
Russian_DateTime_Month | Month (Russian), e.g. 1, 01, "янв.", "январь", "января"
Russian_DateTime_MonthByRomanDigits | Month in Roman numerals (Russian), e.g. VII, IX
Russian_DateTime_MonthByWords | Month spelled out (Russian), e.g. "янв.", "январь", "января"
Russian_DateTime_YearByWords | Year spelled out (Russian), e.g. "г.", "года"
Russian_HumanProperName | Full name (Russian), e.g. "Пушкин Александр Сергеевич", "Лидия Николаевна Федосеева-Шукшина"
Russian_HumanProperName_Name | Name (Russian), e.g. "Александр", "Саша", "Лидия", "Лида"
Russian_HumanProperName_Patronymic | Patronymic (Russian), e.g. "Сергеевич", "Николаевна"
Russian_HumanProperName_Surname | Surname (Russian), e.g. "Пушкин", "Федосеева-Шукшина"
Russian_Number | Number (Russian)
Russian_WellKnownCode_BIC | Bank investment contract (Russian), e.g. 044585000
Russian_WellKnownCode_INN | Individual Taxpayer Identification Number (Russian), e.g. 500100732259
Russian_WellKnownCode_Passport | Passport number (Russian), e.g. 12 34 123456
Serbian_Cyrillic_Address_District.amd | District (Serbian, Cyrillic script)
Serbian_Cyrillic_Address_Municipalities.amd | Municipalities (Serbian, Cyrillic script)
Serbian_Cyrillic_Address_Streets.amd | Streets (Serbian, Cyrillic script)
Serbian_Cyrillic_Address_Towns.amd | Towns (Serbian, Cyrillic script)
Serbian_Cyrillic_HumanProperName_Name.amd | Name (Serbian, Cyrillic script)
Serbian_Cyrillic_HumanProperName_Surname.amd | Surname (Serbian, Cyrillic script)
Serbian_Cyrillic_Industry.amd | Industry (Serbian, Cyrillic script)
Serbian_Latin_Address_District.amd | District (Serbian)
Serbian_Latin_Address_Municipalities.amd | Municipalities (Serbian)
Serbian_Latin_Address_Streets.amd | Streets (Serbian)
Serbian_Latin_Address_Towns.amd | Towns (Serbian)
Serbian_Latin_HumanProperName_Name.amd | Name (Serbian)
Serbian_Latin_HumanProperName_Surname.amd | Surname (Serbian)
Serbian_Latin_Industry.amd | Industry (Serbian)
Slovak_AcademicDegree | Academic degree (Slovak)
Slovak_Activity | Activity (Slovak)
Slovak_Address | Address (Slovak)
Slovak_Address_City | City, village, settlement (Slovak)
Slovak_Address_Country | Country (Slovak)
Slovak_Address_PhoneNumber | Phone number (Slovak)
Slovak_Address_PhonePrefix | Phone prefix (Slovak)
Slovak_Address_Region | Region (Slovak)
Slovak_Address_Street | Street (Slovak)
Slovak_Address_ZipCode | Zip code (Slovak)
Slovak_Currency_ByDigits | Currency in numerals (Slovak)
Slovak_Currency_Names | Currency name (Slovak)
Slovak_DateTime_MonthByWords | Month spelled out (Slovak)
Slovak_DateTime_WeekDay | Day of week (Slovak)
Slovak_Firm | Firm name (Slovak)
Slovak_HumanProperName | Full name (Slovak)
Slovak_HumanProperName_Initial | Initial (Slovak)
Slovak_HumanProperName_Name | Name (Slovak)
Slovak_HumanProperName_Surname | Surname (Slovak)
Slovak_TaxOffice | Tax office (Slovak)
Spanish_HumanProperName_Name | Name (Spanish)
Ukrainian_Address | Address (Ukrainian)
Ukrainian_Address_Abbreviation | Address abbreviation (Ukrainian)
Ukrainian_Address_City | City, village, settlement (Ukrainian)
Ukrainian_Address_District | District (Ukrainian)
Ukrainian_Address_KievStreet | Street in Kiev (Ukrainian)
Ukrainian_Address_Region | Region (Ukrainian)
Ukrainian_Address_ZIPcode | Zip code (Ukrainian)
Ukrainian_Currency_ByDigits | Currency in numerals (Ukrainian)
Ukrainian_Currency_Names | Currency name (Ukrainian)
Ukrainian_DateTime | Date (Ukrainian)
Ukrainian_DateTime_MonthByWords | Month spelled out (Ukrainian)
Ukrainian_HumanProperName | Full name (Ukrainian)
Ukrainian_HumanProperName_Initial | Initial (Ukrainian)
Ukrainian_HumanProperName_Name | Name (Ukrainian)
Ukrainian_HumanProperName_Surname | Surname (Ukrainian)

See also

Predefined Languages in ABBYY FlexiCapture Engine


Text Types

Specifications >

Text Types

The ABBYY FlexiCapture Engine 12 recognizes the following types of text:

·Common typographic text

·Text typed on a typewriter

·Text printed on a dot-matrix printer

·Text printed on a fax machine

·Special set of characters including only digits written in ZIP-code style. They look as follows:

·Handprinted text. It may look as follows:

·Text in monospaced font designed specifically for Optical Character Recognition. It is largely used by banks, credit card companies and similar businesses. It may look as follows:

·Text printed in a font designed specifically for Optical Character Recognition. It may look as follows:

·Special numeric characters printed in magnetic ink. MICR (Magnetic Ink Character Recognition) characters are found in a variety of places, including personal checks. They may look as follows:

·Special MICR barcode font (CMC-7). It may look as follows:

See also

TextTypeEnum


Barcode Types

Specifications >

Barcode Types

ABBYY FlexiCapture Engine 12 recognizes the following types of barcode:

Barcode Type

Description

AustraliaPost

AustraliaPost is a "four-state" system encoding four types of bars: Full-Height, Ascender, Descender and Tracker (DAFT notation). This encoding system is used in mail sorting for Australia. AustraliaPost bar codes can be created and printed using standard barcode generation software.

Aztec

Aztec is a high density two-dimensional matrix style bar code symbology that can encode up to 3750 characters from the entire 256 byte ASCII character set. The symbol is built on a square grid with a bulls-eye pattern at its center.

Codabar

Codabar is a self-checking, variable length barcode that can encode 16 data characters. It is used primarily for numeric data, but also encodes six special characters. Codabar is useful for encoding dollar and mathematical figures because a decimal point, plus sign, and minus sign can be encoded.

note Note: While Codabar originally has no check digit, it can be interpreted as the barcode with a check sum. ABBYY FlexiCapture Engine 12 uses an algorithm for computing check digits according to Modulo 16. The check digit is computed as follows. Each Codabar character has a value assigned to it. The sum of all character values is taken, including the Start and the Stop characters. The data character whose value, when added to this sum, equals a multiple of 16 is the check digit.

Code 128

Code 128 is an alphanumeric, very high-density, compact, variable length barcode scheme that can encode the full 128 ASCII character set. Each character is represented by three bars and three spaces totaling 11 modules. Each bar or space is one, two, three, or four modules wide with the total number of modules representing bars an even number and the total number of modules representing a space an odd number. Three different start characters are used to select one of three character sets.

Code 32

Code 32 (Pharmacode) is a variation of the Code 39, representing an integer value from 3 to 131070. The number is encoded in binary using black bars and spaces between them. The minimum number of bars is 2, the maximum is 16. Pharmacode is used in the pharmaceutical industry as a packing control system.

Code 39

Code 39, also referred to as Code 3 of 9, is an alphanumeric, self-checking, variable length barcode that uses five black bars and four spaces to define a character. Three of the elements are wide and six are narrow.

note Note: Barcode in Code 39 standard without asterisk has no start and stop symbol, the asterisk "*".

Code 93

Code 93 is a variable length bar code that encodes 47 characters. It is named Code 93 because every character is constructed from nine elements arranged into three bars with their adjacent spaces. Code 93 is a compressed version of Code 39 and was designed to complement Code 39.

Data Matrix

Data Matrix is a two-dimensional matrix barcode consisting of black and white modules arranged in either a square or rectangular pattern. Every Data Matrix is composed of two solid adjacent borders in an "L" shape and two other borders consisting of alternating dark and light modules. Within these borders are rows and columns of cells encoding information. A Data Matrix barcode can store up to 2335 alphanumeric characters.

EAN 8 and 13

The European Article Numbering (EAN) system is used for products that require a country origin. This is a fixed-length barcode used to encode either eight or thirteen characters. The first two characters identify the country of origin, the next characters are data characters, and the last character is the checksum. These barcodes may include an additional barcode to the right of the main barcode. This second barcode, which is usually not as tall as the primary barcode, is used to encode additional information for newspapers, books, and other periodicals. The supplemental barcode may either encoded 2 or 5 digits of information.

GS1-128

This type of barcode is a 19 digit barcode with a 20th check digit. For a total of 20 digits. It typically is used for carton identification. Both for internal carton numbering and also for using the UCC-128 barcode on your cartons being shipped out to your customers. Former coorect name UCC-128.

IATA 2 of 5

IATA 2 of 5 is a barcode standard designed by the IATA (International Air Transport Association). This standard is used for all boarding passes.

Industrial 2 of 5

Industrial 2 of 5 is numeric-only barcode that has been in use a long time. Unlike Interleaved 2 of 5, all of the information is encoded in the bars; the spaces are fixed width and are used only to separate the bars. The code is self-checking and does not include a checksum.

IntelligentMail

IntelligentMail is a 65-bar height-modulated self-checking barcode used on mail in USA. Four types of bars are used for encoding: Full-Height, Ascender, Descender and Tracker (DAFT notation). The 65 bars encode 114-bit message. This message is represented by 130 bits, grouped as ten 13-bit characters. 2, 5, 8 or 11 of the 13 bits of each character are set to one. The Hammind distance between bars is at least 2.

Interleaved 2 of 5

Interleaved 2 of 5 is a variable length (must be a multiple of two), high-density, self-checking, numeric barcode that uses five black bars and five white bars to define a character. Two digits are encoded in every character; one in the black bars and one in the white bars. Two of the black bars and two of the white bars are wide. The other bars are narrow.

Matrix 2 of 5

Standard 2 of 5 is self-checking numeric-only barcode. Unlike Interleaved 2 of 5, all of the information is encoded in the bars; the spaces are fixed width and are used only to separate the bars. Matrix 2 of 5 is used primarily for warehouse sorting, photo finishing, and airline ticket marking.

MaxiCode

MaxiCode is a specific type of barcode, that uses dots arranged in a hexagonal grid instead of bars. In the center of 1-inch square containing the MaxiCode symbol is a bullseye which is surrounded by the grouped dots. The information encoded with the MaxiCode symbol is protected with a Reed-Solomon error correction which allows to read the message even if a part of the symbol is damaged.

The MaxiCode encoding is used by the United Parcel Service.

Patch

A pattern of horizontal black bars separated by spaces. Typically, a patch code is placed near the top center of a paper document to be scanned and used as a document separator.

PDF417

PDF417 is a variable length, two-dimensional (2D), stacked symbology that can store up to 1850 printable ASCII characters in text compaction mode or 1100 binary characters per symbol in byte compaction mode. PDF417 is designed with selectable levels of error correction. Its high data capacity can be helpful in applications where a large amount of data must travel with a labeled document or item.

note Note: Some barcode printers use code pages other than US-MSDOS required by the specifications. In most cases this will be the code page of the operating system under which the barcode printer was running.

PostNet

The Postnet (Postal Numeric Encoding Technique) is a fixed length symbology (5, 6, 9, or 11 characters) which uses constant bar and space width. Information is encoded by varying the bar height between the two values. Postnet barcodes are placed on the lower right of envelopes or postcards, and are used to expedite the processing of mail with automatic equipment and provide reduced postage rates.

QR Code

QR Code is a two-dimensional matrix barcode. The barcode has 3 large squares (registration marks) in the corners which define the top of the barcode. The black and white squares in the area between the registration marks are the encoded data and error correction keys. QR Codes can encode over 4000 ASCII characters.

UPC-A

The UPC-A barcode is EAN 13 barcode with the '0' first character.

UPC-E

The UPC-E barcode is a shortened version of UPC-A barcode. It compresses the data characters and the checksum into six characters. This bar code is ideal for small packages because it is the smallest bar code.

See also

BarcodeTypeEnum


Export File Formats

Specifications >

Export File Formats

The ABBYY FlexiCapture Engine allows you to export recognized data in the following formats:

·Microsoft Office Excel Workbook (*.XLS)

·DBase file (*.DBF)

·Comma Separated Values File (*.CSV)

·Simple text (*.TXT)

·XML Document (*.XML)


System Requirements

Specifications >

System Requirements

ABBYY FlexiCapture Engine 12 Requirements

·PC with x86-compatible processor (1 GHz or higher)

·Operating system:

oWindows Server 2016

oWindows 10

oWindows Server 2012 R2 with the April 2014 update rollup (KB2919355)

oWindows 8.1 with the April 2014 update rollup (KB2919355)

oWindows Server 2012

oWindows 8

oWindows Server 2008 R2 SP1

oWindows 7 SP1

ABBYY FlexiCapture Engine has been tested on the following cloud computing platforms:

oMicrosoft Azure:

§Azure App Services

§Azure Cloud Services

§Azure Service Fabric

§Azure Virtual Machines

oAmazon EC2

ABBYY FlexiCapture Engine has been tested in the following virtual environments:

oMicrosoft Hyper-V Server 2008

oMicrosoft Hyper-V Server 2008 R2 SP1

oMicrosoft Hyper-V Server 2012

oMicrosoft Hyper-V Server 2012 R2

oMicrosoft Hyper-V Server 2016

oOracle VM VirtualBox 5.2

oParallels Desktop for Mac 13.0.1

oVMware ESXi 6.5

oVMware Workstation Player 12.5

oVMware Workstation Pro 14.0.0
ABBYY FlexiCapture Engine can also be run in a Docker container on supported platforms.

·Memory:

ofor processing one-page documents — minimum 400 MB RAM, recommended 1 GB RAM

ofor processing multi-page documents — minimum 1 GB RAM, recommended 1,5 GB RAM

·Hard disk space: 1400 MB for library installation and 100 MB for program operation plus additional 15Mb for every processing page of a multi-page document

·100% TWAIN-compatible scanner, digital camera, or fax modem — for scanning only

·Video card and monitor (min. resolution 1024*768) — for displaying GUI elements

·Keyboard, mouse or other input device

·The following registry branches should be accessible from the workstation:

o"HKEY_CURRENT_USER\Software\ABBYY\SDK\12\FlexiCapture Engine" — full control

o"HKEY_CURRENT_USER\Software\ABBYY\SDK\12" — full control for installation only

o"HKEY_LOCAL_MACHINE\Software\ABBYY\SDK\12" — full control for installation only

·The following folders should be accessible from the workstation:

oFolder with ABBYY FlexiCapture Engine binary files — access for reading

o%TEMP% folder — full control access

ofolder %ProgramData%\ABBYY\SDK\12\FlexiCapture Engine — full control access

ofolder %ProgramData%\ABBYY\SDK\12\Licenses — full control access

·The following components should be installed:

oMicrosoft® Internet Explorer 8.0 or higher

ABBYY SDK 12 License Server Requirements

·PC with x86-compatible processor (1 GHz or higher)

·Operating system:

oWindows Server 2016

oWindows 10

oWindows Server 2012 R2 with the April 2014 update rollup (KB2919355)

oWindows 8.1 with the April 2014 update rollup (KB2919355)

oWindows Server 2012

oWindows 8

oWindows Server 2008 R2 SP1

oWindows 7 SP1

ABBYY SDK 12 Licensing Service has been tested in the following virtual environments:

oMicrosoft Hyper-V Server 2008

oMicrosoft Hyper-V Server 2008 R2 SP1

oMicrosoft Hyper-V Server 2012

oMicrosoft Hyper-V Server 2012 R2

oMicrosoft Hyper-V Server 2016

oOracle VM VirtualBox 5.2

oParallels Desktop for Mac 13.0.1

oVMware ESXi 6.5

oVMware Workstation Player 12.5

oVMware Workstation Pro 14.0.0

ABBYY SDK 12 Licensing Service can also be run in a Docker container on supported platforms.

·25 MB of free hard-disk space

·folder %ProgramData%\ABBYY\SDK\12\Licenses — full control access

·For activation/deactivation of the License:

oAllowed connections to *.abbyy.com

oport: 80

oprotocol: http

In case proxy-server, VPN- or Dial-Up conection is used you must customize in the Internet Explorer next settings: Tools > Internet Options > Connections

Compatibility

note Note: ABBYY FlexiCapture Engine 12 works with projects created in ABBYY FlexiCapture 12 Release 2 Update 7, Build 12.0.2.3042, or earlier. Projects saved in the current version of ABBYY FlexiCapture Engine 12 can be used in ABBYY FlexiCapture 12 Release 2 Update 7, Build 12.0.2.3042, or later. You can also pass projects to and from ABBYY FlexiCapture 12 shipped with the current ABBYY FlexiCapture Engine 12 distribution.

warning Important! Both ABBYY FlexiCapture Engine and ABBYY FlexiCapture work with the Adobe PDF Library. In case ABBYY FlexiCapture Engine and compatible ABBYY FlexiCapture use different versions of the Adobe PDF Library recognition results can differ.


What's New in ABBYY FlexiCapture Engine 12

Specifications >

What's New in ABBYY FlexiCapture Engine 12

Here you can find the list of new features in ABBYY FlexiCapture Engine 12.

·Working with projects is deprecated. Corresponding functionality will be removed in future versions.
FlexiCapture Engine is designed for data extraction from fixed forms and semi-structured documents. These scenarios can be performed using light-weight FlexiCapture Processor.

·Loading of the Engine object is now a unified algorithm with a possibility to tune loading parameters. Investigate Step 1: Load FlexiCapture Engine for details

·More image preprocessing parameters are available (ReduceISONoise, RemoveColorMarks, TreatImageAsPhoto, UseAutocrop, WhitenBackground properties of the ImageLoadingParams object)

·New functionality for image exporting to PDF/A (PdfAModeEnum, IImageExportParams::PdfAMode, IImageExportParams::EnableFastWebView, IImageExportParams::WriteTaggedPdf).

·Extended information about classification results. All the classes assigned to the page by the classifier and their confidence values can now be observed ( IClassConfidence, IClassConfidences, IClassificationResult::Classes, IClassificationResult::IsConfident )

· Burmese, Farsi, Georgian and Japanese (Modern) languages recognition.

See also

ABBYY FlexiCapture Engine 12 and 11 Compatibility


Backward Compatibility Issues

Specifications >

Backward Compatibility Issues

This section contains the description of compatibility issues with the previous versions of ABBYY FlexiCapture Engine:

·ABBYY FlexiCapture Engine 12 and 11 compatibility

·ABBYY FlexiCapture Engine 12 and 10/10.5 compatibility

·ABBYY FlexiCapture Engine 12 and 9.0/9.5 compatibility


ABBYY FlexiCapture Engine 12 and 11 Compatibility

Specifications > Backward Compatibility Issues >

ABBYY FlexiCapture Engine 12 and 11 Compatibility

ABBYY FlexiCapture Engine 12 is not binary compatible with ABBYY FlexiCapture Engine 11. Applications that were compiled using ABBYY FlexiCapture Engine 11 should be recompiled using ABBYY FlexiCapture Engine 12 headers and library. Some changes of the source code may be necessary because of the ABBYY FlexiCapture Engine API improvements.

Below is the full list of changes.

cicon2 Project structure
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ProjectProperties | DeleteEmptyPages ImageGroupingParams | Removed | These properties did not work properly in previous version and were scheduled for removal.
 | Behavior changed | This property is now read-only. Project properties are intended to be modified only in ABBYY FlexiCapture. |
 | Deprecated | This property is now deprecated. Export parameters of the project should be edited in ABBYY FlexiCapture, before using the project in ABBYY FlexiCapture Engine. |


ABBYY FlexiCapture Engine 12 and 10/10.5 Compatibility

Specifications > Backward Compatibility Issues >

ABBYY FlexiCapture Engine 12 and 10/10.5 Compatibility

ABBYY FlexiCapture Engine 12 is not binary compatible with ABBYY FlexiCapture Engine 10/10.5. Applications that were compiled using ABBYY FlexiCapture Engine 10/10.5 should be recompiled using ABBYY FlexiCapture Engine 12 headers and library. Some changes of the source code may be necessary because of the ABBYY FlexiCapture Engine API improvements.

Below is the full list of changes.

·long data type has been replaced with int data type in all properties and methods that used it.

·The InitializeEngine function now takes only one input parameter — the Customer Project ID number, which is an alphanumeric string common to all the Developer and Runtime licenses your project uses.

·The SaveToMemory method provided by many objects returns the handle to the memory buffer as the Handle object.

·The LoadFromMemory method provided by many objects receives the pointer to the memory buffer as __int64.

cicon2 Engine loaders
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
InitializeEngine |  | Parameters changed | The function now takes only one input parameter — the Project ID number
cicon2 Engine object
Property/Method/Constant | What has happened? | Comment
LoadImageDocFromMemory | Parameters changed | The pointer to a memory buffer containing image data is passed as __int64.
ParentWindow | Type changed | The property has the __int64 type.
cicon2 Project structure
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ProjectProperties | DeleteEmptyPages ImageGroupingParams | Removed | Project properties are intended to be modified only in ABBYY FlexiCapture, before using the project in ABBYY FlexiCapture Engine.
 | Behavior changed | This property is now read-only. Project properties are intended to be modified only in ABBYY FlexiCapture. |
 | Deprecated | This property is now deprecated. Export parameters of the project should be edited in ABBYY FlexiCapture, before using the project in ABBYY FlexiCapture Engine. |
cicon2 Document structure
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
FieldValue | AsInteger | Type changed | The property has the __int64 type.
 | Removed | The properties is no longer supported. |
BarcodeTypeEnum | BT_PDF417_CodePage_in_ByteMode | Removed | This constant is deprecated and was removed.
cicon2 Document definition structure
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
FieldDefinition | IsFlexible | Removed | The property is moved to the SectionDefinition object.
 | Removed | The method is deprecated and is no longer supported. |
TextRecognitionParams | TextType | Type changed | This property now takes an integer value which is an OR superposition of TextTypeEnum constants which correspond to assumed types of the text.
 | Removed | The functionality provided by this property is now covered by the TextType property. |
TextTypeEnum | TT_ToBeDetected | Removed | This constant is no longer needed, as it can be replaced by the OR combination of all the others.
 | Added | This is a new constant, for the type of text frequently used in fax machines. |
cicon2 Image-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
Image | GetPicture | Output parameters number changed. | The handle to the output bitmap is returned as the Handle object
ImageProcessingTools | BitmapToImage | Parameters changed | The pointer to a memory buffer containing image data is passed as __int64.
 | Output parameters number changed. | The handle to the memory buffer is returned as the Handle object. |
 | Parameter renamed | The new name of the parameter HslHew is HslHue. |
 | Removed | This method is deprecated and is no longer supported. |
 | Removed | This method is deprecated and is no longer supported. |
ImageDocument | SaveImageDocToMemory | Renamed, parameters changed | The new name of this method is SaveToMemory. The handle to the memory buffer is returned as the Handle object.
 | Renamed | The new name of the method is SaveTo. |
 | Renamed | The new name of the property is IsSkewCorrected. |
JpegExtendedParams | SaveToMemory | Output parameters number changed. | The handle to the memory buffer is returned as the Handle object.
 | Parameters changed | The pointer to a memory buffer containing image data is passed as __int64. |
ImageTypeEnum | IT_Deskewed | Renamed | The new name of the constant IT_Modified.
ImageCompressionTypeEnum | ICT_J2k ICT_JBIG2 ICT_PDF | Removed | Use the new ICT_Default constant instead. Suitable compression type will be selected automatically.
 | Added | This is a new constant, which allows you to select compression type automatically for all image formats but TIFF. |
 | Removed | The constant is no longer supported. |
cicon2 Export parameter objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ProjectProperties | ExportParams | Behavior changed | The property becomes read-only.
cicon2 Text-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
CharParams | LanguageName | Removed | Use the LanguageId instead.
cicon2 Language-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
EnumDictionaryWords | Dictionary | Removed | The property is no longer supported. The reference to the parent Dictionary object cannot be obtained.
Dictionary | Edit | Removed | The method is no longer supported. Use the Delete and Add methods for editing.
cicon2 Scanning-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ScanPaperSizeEnum | SPS_A6 SPS_A7 SPS_A8 | Added | These are new constants for more page size types.
cicon2 Supplementary objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
LongsCollection |  | Renamed | The new name of the object is IntsCollection.
IntsCollection StringsCollection | Insert | Renamed | The Insert method has been renamed to InsertAt.
Region | SaveToMemory | Output parameters number changed. | The handle to the output bitmap is returned as the Handle object
 | Parameters changed | The pointer to a memory buffer containing image data is passed as __int64. |
cicon2 Verification-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
VerificationObject | ContextImage | Type changed | The property has the __int64 type.
GroupVerificationObject | Image | Type changed | The property has the __int64 type.
cicon2 License-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
AFCEM_ Prefixed Flags | AFCEM_Arabic | Added | This is a new constant of the AFCEM_ prefixed flags.
ATT_ Prefixed Flags | ATT_Fax | Added | This is a new constant of the ATT_ prefixed flags.
 | Removed | The constant was not in use in ABBYY FlexiCapture Engine and made sense only in ABBYY FineReader Engine. |

See also

Specifications

ABBYY FlexiCapture Engine 12 and 9.0 Compatibility


ABBYY FlexiCapture Engine 12 and 9.0/9.5 Compatibility

Specifications > Backward Compatibility Issues >

ABBYY FlexiCapture Engine 12 and 9.0/9.5 Compatibility

ABBYY FlexiCapture Engine 12 is not binary compatible with ABBYY FlexiCapture Engine 9.0/9.5. Applications that were compiled using ABBYY FlexiCapture Engine 9.0 should be recompiled using ABBYY FlexiCapture Engine 12 headers and library. Some changes of the source code may be necessary because of the ABBYY FlexiCapture Engine API improvements.

Below is the full list of changes.

·long data type has been replaced with int data type in all properties and methods that used it.

·The InitializeEngine function now takes only one input parameter — the Customer Project ID number, which is an alphanumeric string common to all the Developer and Runtime licenses your project uses.

·The SaveToMemory method provided by many objects returns the handle to the memory buffer as the Handle object.

·The LoadFromMemory method provided by many objects receives the pointer to the memory buffer as __int64.

cicon2 Engine loaders
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
WorkProcessLoader |  | Renamed | The new name of the object is OutprocLoader
InitializeEngine |  | Parameters changed | The function now takes only one input parameter — the Project ID number
cicon2 Engine object
Property/Method/Constant | What has happened? | Comment
LoadImageDocFromMemory | Parameters changed | The pointer to a memory buffer containing image data is passed as __int64. .
ParentWindow | Type changed | The property has the __int64 type.
cicon2 Document structure
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
FieldValue | IsSuspicious | The property is read-only. | The value of this property is a result of recognition and there is no need to change this value.
 | Type changed | The property has the __int64 type. |
 | Removed | The properties is no longer supported. |
BarcodeTypeEnum | BT_PDF417_CodePage_in_ByteMode | Removed | This constant is deprecated and was removed.
cicon2 Project structure
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ProjectProperties | DeleteEmptyPages ImageGroupingParams | Removed | Project properties are intended to be modified only in ABBYY FlexiCapture, before using the project in ABBYY FlexiCapture Engine.
 | Behavior changed | This property is now read-only. Project properties are intended to be modified only in ABBYY FlexiCapture. |
 | Deprecated | This property is now deprecated. Export parameters of the project should be edited in ABBYY FlexiCapture, before using the project in ABBYY FlexiCapture Engine. |
cicon2 Document definition structure
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
FieldDefinition | ShouldCheckConstraints Format | Removed | The properties are obsolete and are no longer supported in Document Definitions.
 | Removed | The property is moved to the SectionDefinition object. |
 | Removed | The method is deprecated and is no longer supported. |
TextRecognitionParams | TextType | Type changed | This property now takes an integer value which is an OR superposition of TextTypeEnum constants which correspond to assumed types of the text.
 | Removed | The functionality provided by this property is now covered by the TextType property. |
TextTypeEnum | TT_ToBeDetected | Removed | This constant is no longer needed, as it can be replaced by the OR combination of all the others.
 | Added | This is a new constant, for the type of text frequently used in fax machines. |
cicon2 Image-related objects

Object/Enumeration

Property/Method/Constant

What has happened?

Comment

Image

WriteToFile

The number of input parameters has been changed.

The method takes as input parameter the JpegExtendedParams object, which specifies the parameters of saving to JPEG format.

Output parameters number changed.

The handle to the output bitmap is returned as the Handle object

ImageProcessingTools

CorrectOrientationByText

Removed

Use the following procedure instead:

1.Detect orientation of the image using the DetectOrientationByText method instead. This method does not rotate the image. The method returns a RotationTypeEnum constant.

2.Pass the constant to the IImageProcessingTools::RotateImageByRotationType method to rotate the image.

Parameters changed

The pointer to a memory buffer containing image data is passed as __int64.

Output parameters number changed.

The handle to the memory buffer is returned as the Handle object.

Parameter renamed

The new name of the parameter HslHew is HslHue.

Removed

This method is deprecated and is no longer supported.

ImageDocument

SaveImageDocToMemory

Renamed, parameters changed

The new name of this method is SaveToMemory. The handle to the memory buffer is returned as the Handle object.

Renamed

The new name of the method is SaveTo.

Renamed

The new name of the property is IsSkewCorrected.

JpegExtendedParams

SaveToMemory

Output parameters number changed.

The handle to the memory buffer is returned as the Handle object.

Parameters changed

The pointer to a memory buffer containing image data is passed as __int64.

ImageTypeEnum

IT_Deskewed

Renamed

The new name of the constant IT_Modified.

ImageCompressionTypeEnum

ICT_J2k

ICT_JBIG2

ICT_PDF

Removed

Use the new ICT_Default constant instead. Suitable compression type will be selected automatically.

Added

This is a new constant, which allows you to select compression type automatically for all image formats but TIFF.

Removed

The constant is no longer supported.
cicon2 Export parameter objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ExportParams | DeleteExportedDocuments | Removed | This functionality is no longer supported in ABBYY FlexiCapture Engine. In ABBYY FlexiCapture this setting is an attribute of a batch type.
FileExportParams | FileAssemblingRule FolderCreationRule | Removed | Use the IFileExportParams::FileNamePattern property instead.
FileAssemblingRuleEnum FolderCreationRuleEnum |  | Removed | These constants are no longer in use. Corresponding properties have been removed.
ImageFileAssemblingRuleEnum | IFAR_SingleFile | Removed | This functionality is no longer supported in FlexiCapture Engine technology. You can use other ways of saving images.
ProjectProperties | ExportParams | Behavior changed | The property becomes read-only.
cicon2 Import parameter objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ImageLoadingParams | DeleteOriginalImages ProcessedImagesFolder InvalidImagesFolder | Removed | Similar properties are available in the HotFolderProfile object.
cicon2 Text-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
CharParams | LanguageName | Removed | Use the LanguageId instead.
cicon2 Language-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
EnumDictionaryWords | Dictionary | Removed | The property is no longer supported. The reference to the parent Dictionary object cannot be obtained.
Dictionary | Edit | Removed | The method is no longer supported. Use the Delete and Add methods for editing.
cicon2 Scanning-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
ScanPaperSizeEnum | SPS_A6 SPS_A7 SPS_A8 | Added | These are new constants for more page size types.
cicon2 Supplementary objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
LongsCollection |  | Renamed | The new name of the object is IntsCollection.
IntsCollection StringsCollection | Insert | Renamed | The Insert method has been renamed to InsertAt.
Region | SaveToMemory | Output parameters number changed. | The handle to the output bitmap is returned as the Handle object
 | Parameters changed | The pointer to a memory buffer containing image data is passed as __int64. |
cicon2 Verification-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
VerificationObject | ContextImage | Type changed | The property has the __int64 type.
GroupVerificationObject | Image | Type changed | The property has the __int64 type.
cicon2 Error objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
AssemblingErrorTypeEnum | AET_WrongItemsOrder | Removed | This constant is no longer in use. Corresponding error type cannot be returned by FlexiCapture Engine.
cicon2 License-related objects
Object/Enumeration | Property/Method/Constant | What has happened? | Comment
License | IsAbsoluteTimeLimitationUsed IsRelativeTimeLimitationUsed RelativeDays | Removed | This properties of the license do not make sense any more.
AFCEM_ Prefixed Flags | AFCEM_Arabic | Added | This is a new constant of the AFCEM_ prefixed flags.
ATT_ Prefixed Flags | ATT_Fax | Added | This is a new constant of the ATT_ prefixed flags.
 | Removed | The constant was not in use in ABBYY FlexiCapture Engine and made sense only in ABBYY FineReader Engine. |

See also

Specifications

ABBYY FlexiCapture Engine 12 and 10.5 Compatibility


Documentation Changes

Specifications >

Documentation Changes

This section contains the list of changes that have been made to documentation since the latest release.

Documentation section

What has changed

Comment

Developer's Help and User's Guide

Guided Tour

Integration with ABBYY FineReader Engine

ABBYY FlexiCapture Engine 12 is compatible with ABBYY FineReader Engine 12 now.

API Reference

GetEngineLoader

This is a new function for unified loading of the IEngine object with the help of pre-configured IEngineLoader object.

InitializeEngine
InitializeEngineEx

The functions are deprecated and will be removed in future versions.

Engine loaders

IEngineLoader::AppDataPath
IEngineLoader::CustomerProjectId
IEngineLoader::LicensePassword
IEngineLoader::LicensePath

The new properties of the IEngineLoader object for tuning the parameters of Enging initialization.

IEngineLoader::GetEngine

The new method for getting a pointer to the IEngine interface. The method is unified for use with all license types, including Cloud License.

IEngineLoader::Load

The method is deprecated and will be removed in future versions.

Document structure objects

IDocument::AsCustomStorage
IDocument::AsField
IDocument::AsUndoable

These are the new properties for the documents converting.

Export Parameters Objects

PdfAModeEnum
IImageExportParams::PdfAMode

These are a new enumeration and property for tuning image export to PDF/A format.

IImageExportParams::EnableFastWebView

The new property that specifies if exported PDF file is set to Fast Web Viewing.

IImageExportParams::WriteTaggedPdf

This new property specifies if the image should be exported to tagged PDF.

TextEncodingTypeEnum

A new constant TET_UTF8_WoBOM was added. This constant means that the encoding type of a file is the UTF-8 format without the byte order mark (BOM) at the start of the text stream.

ImageExportParams::OverwriteFiles

This property is not used and will be removed in future versions. Overwriting of the original image can be tuned with the FileOverwriteRule property of the FileExportParams.

FlexiCapture Processor

ClassConfidence
ClassConfidences
IClassificationResult::Classes
IClassificationResult::IsConfident

The new interfaces and properties for detailed work with classification results.

IFlexiCaptureProcessor::AddImageDocument

The method that adds a preprocessed image to the internal processing queue.

Import Parameters Objects

IImageLoadingParams::ReduceISONoise
IImageLoadingParams::RemoveColorMarks
IImageLoadingParams::TreatImageAsPhoto
IImageLoadingParams::UseAutocrop
IImageLoadingParams::WhitenBackground

The new properties for image preprocessing tuning.

SourceContentReuseModeEnum
IImageLoadingParams::SourceContentReuseMode

This functionality allows to set the mode of source PDF file contents reusing.

IImage::Close
IImageFile::Close

These are the new methods for reclaiming the memory occupied by the images.

License-Related Objects

AFCEM_Classification

The new Classification module.

Errors objects

IRuleError::Fields

This property can now be changed by your code.

Specifications

Barcode Types

The new barcode types are now supported: AustraliaPost, Code 32, IntelligentMail, MaxiCode.

Predefined Languages in ABBYY FlexiCapture Engine

New predefined languages are now supported: Burmese, Farsi, Georgian, JapaneseModern.

System Requirements

ABBYY FlexiCapture Engine can now be run in a Docker container on supported platforms.


Frequently Asked Questions

No topics above this level

Frequently Asked Questions

Using the Engine object

cicon2 What should I do if I have got problems creating the Engine object in C#.NET?

If you use the InitializeEngine (InitializeEngineEx) function, you must make sure to specify [STAThread] (single-threaded apartment model) оr [MTAThread] (multi-threaded apartment model) as an attribute on your application's main function:

[STAThread]
public static void Main()
{
...
}

Is is recommended to use the [STAThread] because it is now more accepted.
cicon2 How to work with read-only object properties in raw C++?

Certain ABBYY FlexiCapture Engine objects have read-only object properties. Such properties cannot be changed directly in raw C++. If you want to change such a property, you need to pass a reference to the property object to a new variable, and then use this variable to change it. Below you can see a C++ sample for the IProject::Batches property which is represented by a read-only collection:

IProject* pProject = 0;
IBatches* pBatches = 0;
IBatch* pBatch = 0;
...
// The pBatches variable receives a reference to the batches collection from the Project
pProject->get_Batches( &pBatches );
// Add one more element to the batches collection
pBatches->AddNew( L"BatchName", &pBatch );
...
cicon2 What should I do, if an “access to remote object” error occurs when accessing one of the FlexiCapture Engine objects?

Make sure that parent objects of this object have not been released before the method which leads to the error is called. Pointers to child object's interfaces are valid until their parent objects exist. An attempt to access a child object after its parent object has been destroyed may result in error. Please see Working with Properties for details.
cicon2 Is it possible to run and use Engine object in several threads?

Yes, it is possible. You should use the InprocLoader or OutprocLoader object when creating the Engine object. See Different Ways to Load the Engine Object for details.

If you use the InitializeEngine (InitializeEngineEx) function for loading, using Engine object in several threads is impossible. In this case the methods of all ABBYY FlexiCapture Engine objects should be called only from the thread in which Engine object was created. See also Step 1: Load FlexiCapture Engine.
cicon2 Is it possible to create and run the Engine object on a multi-processor system?

Yes, it is possible. You should use the OutprocLoader object when creating the Engine object. See Different Ways to Load the Engine Object for details.
cicon2 What should I do if the “Engine deinitialization failed” exception is thrown during deinitialization of the Engine object?

This exception is thrown if not all the objects which were created and used by the application have been deleted before the Engine object deinitialization. If all the objects have been deleted the exception may be caused by the scavenger operation. If the application is developed in Visual Basic .Net, all objects with the Nothing value are not deleted, they are only marked for deletion. The exact moment when the garbage collector deletes the object is not known. Therefore, you should call the following methods before the deinitialization of the Engine object so that the garbage collector deletes the object:

GC.Collect()
GC.WaitForPendingFinalizers()

If the application is developed in Delphi, see the Using ABBYY FlexiCapture Engine in Delphi section.

You can use the StartLogging method of the Engine object to get a list of objects that have not been deleted.
cicon2 How can I create a log file to keep track of all errors, warnings and method calls of ABBYY FlexiCapture Engine?

To do this, you need to call the StartLogging method of the Engine object. As input parameters, specify the log file name and the Boolean variable which determines whether method calls messages should be logged or not. Once you have called this method, all messages will be logged. To stop logging, call the StopLogging method of the Engine object.
cicon2 What should I do if a message saying “A reference to FCEngine.tlb could not be added” appears in .NET development tools?

This may happen if for some reason the type library has not been registered properly. In this case you can register the library manually:

1.From the command line, use the Regtlib utility together with the full path to the FCEngine.tlb type library.

2.Then try to add the FCEngine.tlb library as a reference to your project again.

Data capture-related questions

cicon2 Is it possible to modify Document Definitions using ABBYY FlexiCapture Engine 12?

Document Definitions can be modified only with the help of ABBYY FlexiCapture or ABBYY FlexiLayout Studio.

cicon2 I am processing several batches of images, and each of these batches requires different set of Document Definitions. How should I use FlexiCapture Processor in this situation?

FlexiCaptureProcessor is a “one-time” object and has no methods to change the Documents Definitions set associated with the object. It means that the object could be created, used with a specific set of Document Definitions and destroyed afterwards. In order to process a few different set of documents (with different set of Document Definitions), you need to create a new FlexiCaptureProcessor object for each documents set:

1.Create a new FlexiCaptureProcessor object.

2.Add needed Document Definitions.

3.Process the documents.

4.Destroy the FlexiCaptureProcessor object.
cicon2 How can I identify a page as “Unprocessed” or “Unknown” in ABBYY FlexiCapture Engine 12?

In ABBYY FlexiCapture 12 such definitions as “Unprocessed” and “Unknown” pages exist. “Unknown” page is a page that has been processed but none of the Document Definitions has matched the page; “Unprocessed” page is a page that has been added to the batch, but has not been processed yet.

ABBYY FlexiCapture Engine 12 defines page types differently. All possible types of pages are described in the PageTypeEnum enumeration constants:

·PT_Unknown corresponds to “Unprocessed” page in terms of ABBYY FlexiCapture 12

·PT_Delimeter — documents delimiter

·PT_MeetsDocumentDefinition — analyzed page for which some page definition was applied

·PT_Attachment — annex page
cicon2 When a document has assembly errors, ABBYY FlexiCapture 12 shows information about the correct structure of the document (including the information if the document should contain some annex pages and how many). How can I get this information from ABBYY FlexiCapture Engine 12?

It is not possible to get exactly the same information as shown in ABBYY FlexiCapture 12. To get the information on possible document’s assembly errors, you can use AssemblingError object.
cicon2 How can I increase the speed of processing with ABBYY FlexiCapture Engine?

The speed of processing depends on the quality of images and on the settings used during processing. Refer to Increasing Processing Speed.

Licensing and distribution

cicon2 Is there a special installation program for distribution ABBYY FlexiCapture Engine on a workstation?

ABBYY FlexiCapture Engine 12 does not have special installation program for distribution. You can install the ABBYY FlexiCapture Engine library on a workstation in automatic mode from the command line, or install it manually by copying the necessary files. See Distribution of Applications Which Use the ABBYY FlexiCapture Engine Library for details.
cicon2 What license is required for compiling an application?

The functions which load the Engine require Customer Project ID which will be shared by all Developer and Runtime licenses. You need only the correct Customer Project ID for your application to work with corresponding Developer and Runtime licenses. See Distribution of Applications Which Use the ABBYY FlexiCapture Engine Library.
cicon2 What license is required for activating ABBYY FlexiCapture Engine on a workstation?

You should activate a Runtime License on the workstation. See Distribution of Applications Which Use the ABBYY FlexiCapture Engine Library.
cicon2 What ABBYY FlexiCapture Engine files should be copied on a workstation?

Files marked as “mandatory” in the table of the ABBYY FlexiCapture Engine Distribution Kit section. They are system modules and main recognition databases.

·Recognition databases for handprinted text, if you want to recognize handprinted text.

·Resource files for interface languages that will be used in your application.

·Dictionary support files for recognition languages that your application will support. If the recognition languages include languages with the Latin alphabet, make sure that you copy the Univers.amd and Univers.amm files.

·Scanning modules and scanning-specific resources if your application will perform scanning via the ABBYY FlexiCapture Engine interface.

·FineReader Engine modules, if your application will use FineReader Engine functionality.

All the files must be copied to the same folder, if otherwise is not stated.

See also Installing the ABBYY FlexiCapture Engine Library in Manual Mode and ABBYY FlexiCapture Engine Distribution Kit.
cicon2 Which folders should be accessible from the workstation?

The following registry branches should be accessible from the workstation:

·HKEY_CURRENT_USER\Software\ABBYY\SDK\12\FlexiCapture Engine — full control

·HKEY_CURRENT_USER\Software\ABBYY\SDK\12 — full control for installation only

·HKEY_LOCAL_MACHINE\Software\ABBYY\SDK\12 — full control for installation only

The following folders should be accessible from the workstation:

·Folder with ABBYY FlexiCapture Engine binary files — access for reading

·%TEMP% folder — full control access

See Installing the ABBYY FlexiCapture Engine Library.
cicon2 The application runs on a workstation with an activated Runtime License. The message saying “ABBYY FlexiCapture Engine is not licensed” is displayed. What should I do?

Please, make sure that the Runtime License you are using has the same Customer Project ID that is passed to the methods which load FlexiCapture Engine as one of the input parameters. Make sure that the Customer Project ID used by the methods is correct.

See also Licensing, Distribution of Applications Which Use the ABBYY FlexiCapture Engine Library.

If you cannot find the answer to your question, please contact the ABBYY Technical Support.


Contact ABBYY

No topics above this level

Contact ABBYY

In this section you can find the contacts of ABBYY sales offices and technical support:

·How to Buy

·Technical Support


How to Buy ABBYY FlexiCapture Engine 12

Contact ABBYY >

How to Buy ABBYY FlexiCapture Engine 12

You can order ABBYY FlexiCapture Engine by contacting our offices at the following addresses:

·ABBYY Russia: engine@abbyy.com

·ABBYY USA: sales@abbyyusa.com

·ABBYY Europe: engine_eu@abbyy.com

·ABBYY Ukraine: engine@abbyy.ua

You can purchase additional language support applications and fonts at www.paratype.com/shop.


Technical Support

Contact ABBYY >

Technical Support

If you have any questions regarding the use of ABBYY FlexiCapture Engine, first of all consult the documentation provided with this product (this Developer's Help and the Readme file). Useful information can also be found in the technical support section of our Web site at www.abbyy.com.

If you cannot find the answer to your question, please contact the ABBYY office serving your region by e-mail. Please provide the following information when contacting technical support:

·your first and last name;

·the name of your organization;

·your phone number (or fax, or e-mail);

·the serial number of your ABBYY FlexiCapture Engine package;

·the protection type of your ABBYY FlexiCapture Engine package (software or hardware);

·the build number (to determine the build number, see Properties in the FCEngine.dll local menu or the Readme.html file);

·a description of the problem;

·a project that demonstrates the problem (with the necessary data files). This may be a slightly modified ABBYY FlexiCapture Engine sample. We recommend that you compress the files using any popular archiving program (WinZIP, WinRAR, etc.);

·the name of your development tool;

·the type of your computer and processor;

·the version of your Windows operating system.

You can gather some of the above mentioned information automatically:

1.Run the AInfo utility (AInfo.exe) from the <Installation folder>/Bin/Support folder.

2.A dialog box will open displaying available information. Save this information to a ZIP file.

note Note: No personal information or information about the user’s computer is collected. You can view all the saved information in the created archive.

You can also provide any additional information you consider important.

Support contacts

North/Central Americas | Customers from USA, Canada, Japan, Mexico or other Central American countries, please contact ABBYY North American Headquarters at dev_support@abbyyusa.com
Western Europe | Customers from Austria, Benelux, Denmark, France, Germany, Italy, Ireland, Norway, Portugal, Spain, Sweden, Switzerland, the United Kingdom or other Western European countries, please contact ABBYY European Headquarters at TechSupport_eu@abbyy.com
Eastern Europe and the Mediterranean | Customers from Ukraine, Moldova, Turkey, Israel or Eastern European countries, please contact ABBYY Eastern European Headquarters at engine_support@abbyy.ua
All other regions | Customers from the countries not mentioned above, please contact ABBYY International Headquarters at SDK_Support@abbyy.com