vvxtrSample2.cc

Go to the documentation of this file.

#include <vvocr/vvxtrFactory.h>     // All OCR Shop XTR/API header files are included through here

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

#include <signal.h>

//#include <vvocr/vvxtrAPI.h>       // These headers are used, but included from vvxtrFactory.h.
//#include <vvutil/vvLog.h>
//#include "stdio.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);

// 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);

// Read in raw image data
vvxtrStatus createImageStruct(unsigned char * buf, vvxtrImage** inputImage);
vvxtrImage* readFromRawData();

// 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));
    vvERROR(xtrEngine->vvSetValue(dm_pp_reverse_video, vvYes));
    vvERROR(xtrEngine->vvSetValue(dm_pp_photometric_interp , vvCorrect));


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

        cout << "Process another input image? [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)
{
    vvxtrImage* inputImage = NULL;      // One page of image data

    // Read raw input data from a file and load it into the engine through memory:
    inputImage = readFromRawData();

    // Process pages from the input image.
    if (inputImage != NULL)
    {
        // Load a page of image data into the OCR engine.
        cout << ".... loading image data into the engine" << endl ;
        vvxtrStatus status = xtrEngine->vvReadImageData(inputImage);

        // Handle errors.
        if (status == VV_OK)
        {
            // Process a valid page.
            vvERROR( processOnePage(xtrEngine) );

            // Close the loaded image page.
            cout << ".... unloading the image data" << endl ;
            vvERROR(xtrEngine->vvUnloadImage());
        }
        else
        {
            vvERROR( status );
        }

        // Free allocated memory.
        if (inputImage->GetData() != NULL)
            free (inputImage->GetData());
        if (inputImage != NULL)
            delete inputImage;
    }
    else    // inputImage was not loaded successfully
    {
        vvERROR( VV_ERR );
    }

    return VV_OK;
}


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;
}

vvxtrImage* readFromRawData()
{
    char inputFilename [200];           // File containing raw image data
    FILE *fp = NULL;

    unsigned char * buf = NULL;         // Buffer of raw image data

    vvxtrImage* inputImage = NULL;      // Image data to return

    cout << "Enter the filename for the raw input image data:" << endl << "> ";
    std::cin >> inputFilename;

    // Open file containing raw image data.
    if (!(fp = fopen(inputFilename, "rb")))
    {
        cout << "readRawData:  Error opening file " << inputFilename << " for reading." << endl ;
        return NULL;
    }

    // Find number of bytes in file.
    if ((fseek(fp, 0, SEEK_END)) != 0)
    {
        printf("fseek problem!\n");
        return NULL;
    }
    int numBytes = ftell(fp);
    rewind(fp);

    // Read image data from the file into buf.
    if ((buf = (unsigned char *) (malloc)(numBytes)) == NULL )
    {
        cout << "readRawData:  Error in memory allocation (" << numBytes << " bytes)" << endl ;
        return NULL;
    }

    // Verify byte count.
    if ( (fread(buf, 1, numBytes, fp)) != numBytes)
    {
        cout << "readRawData:  Unable to read " << numBytes <<" bytes" << endl;
        free (buf);
        return NULL;
    }

    // Close input file.
    fclose(fp);

    cout << ".... read " << numBytes << " bytes of input data from " << inputFilename << "." << endl;

    // Convert the raw data in the image buffer into a vvxtrImage structure.
    if (createImageStruct(buf, &inputImage) != VV_OK)
    {
        free (buf);
        delete inputImage;
        return NULL;
    }

    return inputImage;
}

vvxtrStatus createImageStruct(unsigned char * buf, vvxtrImage** inputImage)
{
    char response [40];

    (*inputImage) = new vvxtrImage();

    cout << "Enter the image data: " << endl ;

    cout << "width?  " ;
    std::cin >> response;
    (*inputImage)->SetWidth(atol(response));

    cout << "height?  " ;
    std::cin >> response;
    (*inputImage)->SetHeight(atol(response));

    cout << "bytes per line?  " ;
    std::cin >> response;
    (*inputImage)->SetBytesPerLine(atol(response));

    cout << "X dpi?  " ;
    std::cin >> response;
    (*inputImage)->SetXDPI(atol(response));

    cout << "Y dpi?  " ;
    std::cin >> response;
    (*inputImage)->SetYDPI(atol(response));

    cout << "bits per pixel (1, 8, or 24)?  " ;
    std::cin >> response;
    (*inputImage)->SetBitsPerPixel(atol(response));

    cout << "bits per sample (1 or 8)?  " ;
    std::cin >> response;
    (*inputImage)->SetBitsPerSample(atol(response));

    (*inputImage)->SetData(buf);

    cout << ".... Image data placed in a vvxtrImage structure:" << endl << endl;
    cout << "  width      " << (*inputImage)->GetWidth() << endl;
    cout << "  height     " << (*inputImage)->GetHeight() << endl;
    cout << "  bpl        " << (*inputImage)->GetBytesPerLine() << endl;
    cout << "  xdpi       " << (*inputImage)->GetXDPI() << endl;
    cout << "  ydpi       " << (*inputImage)->GetYDPI() << endl;
    cout << "  bpp        " << (*inputImage)->GetBitsPerPixel() << endl;
    cout << "  bps        " << (*inputImage)->GetBitsPerSample() << endl;
    cout << "  image size " << (*inputImage)->GetImageSize() << endl << endl;

    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);
}

---