vvxtrSample.cc

Go to the documentation of this file.

#include <vvocr/vvxtrFactory.h>

#include <string>
#include <ios>
#include <iostream>
#include <fstream>

#include <signal.h>

//#include "stdio.h"            // These headers are used, but are included through vvxtrFactory.h
//#include <vvocr/vvxtrAPI.h>
//#include <vvutil/vvLog.h>

using std::ios;
using std::string;
using std::cout ;
using std::cerr ;
using std::endl ;


// Global variables

string g_remoteEngine ;
vvEngAPI * g_xtrEngine = NULL ;


// Prototypes

// Create an engine
vvEngAPI * CreateEngine();

// Main example routine
vvxtrStatus runOCR(vvEngAPI * xtrEngine);

// Process one document, from input to output
vvxtrStatus processOneDocument(vvEngAPI * xtrEngine);

// Open an input image file
vvxtrStatus openImageDocument(vvEngAPI * xtrEngine, char * inputFilename);

// Run preprocessing and recognition the currently loaded page of image data
vvxtrStatus processOnePage(vvEngAPI * xtrEngine);

// Output a document
vvxtrStatus outputDoc(vvEngAPI * xtrEngine);

// Output an subimage
vvxtrStatus outputImg(vvEngAPI * xtrEngine);

// Exit and error handling
void CloseDown();
void SigTermHandler(int param);
void SigErrorHandler(int param);



// Program entry point

int main (int argc, char ** argv)
{
    // Set up exit and error handling.
    atexit(CloseDown);

    signal(SIGTERM,SigTermHandler);
    signal(SIGINT,SigTermHandler);
    signal(SIGQUIT,SigTermHandler);
    signal(SIGSEGV,SigErrorHandler);
    signal(SIGBUS,SigErrorHandler);

    // Status returned from OCR engine calls
    int status;

    // Set the log level:
    //
    // If you are having serious trouble and don't mind being overrun with log messages,
    // you can set the log level to:
    //
    //  vvLogSetLevel(1000);
    //
    // Otherwise, it works well to set the log level to print error messages
    // only, unless the environment variable VV_DEBUG indicates otherwise:
    int level = VVLOG_ERROR ;
    char * debug = getenv("VV_DEBUG");
    if (debug)
    {
        level = atoi(debug);
    }
    vvLogSetLevel(level);

    if (argc==2)
    {
        // The first argument describes where to find the ocrxtrdaemon.
        g_remoteEngine = argv[1];

        // Instantiate an engine object.
        g_xtrEngine = CreateEngine();
        if (g_xtrEngine==NULL)
        {
            cerr << "Error creating engine" << endl ;
            status = -1;
        }
        else
        {
            const char * version ;

            // Print library and ocrxtrdaemon versions.
            
            g_xtrEngine->vvGetVersion(vvRemote, &version);
            cout << "Remote ocrxtrdaemon version number : " << version << endl ;
            
            g_xtrEngine->vvGetVersion(vvLocal, &version);
            cout << "Local client library version : " << version << endl ;

            // Run the sample program.
            
            status = runOCR( g_xtrEngine );
        }
    }
    else  // Handle an invalid number of parameters.
    {
        cout << "Usage: " << argv[0] << " host[:port]" << endl ;
        status = -1 ;
    }

    // Print returned error codes.
    if (status != VV_OK)
    {
        if (g_xtrEngine)
        {
            cerr << "Error: Status code " << status << ", which indicates " << g_xtrEngine->vvGetStatusString(status) << endl ;
            cerr << "Last server message was: '" << g_xtrEngine->vvGetStatusString() << "'" << endl ;
        }
        else
        {
            cerr << "Error: Status code: " << status << endl ;
            cerr << "Probably failed to connect with " << argv[1] << endl ;
        }
    }

    // Clean up and finish.
    if (g_xtrEngine != NULL)
    {
        delete g_xtrEngine;
        g_xtrEngine = NULL;
    }
    return status;
}

vvEngAPI * CreateEngine()
{
    return vvxtrCreateRemoteEngine(g_remoteEngine.c_str());
}

