Frequently Asked Questions

ABBYY FineReader Engine 12 provides a special installation utility for distribution. Using this utility you can install the ABBYY FineReader Engine library on a workstation in automatic mode from the command line. You can also install the library manually by copying the necessary files. See Distribution of Applications Which Use the ABBYY FineReader Engine Library.

All the licenses in one project share the same Customer Project ID which is required by the functions that initialize the library. The end user's Runtime License and the software developer's Developer License should correspond to the Customer Project ID passed to these functions.

See also Distribution of Applications Which Use the ABBYY FineReader Engine Library.

You should activate a Runtime License on the workstation. See Activating the ABBYY FineReader Engine Library with the Runtime License.

• Files for the functioning of the modules that your application will support.
• Files marked as "mandatory" in the table of the ABBYY FineReader 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, scanning-specific resources and Twain modules if your application will perform scanning via the ABBYY FineReader Engine interface.
• Visual Components modules and corresponding specific resources, if your application uses ABBYY FineReader Engine Visual Components. Register VisualComponents_dll using regsvr32.exe.

You can also use the FREngineDistribution.csv file to automatically create a list of files required for your application to function.

See Installing the ABBYY FineReader Engine Library in Manual Mode.

Full control permissions for the following folders are required:

• %TEMP% folder
• folder %ProgramData%\ABBYY\SDK\12\FineReader Engine
• folder %ProgramData%\ABBYY\SDK\12\Licenses (required for license server, optional for workstations)

All users running your application should have read&execute and write permissions to:

• %ProgramData%\ABBYY folder.

The following registry branches should be accessible from the workstation:

• "HKEY_CURRENT_USER\Software\ABBYY\SDK\12\FineReader 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

See Installing the ABBYY FineReader Engine Library.

Please make sure that the Runtime License corresponds to the Customer Project ID with which the application was compiled. If the license does not match the Customer Project ID, the application will not work.

Customer Project ID is passed to the methods which load FineReader 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 FineReader Engine Library.

To be able to use processing methods such as IFRDocument::Process, you need a license which includes Processing module. If your license does not support it, you can recognize only barcodes; use the IFRPage::ExtractBarcodes method.

To be able to use processing methods such as IFRDocument::Process, you need a license which includes Processing module. If your license does not support it, you still can recognize barcodes and/or checkmarks using other methods:

• for barcode recognition, you can use the IFRPage::ExtractBarcodes method;
• an OMR license will generally also include Recognition module, which allows you to call such methods as IFRDocument::Recognize, IFRDocument::RecognizePages, IFRPage::Recognize, IFRPage::RecognizeBlocks.

To run ABBYY FineReader Engine in a Docker container, use two separate containers with ABBYY FineReader Engine and the Licensing Service inside.

See the instructions for this scenario in Running ABBYY FineReader Engine 12 inside a Docker container.

You may run your ABBYY FineReader Engine-based application in Azure Cloud Service or Azure App Service. Use the instructions provided in Running ABBYY FineReader Engine in Azure Services.

Use the methods of the ImageDocument object that improve image quality. These methods allow you to select an image region to work with.

ABBYY FineReader Engine provides several ways of correcting the image resolution:

1. During image opening and preparation, managed by the OverwriteResolution and AutoOverwriteResolution properties of the PrepareImageMode object.
   The OverwriteResolution property allows you to change the resolution manually, specifying the horizontal and/or vertical resolution in XResolutionToOverwrite and YResolutionToOverwrite properties.
   The resolution is corrected before any other operations are performed on the image. This method may be helpful when the input image resolution is absent or incorrect (for example, outside the required limits of 50 to 3200 dpi), as such images may not be opened without correcting resolution first.
2. After the image is opened, using the ChangeResolution method of the ImageDocument object.
   You may use the DetectResolution method of the FRPage object to determine the optimal resolution value.
3. During image preprocessing stage (which will, by default, be included in the call to any of the methods which perform full processing of the image), managed by the CorrectResolution property of the PagePreprocessingParams object.
   This method allows only for automatic resolution correction; if you need to assign a specific value use one of the others.

For PDF input files, the resulting images may differ depending on the method used. Working via OverwriteResolution may modify the image size in pixels, so that linear dimensions of the page remain the same. Using ChangeResolution or automatically correcting resolution during preprocessing will not affect the image size in pixels, changing the linear dimensions of the image instead. The processing results for images of different size, even obtained from the same input, may not be the same.

