vvxtrAPI.h

Go to the documentation of this file.

#ifndef VVXTRAPI_H
#define VVXTRAPI_H 1

#include "vvxtrDefs.h"
#include "malloc.h"
#include "memory.h"

class vvEngAPI 
{
public:
    vvEngAPI() { memset(m_hints,0,sizeof(m_hints)); }// No hints to begin with! 

    virtual ~vvEngAPI() {};

    virtual vvxtrStatus vvKill() = 0;

    virtual vvxtrStatus vvInitInstance() = 0;

    virtual vvxtrStatus vvEndInstance() = 0;

    virtual vvxtrStatus vvStartOCRSes() = 0;

    virtual vvxtrStatus vvEndOCRSes() = 0;

    virtual vvxtrStatus vvStartDoc() = 0;

    vvxtrStatus vvStartDoc(int fileFormat)
    {
        vvERROR(vvSetValue(dm_out_text_format, (vvxtr_stdarg)fileFormat));

        return vvStartDoc();
    }

    virtual vvxtrStatus vvSpoolDoc() = 0;

    virtual vvxtrStatus vvEndDoc() = 0;

    virtual vvxtrStatus vvAcquireDocMemory(void * memPtr,int bufsize) = 0;

    virtual vvxtrStatus vvAcquireDocFile(const char * filename) = 0;

    virtual vvxtrStatus vvCaptureSubimage() = 0;

    vvxtrStatus vvCaptureSubimage( int regionID )
    {
        vvERROR(vvSetValue(dm_current_region, (vvxtr_stdarg)regionID));
        return vvCaptureSubimage();
    }

    virtual vvxtrStatus vvAcquireSubimageMemory(void * memPtr,int bufsize) = 0;

    virtual vvxtrStatus vvAcquireSubimageFile(const char * filename) = 0;

    virtual vvxtrStatus vvOpenImageFile() = 0;

    vvxtrStatus vvOpenImageFile( const char * fileName )
    {
        vvERROR(vvSetValue(dm_in_filename,(vvxtr_stdarg)fileName));
        return vvOpenImageFile();
    }

    virtual vvxtrStatus vvCloseImageFile() = 0;

    virtual vvxtrStatus vvReadImageData() = 0;

    virtual vvxtrStatus vvReadImageData(const struct vvxtrImage * img) = 0;

    virtual vvxtrStatus vvUnloadImage() = 0;

    virtual vvxtrStatus vvPreprocess() = 0;

    virtual vvxtrStatus vvRecognize() = 0;

    virtual vvxtrStatus vvInitValues() = 0;

    virtual vvxtrStatus vvGetStatus(const int key, vvxtr_stdarg *result) = 0;

#ifndef DOXYGEN
    virtual vvxtrStatus vvSetValue(const int key, const vvxtr_stdarg value) = 0;
#endif

    vvxtrStatus vvSetValue( const int key, int value)
    {
        return vvSetValue( key, (vvxtr_stdarg)value);
    }
    vvxtrStatus vvSetValue( const int key, char * value )
    {
        return vvSetValue( key, (vvxtr_stdarg)value);
    }

#ifndef DOXYGEN
    virtual vvxtrStatus vvGetValue(const int key, vvxtr_stdarg *result, VVXTR_DATATYPE *resultType) = 0;
#endif

    vvxtrStatus vvGetValue( const int key, int * result )
    {
        return vvGetValue( key, (vvxtr_stdarg*)result, NULL);
    }
    vvxtrStatus vvGetValue( const int key, char ** result )
    {
        return vvGetValue( key, (vvxtr_stdarg*)result, NULL);
    }


    virtual vvxtrStatus vvGetState(vvxtr_state *resultState) = 0;

    virtual vvxtrStatus vvGetCond(const vvxtr_cond c, int *result) = 0;
    
    virtual vvxtrStatus vvSetHint(vvxtrHint hint, bool set=true) {  m_hints[hint]=set ; return VV_OK ; }

    virtual bool vvGetHint(vvxtrHint hint) { return m_hints[hint]; }

    virtual void vvSigHUP() { }