vvxtrStatus runOCR(vvEngAPI * xtrEngine)
{
    char response [40];
    char inputFilename [200];
    char inputSource [40];

    // If the daemon runs on the same filesystem as the client program,
    // communication will be much faster if we set this hint.
    //
    // Do not set this hint if you are running the ocrxtrdaemon on
    // a separate filesystem from the client program.
    vvERROR(xtrEngine->vvSetHint(vvHintLocalFilesystem));
    

    // Initialize the engine first.
    cout << ".... initializing the engine instance" << endl ;
    vvERROR(xtrEngine->vvInitInstance());

    // Start an OCR session to process a batch of input documents.
    // Some training takes place automatically within one OCR
    // session, so images processed in one session should come
    // from the same source.  See vvEngAPI::vvStartOCRSes.
    cout << ".... starting the OCR session" << endl ;
    vvERROR(xtrEngine->vvStartOCRSes());

    // Initialize the engine values.
    cout << ".... initializing the engine values" << endl ;
    vvERROR(xtrEngine->vvInitValues());


    // Set preprocessing and output options.
    cout << ".... setting preproessing and recognition options\n";
    vvERROR(xtrEngine->vvSetValue(dm_pp_auto_segment, vvYes));
    vvERROR(xtrEngine->vvSetValue(dm_pp_segment_lineart, vvYes));
    vvERROR(xtrEngine->vvSetValue(dm_format_analysis, vvYes));


    // Process an arbitrary number of input document images.
    strcpy( response, "y" );
    while ( strcmp(response, "y") == 0 )
    {
        vvERROR( processOneDocument(xtrEngine) );

        cout << "Process another input file? [y|n]" << endl << "> " ;
        std::cin >> response;
    }


    // End the OCR session.
    cout << ".... ending the OCR session" << endl ;
    vvERROR( xtrEngine->vvEndOCRSes() );

    // End the OCR engine instance.  At this point, nothing else can
    // be done unless the engine is initialized again.
    cout << ".... ending the engine instance" << endl ;
    vvERROR( xtrEngine->vvEndInstance() );

    return VV_OK;
}

vvxtrStatus processOneDocument(vvEngAPI * xtrEngine)
{
    // Open an input image document.
    
    char inputFilename [200];
    cout << "Enter the input filename:" << endl << "> ";
    std::cin >> inputFilename;

    vvERROR(openImageDocument(xtrEngine, inputFilename));

    
    // Process pages from the input image.

    // Find the number of pages in the input document.
    int numPages = 0;
    vvERROR( xtrEngine->vvGetValue(dm_in_num_pages, &numPages) );
    cout << ".... " << inputFilename << " contains " << numPages << " page(s)" << endl ;

    bool readAnotherPage = true;
    while (readAnotherPage)
    {
        char response[40];
        cout << "Enter a valid page number to recognize:" << endl << "> ";
        std::cin >> response;

        // Select the page to read
        vvERROR( xtrEngine->vvSetValue(dm_in_curr_page, atol(response) ));

        // Load a page of image data into the OCR engine.
        cout << ".... opening page " << response << endl ;
        vvxtrStatus status = xtrEngine->vvReadImageData();

        // Handle invalid page numbers.
        if (status == VVXTR_ERR_INVALID_PAGE)
        {
            cout << ".... page " << response << 
                    " is not valid.  This image contains " << numPages << " page(s)." << endl ;
            readAnotherPage = true;
        }
        else if (status == VV_OK)
        {
            // Process a valid page.
            vvERROR( processOnePage(xtrEngine) );

            // Determine what to do next.
            cout << "Process another page? [y|n] " << endl << "> ";
            std::cin >> response;

            if ( strcmp(response, "y") == 0 ) readAnotherPage = true;
            else readAnotherPage = false;
    
            // Close the loaded image page.
            cout << ".... unloading the image data" << endl ;
            vvERROR(xtrEngine->vvUnloadImage());
        }
        else
        {
            vvERROR( status );
        }
    }

    
    // Close the input image file.
    
    cout << ".... closing input image file.\n";
    vvERROR( xtrEngine->vvCloseImageFile() );

    return VV_OK;
}

vvxtrStatus openImageDocument(vvEngAPI * xtrEngine, char * inputFilename)
{
    if (xtrEngine == NULL)
        vvERROR( VVXTR_ERR );


    // Set the input filename.
    vvERROR( xtrEngine->vvSetValue(dm_in_filename, inputFilename) );
    
    // Open the file.
    cout << ".... opening the input image file " << inputFilename << endl ;
    vvxtrStatus status = xtrEngine->vvOpenImageFile();

    // Handle errors
    if (status != VV_OK)
    {
        if ( status == VVXTR_ERR_UNABLE_TO_LOAD_IMAGE_FILE )
            cout << ".... unable to load input file \"" << inputFilename << "\"; exiting." << endl ;
        else
            cout << ".... unknown error when trying to load input file \"" << inputFilename << "\"; exiting." << endl ;
    }

    return status;
}

