asprise_ocr_api.h

Go to the documentation of this file.

#ifndef ASPRISE_OCR_API_H
#define ASPRISE_OCR_API_H

#ifdef _WIN32
#define EXPORT_API __declspec(dllexport)
#define CALL_CONVENTION __stdcall
#include <Windows.h>
#else
#define EXPORT_API
#define CALL_CONVENTION
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#define OCR_SPEED_FASTEST "fastest"
#define OCR_SPEED_FAST "fast"
#define OCR_SPEED_SLOW "slow"

#define OCR_RECOGNIZE_TYPE_TEXT "text"
#define OCR_RECOGNIZE_TYPE_BARCODE "barcode"
#define OCR_RECOGNIZE_TYPE_ALL "all"

#define OCR_OUTPUT_FORMAT_PLAINTEXT "text"
#define OCR_OUTPUT_FORMAT_XML "xml"
#define OCR_OUTPUT_FORMAT_PDF "pdf"
#define OCR_OUTPUT_FORMAT_RTF "rtf"

//#define OCR_PROP_INCLUDE_EMPTY_BLOCK "PROP_INCLUDE_EMPTY_BLOCK"

#define OCR_PROP_LIMIT_TO_CHARSET "PROP_LIMIT_TO_CHARSET"

#define OCR_PROP_PAGE_TYPE "PROP_PAGE_TYPE"
#define OCR_PROP_PAGE_TYPE_AUTO_DETECT "auto"
#define OCR_PROP_PAGE_TYPE_SINGLE_BLOCK "single_block"
#define OCR_PROP_PAGE_TYPE_SINGLE_COLUMN "single_column"
#define OCR_PROP_PAGE_TYPE_SINGLE_LINE "single_line"
#define OCR_PROP_PAGE_TYPE_SINGLE_WORD "single_word"
#define OCR_PROP_PAGE_TYPE_SINGLE_CHARACTOR "single_char"
#define OCR_PROP_PAGE_TYPE_SCATTERED "scattered"

#define OCR_PROP_OUTPUT_SEPARATE_WORDS "PROP_OUTPUT_SEPARATE_WORDS"

#define OCR_PROP_INPUT_PDF_DPI "PROP_INPUT_PDF_DPI"

// -------- Dictionary related ---------
#define OCR_START_PROP_DICT_SKIP_BUILT_IN_DEFAULT "START_PROP_DICT_SKIP_BUILT_IN_DEFAULT"

#define OCR_START_PROP_DICT_SKIP_BUILT_IN_ALL "START_PROP_DICT_SKIP_BUILT_IN_ALL"

#define OCR_START_PROP_DICT_CUSTOM_DICT_FILE "START_PROP_DICT_CUSTOM_DICT_FILE" 

#define OCR_START_PROP_DICT_CUSTOM_TEMPLATES_FILE "START_PROP_DICT_CUSTOM_TEMPLATES_FILE" 

#define OCR_PROP_DICT_DICT_IMPORTANCE "PROP_DICT_DICT_IMPORTANCE"

// -------- PDF output related ---------

#define OCR_PROP_PDF_OUTPUT_FILE "PROP_PDF_OUTPUT_FILE"
#define OCR_PROP_PDF_OUTPUT_IMAGE_DPI "PROP_PDF_OUTPUT_IMAGE_DPI"
#define OCR_PROP_PDF_OUTPUT_FONT "PROP_PDF_OUTPUT_FONT"
#define OCR_PROP_PDF_OUTPUT_TEXT_VISIBLE "PROP_PDF_OUTPUT_TEXT_VISIBLE"
#define OCR_PROP_PDF_OUTPUT_IMAGE_FORCE_BW "PROP_PDF_OUTPUT_IMAGE_FORCE_BW"

#define OCR_PROP_PDF_OUTPUT_PDFA "PROP_PDF_OUTPUT_PDFA"
#define OCR_PROP_PDF_OUTPUT_PDFA_FONT_FILE "PROP_PDF_OUTPUT_PDFA_FONT_FILE"

#define OCR_PROP_PDF_OUTPUT_CONF_THRESHOLD "PROP_PDF_OUTPUT_CONF_THRESHOLD"

