tesseract  3.03
/usr/local/google/home/jbreiden/tesseract-ocr-read-only/api/capi.cpp
Go to the documentation of this file.
00001 #ifndef TESS_CAPI_INCLUDE_BASEAPI
00002 #   define TESS_CAPI_INCLUDE_BASEAPI
00003 #endif
00004 #include "capi.h"
00005 #include "genericvector.h"
00006 #include "strngs.h"
00007 
00008 TESS_API const char* TESS_CALL TessVersion()
00009 {
00010     return TessBaseAPI::Version();
00011 }
00012 
00013 TESS_API void TESS_CALL TessDeleteText(char* text)
00014 {
00015     delete [] text;
00016 }
00017 
00018 TESS_API void TESS_CALL TessDeleteTextArray(char** arr)
00019 {
00020     for (char** pos = arr; *pos != NULL; ++pos)
00021         delete [] *pos;
00022     delete [] arr;
00023 }
00024 
00025 TESS_API void TESS_CALL TessDeleteIntArray(int* arr)
00026 {
00027     delete [] arr;
00028 }
00029 
00030 TESS_API void TESS_CALL TessDeleteBlockList(BLOCK_LIST* block_list)
00031 {
00032     TessBaseAPI::DeleteBlockList(block_list);
00033 }
00034 
00035 TESS_API TessResultRenderer* TESS_CALL TessTextRendererCreate()
00036 {
00037     return new TessTextRenderer;
00038 }
00039 
00040 TESS_API TessResultRenderer* TESS_CALL TessHOcrRendererCreate()
00041 {
00042     return new TessHOcrRenderer;
00043 }
00044 
00045 TESS_API TessResultRenderer* TESS_CALL TessPDFRendererCreate(const char* datadir)
00046 {
00047     return new TessPDFRenderer(datadir);
00048 }
00049 
00050 TESS_API TessResultRenderer* TESS_CALL TessUnlvRendererCreate()
00051 {
00052     return new TessUnlvRenderer;
00053 }
00054 
00055 TESS_API TessResultRenderer* TESS_CALL TessBoxTextRendererCreate()
00056 {
00057     return new TessBoxTextRenderer;
00058 }
00059 
00060 TESS_API void TESS_CALL TessDeleteResultRenderer(TessResultRenderer* renderer)
00061 {
00062     delete [] renderer;
00063 }
00064 
00065 TESS_API void TESS_CALL TessResultRendererInsert(TessResultRenderer* renderer, TessResultRenderer* next)
00066 {
00067     renderer->insert(next);
00068 }
00069 
00070 TESS_API TessResultRenderer* TESS_CALL TessResultRendererNext(TessResultRenderer* renderer)
00071 {
00072     return renderer->next();
00073 }
00074 
00075 TESS_API BOOL TESS_CALL TessResultRendererBeginDocument(TessResultRenderer* renderer, const char* title)
00076 {
00077     return renderer->BeginDocument(title);
00078 }
00079 
00080 TESS_API BOOL TESS_CALL TessResultRendererAddImage(TessResultRenderer* renderer, TessBaseAPI* api)
00081 {
00082     return renderer->AddImage(api);
00083 }
00084 
00085 TESS_API BOOL TESS_CALL TessResultRendererAddError(TessResultRenderer* renderer, TessBaseAPI* api)
00086 {
00087     return renderer->AddError(api);
00088 }
00089 
00090 TESS_API BOOL TESS_CALL TessResultRendererEndDocument(TessResultRenderer* renderer)
00091 {
00092     return renderer->EndDocument();
00093 }
00094 
00095 TESS_API BOOL TESS_CALL TessResultRendererGetOutput(TessResultRenderer* renderer, const char** data, int* data_len)
00096 {
00097     const char* tmp_data;
00098     int tmp_data_len;
00099     bool boolValue = renderer->GetOutput(&tmp_data, &tmp_data_len);
00100     *data = tmp_data;
00101     *data_len = tmp_data_len;
00102     return boolValue;
00103 }
00104 
00105 TESS_API const char* TESS_CALL TessResultRendererTypename(TessResultRenderer* renderer)
00106 {
00107     return renderer->full_typename();
00108 }
00109 
00110 TESS_API const char* TESS_CALL TessResultRendererExtention(TessResultRenderer* renderer)
00111 {
00112     return renderer->file_extension();
00113 }
00114 
00115 TESS_API const char* TESS_CALL TessResultRendererTitle(TessResultRenderer* renderer)
00116 {
00117     return renderer->title();
00118 }
00119 
00120 TESS_API int TESS_CALL TessResultRendererImageNum(TessResultRenderer* renderer)
00121 {
00122     return renderer->imagenum();
00123 }
00124 
00125 TESS_API TessBaseAPI* TESS_CALL TessBaseAPICreate()
00126 {
00127     return new TessBaseAPI;
00128 }
00129 
00130 TESS_API void TESS_CALL TessBaseAPIDelete(TessBaseAPI* handle)
00131 {
00132     delete handle;
00133 }
00134 
00135 TESS_API size_t TESS_CALL TessBaseAPIGetOpenCLDevice(TessBaseAPI* handle, void **device)
00136 {
00137     return handle->getOpenCLDevice(device);
00138 }
00139 
00140 TESS_API void TESS_CALL TessBaseAPISetInputName(TessBaseAPI* handle, const char* name)
00141 {
00142     handle->SetInputName(name);
00143 }
00144 
00145 TESS_API const char* TESS_CALL TessBaseAPIGetInputName(TessBaseAPI* handle)
00146 {
00147     return handle->GetInputName();
00148 }
00149 
00150 TESS_API void TESS_CALL TessBaseAPISetInputImage(TessBaseAPI* handle, Pix* pix)
00151 {
00152     handle->SetInputImage(pix);
00153 }
00154 
00155 TESS_API Pix* TESS_CALL TessBaseAPIGetInputImage(TessBaseAPI* handle)
00156 {
00157     return handle->GetInputImage();
00158 }
00159 
00160 TESS_API int TESS_CALL TessBaseAPIGetSourceYResolution(TessBaseAPI* handle)
00161 {
00162     return handle->GetSourceYResolution();
00163 }
00164 
00165 TESS_API const char* TESS_CALL TessBaseAPIGetDatapath(TessBaseAPI* handle)
00166 {
00167     return handle->GetDatapath();
00168 }
00169 
00170 TESS_API void TESS_CALL TessBaseAPISetOutputName(TessBaseAPI* handle, const char* name)
00171 {
00172     handle->SetOutputName(name);
00173 }
00174 
00175 TESS_API BOOL TESS_CALL TessBaseAPISetVariable(TessBaseAPI* handle, const char* name, const char* value)
00176 {
00177     return handle->SetVariable(name, value) ? TRUE : FALSE;
00178 }
00179 
00180 TESS_API BOOL TESS_CALL TessBaseAPISetDebugVariable(TessBaseAPI* handle, const char* name, const char* value)
00181 {
00182     return handle->SetVariable(name, value) ? TRUE : FALSE;
00183 }
00184 
00185 TESS_API BOOL TESS_CALL TessBaseAPIGetIntVariable(const TessBaseAPI* handle, const char* name, int* value)
00186 {
00187     return handle->GetIntVariable(name, value) ? TRUE : FALSE;
00188 }
00189 
00190 TESS_API BOOL TESS_CALL TessBaseAPIGetBoolVariable(const TessBaseAPI* handle, const char* name, BOOL* value)
00191 {
00192     bool boolValue;
00193     if (handle->GetBoolVariable(name, &boolValue))
00194     {
00195         *value = boolValue ? TRUE : FALSE;
00196         return TRUE;
00197     }
00198     else
00199     {
00200         return FALSE;
00201     }
00202 }
00203 
00204 TESS_API BOOL TESS_CALL TessBaseAPIGetDoubleVariable(const TessBaseAPI* handle, const char* name, double* value)
00205 {
00206     return handle->GetDoubleVariable(name, value) ? TRUE : FALSE;
00207 }
00208 
00209 TESS_API const char* TESS_CALL TessBaseAPIGetStringVariable(const TessBaseAPI* handle, const char* name)
00210 {
00211     return handle->GetStringVariable(name);
00212 }
00213 
00214 TESS_API void TESS_CALL TessBaseAPIPrintVariables(const TessBaseAPI* handle, FILE* fp)
00215 {
00216     handle->PrintVariables(fp);
00217 }
00218 
00219 TESS_API BOOL TESS_CALL TessBaseAPIPrintVariablesToFile(const TessBaseAPI* handle, const char* filename)
00220 {
00221     FILE* fp = fopen(filename, "w");
00222     if (fp != NULL)
00223     {
00224         handle->PrintVariables(fp);
00225         fclose(fp);
00226         return TRUE;
00227     }
00228     return FALSE;
00229 }
00230 
00231 TESS_API BOOL TESS_CALL TessBaseAPIGetVariableAsString(TessBaseAPI* handle, const char* name, STRING* val)
00232 {
00233     return handle->GetVariableAsString(name, val) ? TRUE : FALSE;
00234 }
00235 
00236 TESS_API int TESS_CALL TessBaseAPIInit4(TessBaseAPI* handle, const char* datapath, const char* language,
00237     TessOcrEngineMode mode, char** configs, int configs_size,
00238     char** vars_vec, char** vars_values, size_t vars_vec_size,
00239     BOOL set_only_non_debug_params)
00240 {
00241     GenericVector<STRING> varNames;
00242     GenericVector<STRING> varValues;
00243     if (vars_vec != NULL && vars_values != NULL) {
00244         for (size_t i = 0; i < vars_vec_size; i++) {
00245             varNames.push_back(STRING(vars_vec[i]));
00246             varValues.push_back(STRING(vars_values[i]));
00247         }
00248     }
00249 
00250     return handle->Init(datapath, language, mode, configs, configs_size, &varNames, &varValues, set_only_non_debug_params);
00251 }
00252 
00253 
00254 TESS_API int TESS_CALL TessBaseAPIInit1(TessBaseAPI* handle, const char* datapath, const char* language, TessOcrEngineMode oem,
00255                                         char** configs, int configs_size)
00256 {
00257     return handle->Init(datapath, language, oem, configs, configs_size, NULL, NULL, false);
00258 }
00259 
00260 TESS_API int TESS_CALL TessBaseAPIInit2(TessBaseAPI* handle, const char* datapath, const char* language, TessOcrEngineMode oem)
00261 {
00262     return handle->Init(datapath, language, oem);
00263 }
00264 
00265 TESS_API int TESS_CALL TessBaseAPIInit3(TessBaseAPI* handle, const char* datapath, const char* language)
00266 {
00267     return handle->Init(datapath, language);
00268 }
00269 
00270 TESS_API const char* TESS_CALL TessBaseAPIGetInitLanguagesAsString(const TessBaseAPI* handle)
00271 {
00272     return handle->GetInitLanguagesAsString();
00273 }
00274 
00275 TESS_API char** TESS_CALL TessBaseAPIGetLoadedLanguagesAsVector(const TessBaseAPI* handle)
00276 {
00277     GenericVector<STRING> languages;
00278     handle->GetLoadedLanguagesAsVector(&languages);
00279     char** arr = new char*[languages.size() + 1];
00280     for (int index = 0; index < languages.size(); ++index)
00281         arr[index] = languages[index].strdup();
00282     arr[languages.size()] = NULL;
00283     return arr;
00284 }
00285 
00286 TESS_API char** TESS_CALL TessBaseAPIGetAvailableLanguagesAsVector(const TessBaseAPI* handle)
00287 {
00288     GenericVector<STRING> languages;
00289     handle->GetAvailableLanguagesAsVector(&languages);
00290     char** arr = new char*[languages.size() + 1];
00291     for (int index = 0; index < languages.size(); ++index)
00292         arr[index] = languages[index].strdup();
00293     arr[languages.size()] = NULL;
00294     return arr;
00295 }
00296 
00297 TESS_API int TESS_CALL TessBaseAPIInitLangMod(TessBaseAPI* handle, const char* datapath, const char* language)
00298 {
00299     return handle->InitLangMod(datapath, language);
00300 }
00301 
00302 TESS_API void TESS_CALL TessBaseAPIInitForAnalysePage(TessBaseAPI* handle)
00303 {
00304     handle->InitForAnalysePage();
00305 }
00306 
00307 TESS_API void TESS_CALL TessBaseAPIReadConfigFile(TessBaseAPI* handle, const char* filename)
00308 {
00309     handle->ReadConfigFile(filename);
00310 }
00311 
00312 TESS_API void TESS_CALL TessBaseAPIReadDebugConfigFile(TessBaseAPI* handle, const char* filename)
00313 {
00314     handle->ReadDebugConfigFile(filename);
00315 }
00316 
00317 TESS_API void TESS_CALL TessBaseAPISetPageSegMode(TessBaseAPI* handle, TessPageSegMode mode)
00318 {
00319     handle->SetPageSegMode(mode);
00320 }
00321 
00322 TESS_API TessPageSegMode TESS_CALL TessBaseAPIGetPageSegMode(const TessBaseAPI* handle)
00323 {
00324     return handle->GetPageSegMode();
00325 }
00326 
00327 TESS_API char* TESS_CALL TessBaseAPIRect(TessBaseAPI* handle, const unsigned char* imagedata,
00328                                                int bytes_per_pixel, int bytes_per_line,
00329                                                int left, int top, int width, int height)
00330 {
00331     return handle->TesseractRect(imagedata, bytes_per_pixel, bytes_per_line, left, top, width, height);
00332 }
00333 
00334 TESS_API void TESS_CALL TessBaseAPIClearAdaptiveClassifier(TessBaseAPI* handle)
00335 {
00336     handle->ClearAdaptiveClassifier();
00337 }
00338 
00339 TESS_API void TESS_CALL TessBaseAPISetImage(TessBaseAPI* handle, const unsigned char* imagedata, int width, int height,
00340                                                   int bytes_per_pixel, int bytes_per_line)
00341 {
00342     handle->SetImage(imagedata, width, height, bytes_per_pixel, bytes_per_line);
00343 }
00344 
00345 TESS_API void TESS_CALL TessBaseAPISetImage2(TessBaseAPI* handle, const struct Pix* pix)
00346 {
00347     return handle->SetImage(pix);
00348 }
00349 
00350 TESS_API void TESS_CALL TessBaseAPISetSourceResolution(TessBaseAPI* handle, int ppi)
00351 {
00352     handle->SetSourceResolution(ppi);
00353 }
00354 
00355 TESS_API void TESS_CALL TessBaseAPISetRectangle(TessBaseAPI* handle, int left, int top, int width, int height)
00356 {
00357     handle->SetRectangle(left, top, width, height);
00358 }
00359 
00360 TESS_API void TESS_CALL TessBaseAPISetThresholder(TessBaseAPI* handle, TessImageThresholder* thresholder)
00361 {
00362     handle->SetThresholder(thresholder);
00363 }
00364 
00365 TESS_API struct Pix* TESS_CALL TessBaseAPIGetThresholdedImage(TessBaseAPI* handle)
00366 {
00367     return handle->GetThresholdedImage();
00368 }
00369 
00370 TESS_API struct Boxa* TESS_CALL TessBaseAPIGetRegions(TessBaseAPI* handle, struct Pixa** pixa)
00371 {
00372     return handle->GetRegions(pixa);
00373 }
00374 
00375 TESS_API struct Boxa* TESS_CALL TessBaseAPIGetTextlines(TessBaseAPI* handle, struct Pixa** pixa, int** blockids)
00376 {
00377     return handle->GetTextlines(pixa, blockids);
00378 }
00379 
00380 TESS_API struct Boxa* TESS_CALL TessBaseAPIGetTextlines1(TessBaseAPI* handle, const BOOL raw_image, const int raw_padding,
00381                                                                   struct Pixa** pixa, int** blockids, int** paraids)
00382 {
00383     return handle->GetTextlines(raw_image, raw_padding, pixa, blockids, paraids);
00384 }
00385 
00386 TESS_API struct Boxa* TESS_CALL TessBaseAPIGetStrips(TessBaseAPI* handle, struct Pixa** pixa, int** blockids)
00387 {
00388     return handle->GetStrips(pixa, blockids);
00389 }
00390 
00391 TESS_API struct Boxa* TESS_CALL TessBaseAPIGetWords(TessBaseAPI* handle, struct Pixa** pixa)
00392 {
00393     return handle->GetWords(pixa);
00394 }
00395 
00396 TESS_API struct Boxa* TESS_CALL TessBaseAPIGetConnectedComponents(TessBaseAPI* handle, struct Pixa** cc)
00397 {
00398     return handle->GetConnectedComponents(cc);
00399 }
00400 
00401 TESS_API struct Boxa* TESS_CALL TessBaseAPIGetComponentImages(TessBaseAPI* handle, TessPageIteratorLevel level, BOOL text_only, struct Pixa** pixa, int** blockids)
00402 {
00403     return handle->GetComponentImages(level, text_only != FALSE, pixa, blockids);
00404 }
00405 
00406 TESS_API struct Boxa*
00407                TESS_CALL TessBaseAPIGetComponentImages1(   TessBaseAPI* handle, const TessPageIteratorLevel level, const BOOL text_only,
00408                                                            const BOOL raw_image, const int raw_padding,
00409                                                            struct Pixa** pixa, int** blockids, int** paraids)
00410 {
00411     return handle->GetComponentImages(level, text_only != FALSE, raw_image, raw_padding, pixa, blockids, paraids);
00412 }
00413 
00414 TESS_API int TESS_CALL TessBaseAPIGetThresholdedImageScaleFactor(const TessBaseAPI* handle)
00415 {
00416     return handle->GetThresholdedImageScaleFactor();
00417 }
00418 
00419 TESS_API void TESS_CALL TessBaseAPIDumpPGM(TessBaseAPI* handle, const char* filename)
00420 {
00421     handle->DumpPGM(filename);
00422 }
00423 
00424 TESS_API TessPageIterator* TESS_CALL TessBaseAPIAnalyseLayout(TessBaseAPI* handle)
00425 {
00426     return handle->AnalyseLayout();
00427 }
00428 
00429 TESS_API int TESS_CALL TessBaseAPIRecognize(TessBaseAPI* handle, ETEXT_DESC* monitor)
00430 {
00431     return handle->Recognize(monitor);
00432 }
00433 
00434 TESS_API int TESS_CALL TessBaseAPIRecognizeForChopTest(TessBaseAPI* handle, ETEXT_DESC* monitor)
00435 {
00436     return handle->RecognizeForChopTest(monitor);
00437 }
00438 
00439 TESS_API char* TESS_CALL TessBaseAPIProcessPages(TessBaseAPI* handle, const char* filename, const char* retry_config,
00440                                                  int timeout_millisec)
00441 {
00442     STRING text_out;
00443     if (handle->ProcessPages(filename, retry_config, timeout_millisec, &text_out))
00444         return text_out.strdup();
00445     else
00446         return NULL;
00447 }
00448 
00449 TESS_API BOOL TessBaseAPIProcessPages1(TessBaseAPI* handle, const char* filename, const char* retry_config,
00450                                                  int timeout_millisec, TessResultRenderer* renderer)
00451 {
00452     if (handle->ProcessPages(filename, retry_config, timeout_millisec, renderer))    
00453         return TRUE;
00454     else
00455         return FALSE;
00456 }
00457 
00458 TESS_API char* TESS_CALL TessBaseAPIProcessPage(TessBaseAPI* handle, struct Pix* pix, int page_index, const char* filename,
00459                                                 const char* retry_config, int timeout_millisec)
00460 {
00461     STRING text_out;
00462     if (handle->ProcessPage(pix, page_index, filename, retry_config, timeout_millisec, &text_out))
00463         return text_out.strdup();
00464     else
00465         return NULL;
00466 }
00467 
00468 TESS_API BOOL TessBaseAPIProcessPage1(TessBaseAPI* handle, struct Pix* pix, int page_index, const char* filename,
00469                                       const char* retry_config, int timeout_millisec, TessResultRenderer* renderer)
00470 {
00471     if (handle->ProcessPage(pix, page_index, filename, retry_config, timeout_millisec, renderer))
00472         return TRUE;
00473     else
00474         return FALSE;
00475 }
00476 
00477 TESS_API TessResultIterator* TESS_CALL TessBaseAPIGetIterator(TessBaseAPI* handle)
00478 {
00479     return handle->GetIterator();
00480 }
00481 
00482 TESS_API TessMutableIterator* TESS_CALL TessBaseAPIGetMutableIterator(TessBaseAPI* handle)
00483 {
00484     return handle->GetMutableIterator();
00485 }
00486 
00487 TESS_API char* TESS_CALL TessBaseAPIGetUTF8Text(TessBaseAPI* handle)
00488 {
00489     return handle->GetUTF8Text();
00490 }
00491 
00492 TESS_API char* TESS_CALL TessBaseAPIGetHOCRText(TessBaseAPI* handle, int page_number)
00493 {
00494     return handle->GetHOCRText(page_number);
00495 }
00496 
00497 TESS_API char* TESS_CALL TessBaseAPIGetBoxText(TessBaseAPI* handle, int page_number)
00498 {
00499     return handle->GetBoxText(page_number);
00500 }
00501 
00502 TESS_API char* TESS_CALL TessBaseAPIGetUNLVText(TessBaseAPI* handle)
00503 {
00504     return handle->GetUNLVText();
00505 }
00506 
00507 TESS_API int TESS_CALL TessBaseAPIMeanTextConf(TessBaseAPI* handle)
00508 {
00509     return handle->MeanTextConf();
00510 }
00511 
00512 TESS_API int* TESS_CALL TessBaseAPIAllWordConfidences(TessBaseAPI* handle)
00513 {
00514     return handle->AllWordConfidences();
00515 }
00516 
00517 TESS_API BOOL TESS_CALL TessBaseAPIAdaptToWordStr(TessBaseAPI* handle, TessPageSegMode mode, const char* wordstr)
00518 {
00519     return handle->AdaptToWordStr(mode, wordstr) ? TRUE : FALSE;
00520 }
00521 
00522 TESS_API void TESS_CALL TessBaseAPIClear(TessBaseAPI* handle)
00523 {
00524     handle->Clear();
00525 }
00526 
00527 TESS_API void TESS_CALL TessBaseAPIEnd(TessBaseAPI* handle)
00528 {
00529     handle->End();
00530 }
00531 
00532 TESS_API int TESS_CALL TessBaseAPIIsValidWord(TessBaseAPI* handle, const char* word)
00533 {
00534     return handle->IsValidWord(word);
00535 }
00536 
00537 TESS_API BOOL TESS_CALL TessBaseAPIGetTextDirection(TessBaseAPI* handle, int* out_offset, float* out_slope)
00538 {
00539     return handle->GetTextDirection(out_offset, out_slope) ? TRUE : FALSE;
00540 }
00541 
00542 TESS_API void TESS_CALL TessBaseAPISetDictFunc(TessBaseAPI* handle, TessDictFunc f)
00543 {
00544     handle->SetDictFunc(f);
00545 }
00546 
00547 TESS_API void  TESS_CALL TessBaseAPIClearPersistentCache(TessBaseAPI* handle)
00548 {
00549     handle->ClearPersistentCache();
00550 }
00551 
00552 TESS_API void TESS_CALL TessBaseAPISetProbabilityInContextFunc(TessBaseAPI* handle, TessProbabilityInContextFunc f)
00553 {
00554     handle->SetProbabilityInContextFunc(f);
00555 }
00556 
00557 /*
00558  * Declared but not defined funcions in API
00559 
00560 TESS_API void  TESS_CALL TessBaseAPISetParamsModelClassifyFunc(TessBaseAPI* handle, TessParamsModelClassifyFunc f)
00561 {
00562     handle->SetParamsModelClassifyFunc(f);
00563 }
00564 
00565 TESS_API const char* TESS_CALL TessBaseAPIGetLastInitLanguage(const TessBaseAPI* handle)
00566 {
00567     return handle->GetLastInitLanguage();
00568 }
00569 */
00570 
00571 TESS_API BOOL TESS_CALL TessBaseAPIDetectOS(TessBaseAPI* handle, OSResults* results)
00572 {
00573     return handle->DetectOS(results) ? TRUE : FALSE;
00574 }
00575 
00576 TESS_API void TESS_CALL TessBaseAPIGetFeaturesForBlob(TessBaseAPI* handle, TBLOB* blob, INT_FEATURE_STRUCT* int_features,
00577                                                             int* num_features, int* FeatureOutlineIndex)
00578 {
00579     handle->GetFeaturesForBlob(blob, int_features, num_features, FeatureOutlineIndex);
00580 }
00581 
00582 TESS_API ROW* TESS_CALL TessFindRowForBox(BLOCK_LIST* blocks, int left, int top, int right, int bottom)
00583 {
00584     return TessBaseAPI::FindRowForBox(blocks, left, top, right, bottom);
00585 }
00586 
00587 TESS_API void TESS_CALL TessBaseAPIRunAdaptiveClassifier(TessBaseAPI* handle, TBLOB* blob, int num_max_matches,
00588                                                                int* unichar_ids, float* ratings, int* num_matches_returned)
00589 {
00590     handle->RunAdaptiveClassifier(blob, num_max_matches, unichar_ids, ratings, num_matches_returned);
00591 }
00592 
00593 TESS_API const char* TESS_CALL TessBaseAPIGetUnichar(TessBaseAPI* handle, int unichar_id)
00594 {
00595     return handle->GetUnichar(unichar_id);
00596 }
00597 
00598 TESS_API const TessDawg* TESS_CALL TessBaseAPIGetDawg(const TessBaseAPI* handle, int i)
00599 {
00600     return handle->GetDawg(i);
00601 }
00602 
00603 TESS_API int TESS_CALL TessBaseAPINumDawgs(const TessBaseAPI* handle)
00604 {
00605     return handle->NumDawgs();
00606 }
00607 
00608 TESS_API ROW* TESS_CALL TessMakeTessOCRRow(float baseline, float xheight, float descender, float ascender)
00609 {
00610     return TessBaseAPI::MakeTessOCRRow(baseline, xheight, descender, ascender);
00611 }
00612 
00613 TESS_API TBLOB* TESS_CALL TessMakeTBLOB(struct Pix* pix)
00614 {
00615     return TessBaseAPI::MakeTBLOB(pix);
00616 }
00617 
00618 TESS_API void TESS_CALL TessNormalizeTBLOB(TBLOB* tblob, ROW* row, BOOL numeric_mode)
00619 {
00620     TessBaseAPI::NormalizeTBLOB(tblob, row, numeric_mode != FALSE);
00621 }
00622 
00623 TESS_API TessOcrEngineMode TESS_CALL TessBaseAPIOem(const TessBaseAPI* handle)
00624 {
00625     return handle->oem();
00626 }
00627 
00628 TESS_API void TESS_CALL TessBaseAPIInitTruthCallback(TessBaseAPI* handle, TessTruthCallback* cb)
00629 {
00630     handle->InitTruthCallback(cb);
00631 }
00632 
00633 TESS_API TessCubeRecoContext* TESS_CALL TessBaseAPIGetCubeRecoContext(const TessBaseAPI* handle)
00634 {
00635     return handle->GetCubeRecoContext();
00636 }
00637 
00638 TESS_API void TESS_CALL TessBaseAPISetMinOrientationMargin(TessBaseAPI* handle, double margin)
00639 {
00640     handle->set_min_orientation_margin(margin);
00641 }
00642 
00643 TESS_API void TESS_CALL TessBaseGetBlockTextOrientations(TessBaseAPI* handle, int** block_orientation, bool** vertical_writing)
00644 {
00645     handle->GetBlockTextOrientations(block_orientation, vertical_writing);
00646 }
00647 
00648 TESS_API BLOCK_LIST* TESS_CALL TessBaseAPIFindLinesCreateBlockList(TessBaseAPI* handle)
00649 {
00650     return handle->FindLinesCreateBlockList();
00651 }
00652 
00653 TESS_API void  TESS_CALL TessPageIteratorDelete(TessPageIterator* handle)
00654 {
00655     delete handle;
00656 }
00657 
00658 TESS_API TessPageIterator* TESS_CALL TessPageIteratorCopy(const TessPageIterator* handle)
00659 {
00660     return new TessPageIterator(*handle);
00661 }
00662 
00663 TESS_API void TESS_CALL TessPageIteratorBegin(TessPageIterator* handle)
00664 {
00665     handle->Begin();
00666 }
00667 
00668 TESS_API BOOL TESS_CALL TessPageIteratorNext(TessPageIterator* handle, TessPageIteratorLevel level)
00669 {
00670     return handle->Next(level) ? TRUE : FALSE;
00671 }
00672 
00673 TESS_API BOOL TESS_CALL TessPageIteratorIsAtBeginningOf(const TessPageIterator* handle, TessPageIteratorLevel level)
00674 {
00675     return handle->IsAtBeginningOf(level) ? TRUE : FALSE;
00676 }
00677 
00678 TESS_API BOOL TESS_CALL TessPageIteratorIsAtFinalElement(const TessPageIterator* handle, TessPageIteratorLevel level,
00679                                                                TessPageIteratorLevel element)
00680 {
00681     return handle->IsAtFinalElement(level, element) ? TRUE : FALSE;
00682 }
00683 
00684 TESS_API BOOL TESS_CALL TessPageIteratorBoundingBox(const TessPageIterator* handle, TessPageIteratorLevel level,
00685                                                           int* left, int* top, int* right, int* bottom)
00686 {
00687     return handle->BoundingBox(level, left, top, right, bottom) ? TRUE : FALSE;
00688 }
00689 
00690 TESS_API TessPolyBlockType TESS_CALL TessPageIteratorBlockType(const TessPageIterator* handle)
00691 {
00692     return handle->BlockType();
00693 }
00694 
00695 TESS_API struct Pix* TESS_CALL TessPageIteratorGetBinaryImage(const TessPageIterator* handle, TessPageIteratorLevel level)
00696 {
00697     return handle->GetBinaryImage(level);
00698 }
00699 
00700 TESS_API struct Pix* TESS_CALL TessPageIteratorGetImage(const TessPageIterator* handle, TessPageIteratorLevel level, int padding,
00701                                                        int* left, int* top)
00702 {
00703     return handle->GetImage(level, padding, left, top);
00704 }
00705 
00706 TESS_API BOOL TESS_CALL TessPageIteratorBaseline(const TessPageIterator* handle, TessPageIteratorLevel level,
00707                                                        int* x1, int* y1, int* x2, int* y2)
00708 {
00709     return handle->Baseline(level, x1, y1, x2, y2) ? TRUE : FALSE;
00710 }
00711 
00712 TESS_API void TESS_CALL TessPageIteratorOrientation(TessPageIterator* handle, TessOrientation* orientation,
00713                                                           TessWritingDirection* writing_direction, TessTextlineOrder* textline_order,
00714                                                           float* deskew_angle)
00715 {
00716     handle->Orientation(orientation, writing_direction, textline_order, deskew_angle);
00717 }
00718 
00719 TESS_API void TESS_CALL TessResultIteratorDelete(TessResultIterator* handle)
00720 {
00721     delete handle;
00722 }
00723 
00724 TESS_API TessResultIterator* TESS_CALL TessResultIteratorCopy(const TessResultIterator* handle)
00725 {
00726     return new TessResultIterator(*handle);
00727 }
00728 
00729 TESS_API TessPageIterator* TESS_CALL TessResultIteratorGetPageIterator(TessResultIterator* handle)
00730 {
00731     return handle;
00732 }
00733 
00734 TESS_API const TessPageIterator* TESS_CALL TessResultIteratorGetPageIteratorConst(const TessResultIterator* handle)
00735 {
00736     return handle;
00737 }
00738 
00739 TESS_API char* TESS_CALL TessResultIteratorGetUTF8Text(const TessResultIterator* handle, TessPageIteratorLevel level)
00740 {
00741     return handle->GetUTF8Text(level);
00742 }
00743 
00744 TESS_API float TESS_CALL TessResultIteratorConfidence(const TessResultIterator* handle, TessPageIteratorLevel level)
00745 {
00746     return handle->Confidence(level);
00747 }
00748 
00749 TESS_API const char* TESS_CALL TessResultIteratorWordFontAttributes(const TessResultIterator* handle, BOOL* is_bold, BOOL* is_italic,
00750                                                                           BOOL* is_underlined, BOOL* is_monospace, BOOL* is_serif,
00751                                                                           BOOL* is_smallcaps, int* pointsize, int* font_id)
00752 {
00753     bool bool_is_bold, bool_is_italic, bool_is_underlined, bool_is_monospace, bool_is_serif, bool_is_smallcaps;
00754     const char* ret = handle->WordFontAttributes(&bool_is_bold, &bool_is_italic, &bool_is_underlined, &bool_is_monospace, &bool_is_serif,
00755                                                  &bool_is_smallcaps, pointsize, font_id);
00756     if (is_bold)
00757         *is_bold = bool_is_bold ? TRUE : FALSE;
00758     if (is_italic)
00759         *is_italic = bool_is_italic ? TRUE : FALSE;
00760     if (is_underlined)
00761         *is_underlined = bool_is_underlined ? TRUE : FALSE;
00762     if (is_monospace)
00763         *is_monospace = bool_is_monospace ? TRUE : FALSE;
00764     if (is_serif)
00765         *is_serif = bool_is_serif ? TRUE : FALSE;
00766     if (is_smallcaps)
00767         *is_smallcaps = bool_is_smallcaps ? TRUE : FALSE;
00768     return ret;
00769 }
00770 
00771 TESS_API BOOL TESS_CALL TessResultIteratorWordIsFromDictionary(const TessResultIterator* handle)
00772 {
00773     return handle->WordIsFromDictionary() ? TRUE : FALSE;
00774 }
00775 
00776 TESS_API BOOL TESS_CALL TessResultIteratorWordIsNumeric(const TessResultIterator* handle)
00777 {
00778     return handle->WordIsNumeric() ? TRUE : FALSE;
00779 }
00780 
00781 TESS_API BOOL TESS_CALL TessResultIteratorSymbolIsSuperscript(const TessResultIterator* handle)
00782 {
00783     return handle->SymbolIsSuperscript() ? TRUE : FALSE;
00784 }
00785 
00786 TESS_API BOOL TESS_CALL TessResultIteratorSymbolIsSubscript(const TessResultIterator* handle)
00787 {
00788     return handle->SymbolIsSubscript() ? TRUE : FALSE;
00789 }
00790 
00791 TESS_API BOOL TESS_CALL TessResultIteratorSymbolIsDropcap(const TessResultIterator* handle)
00792 {
00793     return handle->SymbolIsDropcap() ? TRUE : FALSE;
00794 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines