L_OcrAutoRecognizeManager_RunJobAsync

#include "ltocr.h"

L_LTOCR_API L_INT EXT_FUNCTION L_OcrAutoRecognizeManager_RunJobAsync(autoRecognizeManager, autoRecognizeJob)

Runs a job asynchronously.

Parameters

L_OcrAutoRecognizeManager autoRecognizeManager

Handle to the OCR engine auto recognize manager.

L_OcrAutoRecognizeJob autoRecognizeJob

Handle to the OCR engine auto recognize job.

Returns

Comments

This method will create an internal worker thread and return control immediately to the caller. When the job is completed, you can call L_OcrAutoRecognizeJob_GetErrors to get any errors that might occurred during the recognition process. To get notification when the job is completed (whether successfully or with aborted due to errors or through user action), use the L_OcrAutoRecognizeManager_SetRunJobCallback method.

To run a job synchronously, use L_OcrAutoRecognizeManager_RunJob.

To use this method, initialize a new L_OcrAutoRecognizeJobData structure with the job's parameters (input image file name, pages, output document format, output document name, optional zones file name, etc.), then use L_OcrAutoRecognizeManager_CreateJob to create the L_OcrAutoRecognizeJob handle passed as job handle to this method. Finally, call L_OcrAutoRecognizeManager_RunJob passing the L_OcrAutoRecognizeJob handle.

This method will perform the following operations:

1. The L_OcrAutoRecognizeRunJobCallback callback will be fired to indicate that job just started.
2. Creates one ore more L_OcrPage. The number of created OCR pages conforms to the following formula: MIN(8, maximum CPUs/cores), so if you have more than 8 cores on your machine only 8 threads will be created but if you have less that 8 cores then that number will be used to determine the number of threads to be created to participate in the recognition process. Also the internal created OCR document will be created as disk-based.

3. Loops through the pages specified in L_OcrAutoRecognizeJobData.FirstPageNumber and in L_OcrAutoRecognizeJobData.LastPageNumber in L_OcrAutoRecognizeJobData.ImageFileName and for each page:
   1. The page is created using L_OcrPage_FromBitmap after we load the file into BITMAPHANDLE.
   2. If L_OcrAutoRecognizeJobData.ZonesFileName contains a valid multipage zone file name and has an entry for the current page, then the zones are loaded with L_OcrPage_LoadZonesFile and applied to the page. If L_OcrAutoRecognizeJobData.ZonesFileName is a NULL or is empty string or it does not contain an equivalent page number, auto-decomposing of the page is performed instead with L_OcrPage_AutoZone.
   3. L_OcrPage_Recognize is called to get the OCR data of the page.
   4. The page is added to the internal OCR document using L_OcrDocument_AddPage.

4. When all pages are processed they will be saved to result file name specified in L_OcrAutoRecognizeJobData.DocumentFileName using the format specified L_OcrAutoRecognizeJobData.Format.

5. All OCR documents and temporary files are deleted.
6. The L_OcrAutoRecognizeRunJobCallback callback will be fired to indicate that the job has completed or aborted.
7. You can use the L_OcrAutoRecognizeJobOperationCallback to get information regarding the current operation being performed. For more information and an example, refer to L_OcrAutoRecognizeManager_SetJobOperationCallback.

The L_OcrAutoRecognizeManager also has some options that you can control, For more information about these options, refer to L_OcrAutoRecognizeManager_GetOptions and L_OcrAutoRecognizeManager_SetOptions.

Required DLLs and Libraries

• LTOCR
• For a listing of the exact DLLs and Libraries needed, based on the toolkit version, refer to Files To Be Included With Your Application.

/* Structure used for the callback function's user data */ 
typedef struct tagJOBCBPARM 
{ 
   L_OcrAutoRecognizeManager AutoRecognizeManager; 
   L_BOOL jobCompleted; 
} JOBCBPARM, * LPJOBCBPARM; 
 
static L_INT EXT_CALLBACK runJobCB(const L_OcrAutoRecognizeRunJobCallbackData* data, L_VOID* userData) 
{ 
   JOBCBPARM* param = (JOBCBPARM*)userData; 
   param->jobCompleted = data->IsCompleted; 
 
   if(data->Status == ERROR_USER_ABORT) 
   { 
      L_OcrAutoRecognizeManager_AbortAllJobs(param->AutoRecognizeManager); 
      param->jobCompleted = L_TRUE; 
   } 
 
   return SUCCESS; 
} 
 
L_INT L_OcrAutoRecognizeManager_RunJobAsyncExample() 
{ 
   L_INT retCode = -1; 
   L_OcrEngine ocrEngine = NULL; 
   L_OcrAutoRecognizeManager autoRecognizeManager = NULL; 
 
   // Create an instance of the engine 
   retCode = L_OcrEngineManager_CreateEngine(L_OcrEngineType_Advantage, &ocrEngine); 
   if(retCode != SUCCESS) 
      return retCode; 
 
   // Start the engine using default parameters 
   std::cout << "Starting up the engine...\n"; 
   retCode =L_OcrEngine_Startup(ocrEngine, NULL, OCR_ADVANTAGE_RUNTIME_DIR); 
   if(retCode != SUCCESS) 
      return retCode; 
 
   // Get the AutoRecognizeManager 
   L_OcrEngine_GetAutoRecognizeManager(ocrEngine, &autoRecognizeManager); 
 
   L_OcrAutoRecognizeJob autoRecognizeJob = NULL; 
   L_OcrAutoRecognizeJobData jobData; 
   jobData.StructSize = sizeof(L_OcrAutoRecognizeJob); 
   wcscpy_s(jobData.ImageFileName, MAKE_IMAGE_PATH(L_TEXT("OCR1.tif"))); 
   wcscpy_s(jobData.DocumentFileName, MAKE_IMAGE_PATH(L_TEXT("OCR1.pdf"))); 
   jobData.Format = DOCUMENTFORMAT_PDF; 
   wcscpy_s(jobData.JobName, L"MyJob"); 
 
   // Create the job 
   L_OcrAutoRecognizeManager_CreateJob(autoRecognizeManager, &autoRecognizeJob, &jobData); 
 
   // Create the callback user data to be updated 
   JOBCBPARM userData; 
   userData.jobCompleted = L_FALSE; 
   userData.AutoRecognizeManager = autoRecognizeManager; 
    
   // Run the job in a thread and wait for it to be done 
   // We will use the callback to get notified when the job is finished 
   L_OcrAutoRecognizeManager_SetRunJobCallback(autoRecognizeManager, &runJobCB, &userData); 
 
   std::cout << "Running the job...\n"; 
   L_OcrAutoRecognizeManager_RunJobAsync(autoRecognizeManager, autoRecognizeJob); 
 
   std::cout << "Waiting for the job to complete...\n"; 
 
   while(userData.jobCompleted != L_TRUE) 
   { 
      Sleep(100); 
   } 
 
   std::cout << "Done...\n"; 
 
   //CLEANUP 
   L_OcrAutoRecognizeJob_Destroy(autoRecognizeJob); 
   L_OcrEngine_Destroy(ocrEngine); 
 
   return retCode; 
}