For the images obtained by capturing the computer screen we recommend using settings intended for text extraction. Call the LoadPredefinedProfile method of the Engine object to load one of the predefined profiles:

• TextExtraction_Accuracy — for extracting text from documents, optimized for accuracy
• TextExtraction_Speed — for extracting text from documents, optimized for speed

The resolution of the image that was received from the screenshot must be set to 72 or 96 dpi (depending on the screen resolution).

Note: These recommendations concern digital images which were created using the operating system or software running on the computer. Resolution of the screen photo made by any additional device (i.e., camera) should be from 200 to 300 dpi.

See also Working with Profiles.

If you use the InitializeEngine function for initialization, make sure to specify [STAThread] (single-thread apartment model) as an attribute on your application's main function:

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

See Using ABBYY FineReader Engine in Delphi.

Certain ABBYY FineReader Engine objects (for example, ILayout::Blocks) have read-only object properties. This does not mean that such properties cannot be changed, it 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 ILayout::Blocks property which is represented by a read-only collection:

ILayout* pLayout = 0;
ILayoutBlocks* pLayoutBlocks = 0;
int blockIndex = 0;
// Receive the layout from the previously opened FRPage
pFRPage->get_Layout( &pLayout );
// The pLayoutBlocks variable receives a reference to the blocks collection from Layout
pLayout->get_Blocks( &pLayoutBlocks );
// Remove an element from the block collection
pLayoutBlocks->DeleteAt( blockIndex );
// Work with modified layout
...
// Release the objects
pLayoutBlocks->Release();
pLayout->Release();
        

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 function for loading, using Engine object in several threads is impossible. In this case, the methods of all FineReader Engine objects should be called only from the thread in which Engine object was created.

Yes, it is possible. See Different Ways to Load the Engine Object for details.

This exception is thrown if not all the objects which were created and used by the application have been deleted before the deinitialization of the Engine object. 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: In this environment, 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 deinitializing 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 FineReader Engine in Delphi section.

If you are using the log (it can be turned on with the StartLogging method of the Engine object), the message "Warning: DeinitializeEngine() has detected external references to FREngine objects. It can indicate a leak if programming platform without automatic garbage collection is used." can also appear in this situation. Even if you are explicitly calling the garbage collector (GC.Collect), it does not always mean that the objects are deleted immediately. When working in the environments with garbage collectors, you can disregard this message.

When working in the environments without garbage collection (such as C++), these exception and message can indicate a problem in your source code. Some objects can be incorrectly handled, causing a memory leak. However, after Engine deinitialization all FineReader Engine objects will be deleted in any case, so the memory leak can occur in the client part of the code, i.e., if you create your own wrappers for the FineReader Engine objects and fail to release them before the deinitialization.

Consider using the TotalObjectsCount property of the Engine object which returns the number of unreleased objects and can help you track down the memory leak.

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 call 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.

Normally you do not need to register FREngine.dll. The library is registered automatically during the Developer installation or the Runtime installation with the default parameters.

However, if for some reason you need to register FREngine.dll after installation (during the Runtime installation you have specified RegisterCOM=No), use the following command line:

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

English is the default recognition language. If you want to change the default recognition language, you must use the SetPredefinedTextLanguage method of the RecognizerParams object.

If a block contains text of different types, ABBYY FineReader Engine will still treat it as text of the same type. To improve the quality of OCR, draw a separate block for text of each type.

See also Using Text Type Autodetection.

If the TextTypes property of the RecognizerParams object contains any combination of TT_Matrix, TT_Typewriter, TT_OCR_A, and TT_OCR_B, then italic fonts and superscript/subscript will not be recognized, regardless of the values of the ProhibitItalic, ProhibitSubscript and ProhibitSuperscript properties of the RecognizerParams object.

See also Using Text Type Autodetection.

The CharConfidence property of the PlainText and CharacterRecognitionVariant objects is a read-only int property that provides an accuracy estimate of the character image recognition. The IsSuspicious property of the CharParams object is a Boolean property which, when set to TRUE, indicates that the character was recognized unreliably. CharConfidence estimates accuracy with no regard for the character's context, while reliability (IsSuspicious) is based on both recognition accuracy and the context — for example, dictionary analysis of the word to which a character belongs.