#define OCR_PROP_PDF_OUTPUT_RETURN_TEXT "PROP_PDF_OUTPUT_RETURN_TEXT"

// -------- RTF output related ---------

#define OCR_PROP_RTF_OUTPUT_FILE "PROP_RTF_OUTPUT_FILE"

#define OCR_PROP_RTF_OUTPUT_RETURN_TEXT "PROP_RTF_OUTPUT_RETURN_TEXT"

#define OCR_PROP_RTF_PAPER_SIZE "PROP_RTF_PAPER_SIZE"

#define OCR_PROP_RTF_SHOW_TABLE_CELL_BORDER "PROP_RTF_SHOW_TABLE_CELL_BORDER"

// -------- image processing related ---------

#define OCR_PROP_IMG_PREPROCESS_TYPE "PROP_IMG_PREPROCESS_TYPE"
#define OCR_PROP_IMG_PREPROCESS_TYPE_DEFAULT "default"
#define OCR_PROP_IMG_PREPROCESS_TYPE_DEFAULT_WITH_ORIENTATION_DETECTION "default_with_orientation_detection"
#define OCR_PROP_IMG_PREPROCESS_TYPE_CUSTOM "custom"

#define OCR_PROP_IMG_PREPROCESS_CUSTOM_CMDS "PROP_IMG_PREPROCESS_CUSTOM_CMDS"

// -------- table related ---------
#define OCR_PROP_TABLE_SKIP_DETECTION "PROP_TABLE_SKIP_DETECTION"

#define OCR_PROP_TABLE_MIN_SIDE_LENGTH "PROP_TABLE_MIN_SIDE_LENGTH"

#define OCR_PROP_SAVE_INTERMEDIATE_IMAGES_TO_DIR "PROP_SAVE_INTERMEDIATE_IMAGES_TO_DIR"

#define OCR_PROP_INPUT_PDF_SINGLE_IMG_PER_PAGE "PROP_INPUT_PDF_SINGLE_IMG_PER_PAGE"

// ------------------------- Functions exposed -------------------------
EXPORT_API const char * CALL_CONVENTION com_asprise_ocr_version();

EXPORT_API int CALL_CONVENTION com_asprise_ocr_setup(bool queryOnly);

EXPORT_API char * CALL_CONVENTION com_asprise_ocr_list_supported_langs();

EXPORT_API long long CALL_CONVENTION com_asprise_ocr_start(const char * lang, const char * speed, const char * propSpec, const char * propSeparator, const char * propKeyValueSpeparator);

EXPORT_API char * CALL_CONVENTION com_asprise_ocr_recognize
(long long handle, const char * imgFiles, int pageIndex, int startX, int startY, int width, int height, const char * recognizeType, const char * outputFormat, const char * propSpec, const char * propSeparator, const char * propKeyValueSpeparator);

EXPORT_API void CALL_CONVENTION com_asprise_ocr_stop(long long handle);

EXPORT_API void CALL_CONVENTION com_asprise_ocr_input_license(const char * licenseeName, const char * licenseCode);

EXPORT_API void CALL_CONVENTION com_asprise_ocr_util_delete(long long handle, bool isArray);

// pyd
EXPORT_API void CALL_CONVENTION initaocr(void);
EXPORT_API void CALL_CONVENTION initaocr_x64(void);

#ifdef __cplusplus
}
#endif

// ------------------------- Run-time Dynamic Linking -------------------------
#ifndef SKIP_AOCR_DYNAMIC
typedef void(*FUNC_TYPE)(void *);
#ifdef _WIN32
    typedef HMODULE LIBRARY_HANDLE;
    #define snprintf _snprintf
#else
    typedef void * LIBRARY_HANDLE;
#endif