vvxtrStatus processOnePage(vvEngAPI * xtrEngine)
{
    char response[40];

    if (xtrEngine == NULL)
        vvERROR( VVXTR_ERR );

    cout << ".... preprocessing and recognizing the image data" << endl ;
        
    vvERROR( xtrEngine->vvPreprocess() );
    vvERROR( xtrEngine->vvRecognize() );


    // Output recognized text.

    cout << "Output a document? [y/n]" << endl << "> ";
    std::cin >> response;

    if ((strcmp(response,"y") == 0) || (strcmp(response, "Y") == 0))
        vvERROR( outputDoc(xtrEngine) );

    
    // Output a subimage.
    
    cout << "Output an image? [y/n]" << endl << "> ";
    std::cin >> response;

    if ((strcmp(response,"y") == 0) || (strcmp(response, "Y") == 0))
        vvERROR( outputImg(xtrEngine) );

    return VV_OK;
}


vvxtrStatus outputImg(vvEngAPI * xtrEngine)
{
    vvxtrStatus status = VV_OK;
    char response [20];

    if (xtrEngine != NULL)
    {

        // Set up parameters for image output. A dm_focus_area of
        // vvFocusAreaRegion specifies that we want to get only one region from the
        // page. The alternative is to get the whole page.
        vvERROR( xtrEngine->vvSetValue(dm_focus_area, vvFocusAreaRegion));

        // User selects subimage output file format.
        {
            cout <<"Choose the subimage output format:" << endl <<
                   "    [t]iff, [g]if, [j]peg, [p]ng, p[d]f, [r]gb, [v]vxtrImage" << endl << "> ";
            std::cin >> response;

            int imgType = atol(response);
    
            if (strcmp(response,"t") == 0)
                imgType = vvSubimageFormatTiffpack;
            else if (strcmp(response,"g") == 0)
                imgType = vvSubimageFormatGif;
            else if (strcmp(response,"j") == 0)
                imgType = vvSubimageFormatJpeg;
            else if (strcmp(response,"p") == 0)
                imgType = vvSubimageFormatPng;
            else if (strcmp(response,"d") == 0)
                imgType = vvSubimageFormatEPdf;
            else if (strcmp(response,"r") == 0)
                imgType = vvSubimageFormatRgb;
            else
                imgType = vvSubimageFormatVvxtrImage;

            vvERROR( xtrEngine->vvSetValue( dm_out_graphics_format, imgType ));
        }

        // List all available region ids, grouped by "image", "text" or "all".
        {
            char* regIds;

            // Get all image region ids
            vvERROR( xtrEngine->vvGetValue(dm_region_ids_image, &regIds));
            char * imageRegions = strdup(regIds);

            // Get all text region ids
            vvERROR( xtrEngine->vvGetValue(dm_region_ids_text, &regIds));
            char * textRegions = strdup(regIds);

            // Get all region ids
            vvERROR( xtrEngine->vvGetValue(dm_region_ids, &regIds));
            char * allRegions = strdup(regIds);

            cout << ".... image region ids: " << (char*)imageRegions << endl ;
            cout << ".... text region ids:  " << (char*)textRegions << endl ;
            cout << ".... all region ids:   " << (char*)allRegions << endl ;

            free(textRegions);
            free(allRegions);
            free(imageRegions);
        }

        // User selects region number.
        cout << "Specify a region to output as an image or [n]one:" << endl << "> ";
        std::cin >> response;
        while ((strcmp(response, "n") != 0)&&(strcmp(response,"none") != 0))
        {
            int regionID = atol(response);

            // Capture the subimage of region regionID.
            // Subimage data is extracted from the original input image.
            cout << ".... capturing subimage of region " << regionID << endl ;
            vvERROR(xtrEngine->vvCaptureSubimage(regionID));

            cout << "Output image to a [f]ile or [m]emory?" << endl << "> ";
            std::cin >> response;

            if(strcmp(response,"m") == 0)
            {
                // Memory size describes size of the data only.
                int memSize = 0;
                vvERROR( xtrEngine->vvGetValue(dm_subimage_memory_size, &memSize));

                char * data = new char[memSize];
                
                // Handle a vvxtrImage differently than file formats.
                int imgFormat = 0;
                vvERROR( xtrEngine->vvGetValue( dm_out_graphics_format, &imgFormat));

                if (imgFormat == (int)vvSubimageFormatVvxtrImage)
                {
                    vvxtrImage * img = vvxtrImage::FromRaw(data) ;

                    cout << ".... Write output image memory [" << memSize << "]\n";
                    vvERROR( xtrEngine->vvAcquireSubimageMemory(img,memSize));

// TODO: Do something with the image we've just acquired!
// This would be where in the code you would manipulate the image directly, if you
// so desire.

                }
                else
                {
                    cout << ".... Write output image memory [" << memSize << "]\n" ;
                    vvERROR( xtrEngine->vvAcquireSubimageMemory(data,memSize));
                    
                    string filename = "outImgMemory";
                    std::ofstream os (filename.c_str(), ios::binary);

// TODO: Do something with the image we've just acquired!
// This would be where in the code you would manipulate the image directly, if you
// so desire. We just write it out to disk, which is silly, because why not just
// use vvAcquireSubimageFile ?

                    if (os)
                    {
                        os.write(data,memSize);
                    }
                    else
                    {
                        cout << "Can't open output filename " << filename ;
                        status == VV_ERR ;
                    }
                }
                delete[] data;
                if (status != VV_OK) return status;
            }   // end memory output
            else
            {
                // Write image output to a file.
                char outputFilename [30];
                sprintf(outputFilename, "outImg_%d", regionID);
                cout << ".... writing output subimage file " << outputFilename << endl ;
                vvERROR( xtrEngine->vvAcquireSubimageFile(outputFilename));
            }
            vvERROR(status);

            cout << "Specify a region to output as an image or [n]one:" << endl << "> ";
            std::cin >> response;
        }

    } else
        status = VVXTR_ERR;

    // Reset focus area
    vvERROR( xtrEngine->vvSetValue(dm_focus_area, vvFocusAreaPage));

    return status;
}


