Skip to main content

​
Licensing and distribution

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 handwritten/handprinted text, if needed.
  • 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.
  • Windows canning modules, scanning-specific resources and Twain modules if your application will perform scanning via the ABBYY FineReader Engine interface.
  • Windows 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
No, it is not necessary, and it is a proper way to limit full access for ‘Everyone’ so an unauthorized user is not allowed to modify. It is enough to have ‘Read’ access only for ‘Everyone’ group.
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.
Please check the permissions granted to the folder %ProgramData%\ABBYY\SDK\12\Licenses with the following command line:
ls -l /var/lib/ABBYY/SDK/12 | grep Licenses
chmod 777 /var/lib/ABBYY/SDK/12/Licenses
If the command line returns a value other than drwxrwxrwx, the folder %ProgramData%\ABBYY\SDK\12\Licenses lacks several permissions.To grant full access permissions to the folder %ProgramData%\ABBYY\SDK\12\Licenses, perform the following command line:
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:
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.
Image-related questions
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. 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.
  2. 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 OverwriteResolutionMode property of the PagePreprocessingParams object. The resolution can be corrected automatically or set to the value specified in the ResolutionToOverwrite property.
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).
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.

​
Using the Engine object

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()
{
  ...
}
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 C++ (C++ raw if Linux), 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 Windows using 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 deinitializing the Engine object so that the garbage collector deletes the object:
    GC.Collect()
    GC.WaitForPendingFinalizers()
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.
After recognizing the target document, you may export it to XML format. The XML schema using in ABBYY FineReader Engine allows you to receive all needed information about the processed text and its structure, attributes, and recognition variants.
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.
To find out if a character was recognized unreliably and needs verification, use the IsSuspicious property of the PlainText or CharParams objects for the given character. It is calculated based on ErrorProbability.To implement more fine-grained distinctions, you can use the ErrorProbability property of the PlainText or CharParams objects, which returns the estimated probability (in range from 0 to 100) that the character was recognized incorrectly. It takes into account the context in which the character is found, for example, whether the word with this character is found in the dictionary.You can also get the character confidence, both for a recognized character (the CharConfidence property of the PlainText object) and for all recognition variants (the CharConfidence property of the CharacterRecognitionVariant object). The confidence provides an accuracy estimate based only on the image of one character, without considering the context. 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).None of these properties make sense for symbols obtained without recognition, for example, those taken directly from the source PDF file.
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.
If your operating system is macOS 10.15 Catalina or above, do the following steps (in this instruction we use the Font Book application):
  1. Find the folder with the fonts (right-click the desired font - Show in Finder).
  2. Install the local fonts from the found folder:
  • Open the application settings (Preferences).
  • Set the Default install location property to Computer.
  • Click the ’+’ button on the toolbar (or use File - Add fonts).
  • Select the folder from step 1.
  • Click the ‘Open’ button. Note, that during fonts installation you need to enter the user password.
Alternatively, you may copy the fonts from the folder in step 1 to /Library/Fonts folder.If you do not plan to install the fonts, but want to use them in ABBYY FineReader Engine, set the Folder property of the CustomFontSet Object.
There are two scan log files: scantwain.txt and scanwia.txt. They are stored in the %userprofile%\AppData\Local\ABBYY\ScanManager\12.00 folder.
Scan is currently implemented only in Windows.
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.
Scan is currently implemented only in Windows.
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:
  • The version should be 1.5 or higher, if
  • 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 latest file version available is 2.0.
See also PDFExportFeatures.
Depending on how you intend to use the fonts, you need to register them in the operating system or add to your application before launching it using one of the following methods:
  • copy the fonts manually into the Data/Resources/Font folder in your ABBYY FineReader Engine-based application.
  • copy the fonts manually into /usr/share/fonts system folder.
  • install the package for the installation of the fonts, depending on your operating system.
See Working with Fonts for details.
If you cannot find the answer to your question, please contact the ABBYY Technical Support.