    virtual const char * vvGetStatusString(vvxtrStatus status= VVXTR_PREVIOUS_ERROR)
    {
        if (status==VVXTR_PREVIOUS_ERROR)
        {
            return "No information";
        }

        switch (status)
        {
            case VVXTR_ERR_INVALID_SYNTAX:              return "Invalid syntax";
            case VVXTR_ERR_NO_INPUT:                    return "No input";
            case VVXTR_ERR_INVALID_STATE:               return "Invalid state";
            case VVXTR_ERR_INITINSTANCE_FAILURE:        return "Initialization of instance failed";
            case VVXTR_ERR_ENDINSTANCE_FAILURE:         return "Ending instance failed";
            case VVXTR_ERR_NO_INPUT_FILE_SPECIFIED:     return "No input file was specified";
            case VVXTR_ERR_UNABLE_TO_LOAD_IMAGE_FILE:   return "Unable to load image data from the file";
            case VVXTR_ERR_IMG_ACQ_FAILED:              return "Image upload to OCR kernel failed";
            case VVXTR_ERR_START_SESSION_FAILED:        return "Starting OCR session failed";
            case VVXTR_ERR_RECOGNITION_FAILED:          return "Recognition failed";
            case VVXTR_ERR_OPEN_CHAR_SET_FAILURE:       return "Unable to open character set";
            case VVXTR_ERR_INVALID_SHAPE_PACK_PATH:     return "Invalid shape pack path";
            case VVXTR_ERR_BAD_LANGUAGE:                return "Bad language pack";
            case VVXTR_ERR_OPENING_LANG_PACK:           return "Unable to open language pack";
            case VVXTR_ERR_LOAD_LANG_FAILED:            return "Unable to load language";
            case VVXTR_ERR_CREATE_LANG_GROUP:           return "Unable to create a language group";
            case VVXTR_ERR_SET_DEF_LEX_CONSTRAINTS:     return "Unable to set default lexical constraints";
            case VVXTR_ERR_WRITE_OUTPUT_FAILED:         return "Unable to write output";
            case VVXTR_ERR_OPENING_OUTPUT_FILE:         return "Unable to open output file";
            case VVXTR_ERR_REGION_ECLIPSED:             return "Region eclipsed";
            case VVXTR_ERR_COULD_NOT_CONVERT_DEPTH:     return "Unable to convert image depth";
            case VVXTR_ERR_GETTING_IMG_REGION:          return "Unable to get image region";
            case VVXTR_ERR_END_SESSION_FAILED:          return "Unable to end session";
            case VVXTR_ERR_OUTPUT_INV_REGION:           return "Error in output of inv region";
            case VVXTR_ERR_NOT_IMPLEMENTED:             return "Feature not implemented";
            case VVXTR_ERR_INV_PDF_FORMAT:              return "Invalid PDF format";
            case VVXTR_ERR_PDF_IMG_OUTPUT:              return "Error in PDF image output";
            case VVXTR_ERR_PDF_END_OUTPUT:              return "Error in finishing PDF output";
            case VVXTR_ERR_HOST_LOOKUP_FAILED:          return "The remote name lookup failed";
            case VVXTR_ERR_CONNECTION_FAILED:           return "The remote connection  failed";
            case VVXTR_ERR_NO_SUBIMAGE:                 return "No subimage available to acquire.";
            case VVXTR_ERR_PP_FAILED:                   return "Preprocessing failed.";
            case VVXTR_ERR_SET_OPTIONS_FAILED:          return "Set options failed.";
            case VVXTR_ERR_REMOVE_FILE_FAILED:          return "Removal of temp file failed.";
            case VVXTR_ERR_NO_DOC:                      return "No doc available to acquire.";
            case VVXTR_ERR_INV_SUBIMG_FORMAT:           return "Invalid subimage format.";
            case VVXTR_ERR_TRANSFER_FAILED:             return "The data transfer failed";
            case VVXTR_ERR_SYNCHRONIZATION:             return "The client and server are out of synch";
            case VVXTR_ERR_NOENGINE:                    return "The engine hasn't been allocated yet";
            case VVXTR_ERR_BUFFER_TOO_SMALL:            return "The buffer size is too small to receive all of the data";
            case VVXTR_ERR_INVALID_PAGE:                return "Invalid page in input image was specified";
            case VVXTR_ERR_MISSING_LANG:                return "Add user lexicon missing language";
            case VVXTR_ERR_ENG_OUT_OF_MEMORY:           return "Internal OCR engine is out of memory";
            case VVXTR_ERR_INVALID_UOR_COUNT:           return "UOR count is invalid";
            case VVXTR_ERR_INVALID_UOR_STRING:          return "UOR string contains an invalid character";
            case VVXTR_ERR_READONLY_VALUE:              return "Can not write to a read-only value.";
            case VVXTR_ERR_INVALID_REGION_ID:           return "Invalid region id.";
            case VVXTR_ERR_SET_REGION_UNSUCCESSFUL:     return "Call to vvSetRegion was unsuccessful.";
            case VVXTR_ERR_REGION_HANDLER:              return "Kernel error in the region handler.";
            case VVXTR_ERR_NO_LICENSE_MANAGER:          return "License manager unavailable, and starting it was unsuccessful";
            case VVXTR_ERR_NO_LICENSE:                  return "No licenses are available for checkout";
            case VVXTR_ERR_NO_FEATURE:                  return "Feature not available.";
            case VVXTR_ERR_ENGINE_KILLED:               return "Engine has been killed with vvKill; no further commands are possible.";
            default:                                    return "Undocumented error";
        }                                               
    }