vvxtrStatus outputDoc(vvEngAPI * xtrEngine)
{
    if (xtrEngine != NULL)
    {
        char response [40];

        // Set up output values.
        cout << "Choose the document output format:" <<
                "  [p]df, [a]scii, [u]nicode, [x]doc" << endl << "> ";
        std::cin >> response;

        int fileFormat ;

        // First we select the output text format
        if (strcmp(response,"p") == 0)
            fileFormat = vvTextFormatPdf ;
        else if (strcmp(response,"u") == 0)
            fileFormat = vvTextFormatUnicode ;
        else if (strcmp(response,"x") == 0)
            fileFormat = vvTextFormatXdoc ;
        else    // default ascii
            fileFormat = vvTextFormatIso ;
    
        // Start an output document with the correct file format.
        cout << ".... starting the output document" << endl ;
        vvERROR(xtrEngine->vvStartDoc(fileFormat));

        // Spool output from the engine based on the options already set.
        // Note that you can select different pages and/or regions and
        // call vvSpoolDoc multiple times before you call vvEndDoc. 
        cout << ".... writing to the output document" << endl ;
        vvERROR(xtrEngine->vvSpoolDoc());

        // End the output document.  At this point, we are done writing
        // output to this output doc. We can write more output, but would
        // need to start a new output document.
        cout << ".... ending the output document" << endl ;
        vvERROR(xtrEngine->vvEndDoc());

        cout << "Send output doc to a [f]ile or [m]emory?" << endl << "> ";
        std::cin >> response;

        if ((strcmp(response,"f") == 0) || (strcmp(response,"file") == 0))
        {
            // Write output to a file.
            
            cout << "Enter the output filename:" << endl << "> ";
            std::cin >> response;
            cout << ".... acquiring the document output as a file called " << response << endl ;
            vvERROR(xtrEngine->vvAcquireDocFile(response));
        }
        else
        {
            // Obtain output in memory.
            
            int dataSize;

            // Get file size in memory.
            vvERROR( xtrEngine->vvGetValue(dm_doc_memory_size, &dataSize));
            cout << ".... need to allocate " << dataSize <<
                    " bytes to store the output document." << endl ;

            // Allocate memory for doc data.
            char * memBuffer = (char*)malloc(dataSize);

            // Write output to memory.
            cout << ".... acquiring the output document in memory." << endl ;
            vvERROR(xtrEngine->vvAcquireDocMemory((void*) memBuffer, dataSize));

            cout << ".... the contents of the memory buffer are:" << endl << endl ;
            for(int i=0; i<dataSize; i++)
                cout.put(memBuffer[i]) ;

            cout << endl << endl ;

            // Free allocated memory.
            free(memBuffer);
        }

    } else
        vvERROR( VVXTR_ERR );

    return VV_OK;
}


void CloseDown()
{
    vvLog(VVLOG_INFO,"[%d] CloseDown()\n",getpid());
    
    if (g_xtrEngine != NULL) g_xtrEngine->vvKill();
}

void SigTermHandler(int param)
{
    vvLog(VVLOG_ERROR,"[%d] SigTermHandler::Received signal %d. Exiting.\n",getpid(),param);
    exit(0);
}

void SigErrorHandler(int param)
{
    vvLog(VVLOG_ERROR,"[%d] Received ERROR signal %d. Exiting.\n",getpid(),param);
    exit(0);
}

---