#if defined(_WIN32) && !defined(_WIN64)
#define FUNC_NAME_com_asprise_ocr_version       "_com_asprise_ocr_version@0"
#define FUNC_NAME_com_asprise_ocr_setup         "_com_asprise_ocr_setup@4"
#define FUNC_NAME_com_asprise_ocr_list_supported_langs "_com_asprise_ocr_list_supported_langs@0"
#define FUNC_NAME_com_asprise_ocr_start         "_com_asprise_ocr_start@20"
#define FUNC_NAME_com_asprise_ocr_stop          "_com_asprise_ocr_stop@8"
#define FUNC_NAME_com_asprise_ocr_recognize     "_com_asprise_ocr_recognize@52"
#define FUNC_NAME_com_asprise_ocr_util_delete   "_com_asprise_ocr_util_delete@12"
#define FUNC_NAME_com_asprise_ocr_input_license "_com_asprise_ocr_input_license@8"
#else
#define FUNC_NAME_com_asprise_ocr_version       "com_asprise_ocr_version"
#define FUNC_NAME_com_asprise_ocr_setup         "com_asprise_ocr_setup"
#define FUNC_NAME_com_asprise_ocr_list_supported_langs "com_asprise_ocr_list_supported_langs"
#define FUNC_NAME_com_asprise_ocr_start         "com_asprise_ocr_start"
#define FUNC_NAME_com_asprise_ocr_stop          "com_asprise_ocr_stop"
#define FUNC_NAME_com_asprise_ocr_recognize     "com_asprise_ocr_recognize"
#define FUNC_NAME_com_asprise_ocr_util_delete   "com_asprise_ocr_util_delete"
#define FUNC_NAME_com_asprise_ocr_input_license "com_asprise_ocr_input_license"
#endif

    typedef const char * (CALL_CONVENTION * func_type_com_asprise_ocr_version) ();
    typedef int(CALL_CONVENTION * func_type_com_asprise_ocr_setup) (bool);
    typedef char * (CALL_CONVENTION * func_type_com_asprise_ocr_list_supported_langs) ();
    typedef long long(CALL_CONVENTION * func_type_com_asprise_ocr_start) (const char *, const char *, const char *, const char *, const char *);
    typedef void(CALL_CONVENTION * func_type_com_asprise_ocr_stop) (long long);
    typedef char * (CALL_CONVENTION * func_type_com_asprise_ocr_recognize) (long long, const char *, int, int, int, int, int, const char *, const char *, const char *, const char *, const char *);
    typedef void(CALL_CONVENTION * func_type_com_asprise_ocr_util_delete) (long long, bool);
    typedef void(CALL_CONVENTION * func_type_com_asprise_ocr_input_license) (const char *, const char *);

    func_type_com_asprise_ocr_input_license func_com_asprise_ocr_input_license = NULL;
    func_type_com_asprise_ocr_list_supported_langs func_com_asprise_ocr_list_supported_langs = NULL;
    func_type_com_asprise_ocr_recognize func_com_asprise_ocr_recognize = NULL;
    func_type_com_asprise_ocr_setup func_com_asprise_ocr_setup = NULL;
    func_type_com_asprise_ocr_start func_com_asprise_ocr_start = NULL;
    func_type_com_asprise_ocr_stop func_com_asprise_ocr_stop = NULL;
    func_type_com_asprise_ocr_util_delete func_com_asprise_ocr_util_delete = NULL;
    func_type_com_asprise_ocr_version func_com_asprise_ocr_version = NULL;

    bool checkIfFuncFound(bool funcFound, const char * funcName) {
        if (funcFound) {
            return true;
        } else {
            printf("ERROR: Failed to look up function in the library: %s\n", funcName);
            return false;
        }
    }

    LIBRARY_HANDLE dynamic_load_aocr_library(const char * pathToFolderContainingAocrLibrary) {
        LIBRARY_HANDLE handle = NULL;
        char libFilePath[256];
        bool isWindows = false;
    #ifdef WIN32
        #ifdef _WIN64
        const char * libName = "aocr_x64.dll";
        #else
        const char * libName = "aocr.dll";
        #endif
        isWindows = true;
    #else
        #ifdef __APPLE__
            const char * libName = "libaocr_x64.dylib";
        #else
            #if defined(__LP64__) || defined(_LP64)
                const char * libName = "libaocr_x64.so";
            #else
                const char * libName = "libaocr.so";
            #endif
        #endif
        isWindows = false;
    #endif

        const char * separator = strlen(pathToFolderContainingAocrLibrary) > 0 && (pathToFolderContainingAocrLibrary[strlen(pathToFolderContainingAocrLibrary) - 1] == '/' || pathToFolderContainingAocrLibrary[strlen(pathToFolderContainingAocrLibrary) - 1] == '\\')
            ? "" : "/";
        snprintf(libFilePath, 256, "%s%s%s", pathToFolderContainingAocrLibrary, separator, libName);
        for (size_t i = 0; i < strlen(libFilePath); i++) { // correct slash directions
            if (libFilePath[i] == '/' || libFilePath[i] == '\\') {
                libFilePath[i] = isWindows ? '\\' : '/';
            }
        }

    #ifdef WIN32
        handle = LoadLibraryA(libFilePath);
        if(handle == NULL) {
            printf("ERROR: GetLastError() returns: %lu\n", GetLastError());
            return NULL;
        }
        func_com_asprise_ocr_input_license = (func_type_com_asprise_ocr_input_license) GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_input_license);
        func_com_asprise_ocr_list_supported_langs = (func_type_com_asprise_ocr_list_supported_langs)GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_list_supported_langs);
        func_com_asprise_ocr_recognize = (func_type_com_asprise_ocr_recognize)GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_recognize);
        func_com_asprise_ocr_setup = (func_type_com_asprise_ocr_setup)GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_setup);
        func_com_asprise_ocr_start = (func_type_com_asprise_ocr_start)GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_start);
        func_com_asprise_ocr_stop = (func_type_com_asprise_ocr_stop)GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_stop);
        func_com_asprise_ocr_util_delete = (func_type_com_asprise_ocr_util_delete)GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_util_delete);
        func_com_asprise_ocr_version = (func_type_com_asprise_ocr_version)GetProcAddress(handle, FUNC_NAME_com_asprise_ocr_version);
    #else
        handle = dlopen(libFilePath, RTLD_LAZY);
        if (handle == NULL) {
            printf("ERROR: dlerror(): %s\n", dlerror());
            return NULL;
        }
        func_com_asprise_ocr_input_license = (func_type_com_asprise_ocr_input_license)dlsym(handle, FUNC_NAME_com_asprise_ocr_input_license);
        func_com_asprise_ocr_list_supported_langs = (func_type_com_asprise_ocr_list_supported_langs)dlsym(handle, FUNC_NAME_com_asprise_ocr_list_supported_langs);
        func_com_asprise_ocr_recognize = (func_type_com_asprise_ocr_recognize)dlsym(handle, FUNC_NAME_com_asprise_ocr_recognize);
        func_com_asprise_ocr_setup = (func_type_com_asprise_ocr_setup)dlsym(handle, FUNC_NAME_com_asprise_ocr_setup);
        func_com_asprise_ocr_start = (func_type_com_asprise_ocr_start)dlsym(handle, FUNC_NAME_com_asprise_ocr_start);
        func_com_asprise_ocr_stop = (func_type_com_asprise_ocr_stop)dlsym(handle, FUNC_NAME_com_asprise_ocr_stop);
        func_com_asprise_ocr_util_delete = (func_type_com_asprise_ocr_util_delete)dlsym(handle, FUNC_NAME_com_asprise_ocr_util_delete);
        func_com_asprise_ocr_version = (func_type_com_asprise_ocr_version)dlsym(handle, FUNC_NAME_com_asprise_ocr_version);
    #endif
        if (handle == NULL) {
            printf("ERROR: failed to dynamically load the library: %s\nMake sure it exists. Contact support@asprise.com if you need any assistance.\n", libFilePath);
        }

        if (checkIfFuncFound(func_com_asprise_ocr_input_license != NULL, FUNC_NAME_com_asprise_ocr_input_license) &&
            checkIfFuncFound(func_com_asprise_ocr_list_supported_langs != NULL, FUNC_NAME_com_asprise_ocr_list_supported_langs) &&
            checkIfFuncFound(func_com_asprise_ocr_recognize != NULL, FUNC_NAME_com_asprise_ocr_recognize) &&
            checkIfFuncFound(func_com_asprise_ocr_setup != NULL, FUNC_NAME_com_asprise_ocr_setup) &&
            checkIfFuncFound(func_com_asprise_ocr_start != NULL, FUNC_NAME_com_asprise_ocr_start) &&
            checkIfFuncFound(func_com_asprise_ocr_stop != NULL, FUNC_NAME_com_asprise_ocr_stop) &&
            checkIfFuncFound(func_com_asprise_ocr_util_delete != NULL, FUNC_NAME_com_asprise_ocr_util_delete) &&
            checkIfFuncFound(func_com_asprise_ocr_version != NULL, FUNC_NAME_com_asprise_ocr_version)) {
            // all found
        }
        else {
            printf("ERROR: at lease one function is not found in the library.\n");
            return NULL;
        }

        return handle;
    }

    bool dynamic_unload_aocr_library(LIBRARY_HANDLE handle) {
        int errorCode = 0;
        if (handle == NULL) {
            return false;
        }
#ifdef WIN32
        return FreeLibrary(handle) != 0;
#else
        errorCode = dlclose(handle);
        if(errorCode != 0) {
            printf("dlclose() returns error code: %d\n", errorCode);
        }
        return errorCode == 0;
#endif
    }

    bool assertFuncExists(bool exists) {
        if (exists) {
            return true;
        } else {
            printf("Function is NULL. Please call dynamic_load_aocr_library first.\n");
            return false;
        }
    }

    const char * c_com_asprise_ocr_version() {
        if (!assertFuncExists(func_com_asprise_ocr_version != NULL)) {
            return NULL;
        }
        return func_com_asprise_ocr_version();
    }

    int CALL_CONVENTION c_com_asprise_ocr_setup(bool queryOnly) {
        if (!assertFuncExists(func_com_asprise_ocr_setup != NULL)) {
            return 0;
        }
        return func_com_asprise_ocr_setup(queryOnly);
    }

    char * c_com_asprise_ocr_list_supported_langs() {
        if (!assertFuncExists(func_com_asprise_ocr_list_supported_langs != NULL)) {
            return NULL;
        }
        return func_com_asprise_ocr_list_supported_langs();
    }

    long long c_com_asprise_ocr_start(const char * lang, const char * speed, const char * propSpec, const char * propSeparator, const char * propKeyValueSpeparator) {
        if (!assertFuncExists(func_com_asprise_ocr_start != NULL)) {
            return 0;
        }
        return func_com_asprise_ocr_start(lang, speed, propSpec, propSeparator, propKeyValueSpeparator);
    }

    char * c_com_asprise_ocr_recognize
        (long long handle, const char * imgFiles, int pageIndex, int startX, int startY, int width, int height, const char * recognizeType, const char * outputFormat, const char * propSpec, const char * propSeparator, const char * propKeyValueSpeparator) {
        if (!assertFuncExists(func_com_asprise_ocr_recognize != NULL)) {
            return NULL;
        }
        return func_com_asprise_ocr_recognize(handle, imgFiles, pageIndex, startX, startY, width, height, recognizeType, outputFormat, propSpec, propSeparator, propKeyValueSpeparator);
    }

    void c_com_asprise_ocr_stop(long long handle) {
        if (!assertFuncExists(func_com_asprise_ocr_stop != NULL)) {
            return;
        }
        func_com_asprise_ocr_stop(handle);
    }

    void c_com_asprise_ocr_input_license(const char * licenseeName, const char * licenseCode) {
        if (!assertFuncExists(func_com_asprise_ocr_input_license != NULL)) {
            return;
        }
        func_com_asprise_ocr_input_license(licenseeName, licenseCode);
    }

    void c_com_asprise_ocr_util_delete(long long handle, bool isArray) {
        if (!assertFuncExists(func_com_asprise_ocr_util_delete != NULL)) {
            return;
        }
        func_com_asprise_ocr_util_delete(handle, isArray);
    }

#endif // #ifndef SKIP_AOCR_DYNAMIC

#endif // ASPRISE_OCR_API_H