When recognizing a character, the ABBYY FineReader Engine provides several recognition variants with a confidence value for each. This value is an internal estimate of the probability that a variant is correct — that is, in fact, the recognized image does represent this character variant. For example, an image of the letter "e" may be recognized:

• as the "e" character with a confidence of 95,
• as the "c" character with a confidence of 85,
• as the "o" character with a confidence of 65, and so on.

Confidence values are in the range from 0 to 100. If a character was obtained not as a result of recognition, its confidence is set to 100 — for example, the confidence of a character extracted directly from the source PDF file.

Note that the confidence should not be understood as a general recognition quality measure. Confidence estimates for different characters are incomparable, and the only safe use of confidence is for comparing several recognition variants of the same image (character). Moreover, higher confidence of a recognition variant does not guarantee that the variant will be selected as the recognition result. This choice depends on the context (the word to which a character belongs) and the results of a differential comparison. For example, if the word with "e" (confidence 95) is not a dictionary word while the word with "c" (confidence 85) is a dictionary word, the latter is selected as the recognition result, even though its confidence is lower.

The selected recognition result may then be marked as suspicious using the IsSuspicious property of the CharParams object. This property is determined by an algorithm that estimates reliability taking into account a number of parameters, such as recognition confidence of the selected variant, confidence of character's other variants, nearby characters and confidence of their recognition variants, geometric parameters of the character, and the character's context (word). If the reliability estimate is lower than a certain threshold, the IsSuspicious property for this character is set to TRUE. Such suspicious characters are highlighted in the ABBYY FineReader.

Make sure that you have set the SaveCharacterRecognitionVariants or SaveWordRecognitionVariants properties of the RecognizerParams object to TRUE. These properties specify whether the variants of characters or words recognition must be saved. See also Using Voting API.

The speed of processing depends on the quality of images and on the settings used during processing. To increase the speed of processing, you can also turn off some unnecessary functionality. Refer to Increasing Processing Speed.

For exporting large documents to PDF, we recommend using the ExportFileWriter object, which provides functionality for saving the recognized data in portions. This new export mode works about 4 times faster with large documents than the processing with standard export.

See details in the Exporting Large Documents section.

To effectively recognize tables without designated borders, you have to set the AggressiveTableDetection property of the PageAnalysisParams object to TRUE. This property activates tables detection mode and improves the analysis quality.

There are two scan log files: scantwain.txt and scanwia.txt. They are stored in the %userprofile%\AppData\Local\ABBYY\ScanManager\12.00 folder.

You can use the ScanSettings property of the ScanSource object to access to the ScanSourceSettings object. This object provides access to the scanning settings of a source.

See details in the description of the Scanning scenario.

PDF versions supported for export are enumerated by the PDFVersionEnum.

Note that the version should not conflict with the specified export parameters. The earliest version of the PDF file which matches the specified parameters of export should be selected as the version of the PDF file:

• The earliest file version available is 1.3.
• The PDF file version should be 1.4, if:
• the PDFAComplianceMode property of the PDFExportParams object is PCM_Pdfa_1a or PCM_Pdfa_1b
• The PDF file version should be 1.4 or higher, if:
• at least one of the PermissionFillFormFields, PermissionExtractTextAndGraphicsExt, PermissionAssembleDoc, PermissionPrintExt properties of the PDFEncryptionInfo object is TRUE, or
• the encryption key length exceeds 40 bits (see the KeyLength property of the PDFEncryptionInfo object), or
• the WriteTaggedPDF property is TSPV_Yes, or
• the WriteXmpMetadata property is TSPV_Yes, or
• the BwPictureFormats property of the PDFPictureCompressionParams is BWPF_JBIG2 or BWPF_JBIG2Lossless.
• The version should be 1.5 or higher, if
• the ColorPictureFormats property of the PDFPictureCompressionParams is CPF_J2K, or
• the GrayPictureFormats property of the PDFPictureCompressionParams is GPF_J2K.
• The version should be 1.6 or higher, if:
• the EncryptionAlgorithm property of the PDFEncryptionInfo object is PDFEA_AES128, or
• OpenType fonts are used in output PDF file.
• The version should be 1.7 or higher, if:
• the EncryptionAlgorithm property of the PDFEncryptionInfo object is PDFEA_AES256.
• The latest file version available is 2.0.

See also PDFExportFeatures.