    virtual vvxtrStatus vvGetVersion( vvxtrVersionLocationEnum loc, const char ** ver ) = 0;

    virtual vvxtrStatus vvAddWordToLexicon( const char *word, int constraintId ) = 0;

    virtual vvxtrStatus vvSetLexicalConstraints( int mode ) = 0;

/*  Currently unsupported options:
    * - ::dm_region_textformat (::vvxtrOutTextFormatEnum)
    * - ::dm_region_prefix (string for \ref region prefix)
    * - ::dm_region_suffix (string for \ref region suffix)
    * - ::dm_region_opacity (::vvxtrRegionOpacityEnum)
    * - ::dm_region_abutment (::vvxtrRegionAbutmentEnum)
    * - ::dm_region_parent (\ref region id of parent \ref region)
 */
    virtual vvxtrStatus vvSetRegionProperties( void ) = 0;

    virtual vvxtrStatus vvForceRegionForeground( int foregroundColor ) = 0;

    virtual vvxtrStatus vvRemoveRegion( void ) = 0;

    bool m_hints[vvNumberOfHints] ;         
private:

} ;


class vvxtrImage 
{
public:

    vvxtrImage() { memset(this,0,sizeof(vvxtrImage)); size = sizeof(vvxtrImage) ; };


    void SetWidth(unsigned int width) { dwImgWidth = width; }
    void SetHeight(unsigned int height) { dwImgHeight = height; }
    
    void SetBytesPerLine(unsigned int bpl) { dwBytesPerLine = bpl; }
    
    void SetXDPI(unsigned short int xdpi) { wXDPI = xdpi; }
    
    void SetYDPI(unsigned short int ydpi) { wYDPI = ydpi; }
    void SetBitsPerPixel(unsigned short int bpp) { chBitsPerPixel = bpp; }
    void SetBitsPerSample(unsigned short int bps) { wBitsPerSample = bps; }
    void SetData(unsigned char * imgData) { data = const_cast<unsigned char *>(imgData); }

    unsigned int    GetWidth() { return dwImgWidth; }
    unsigned int    GetHeight() { return dwImgHeight; }
    unsigned int    GetBytesPerLine() { return dwBytesPerLine; }
    unsigned short int GetXDPI() { return wXDPI; }
    unsigned short int GetYDPI() { return wYDPI; }
    unsigned short int GetBitsPerPixel() { return chBitsPerPixel; }
    unsigned short int  GetBitsPerSample() { return wBitsPerSample; }
    
    unsigned char * GetData() { return data; }
    const unsigned char * GetData() const { return data; }

    int GetImageSize() const { return dwImgHeight*dwBytesPerLine; }
    int GetTotalSize() const { int thisSize = sizeof(vvxtrImage) ;return thisSize+GetImageSize(); } ; 

    static vvxtrImage * FromRaw( void * rawbuffer )
    {
        memset(rawbuffer,0,sizeof(vvxtrImage));
        vvxtrImage * newThis = (vvxtrImage*)rawbuffer;

        newThis->SetData( (unsigned char *)(newThis+1) );
        return newThis ;
    }

protected:
    int     size;                           
    unsigned int        dwImgWidth;         
    unsigned int        dwImgHeight;        
    unsigned int        dwBytesPerLine;     
    unsigned short int  wXDPI;              
    unsigned short int  wYDPI;              
    unsigned short int  chBitsPerPixel;     
    unsigned short int  wBitsPerSample;     
    unsigned char * data ;                  
};

#endif

---