tesseractmain.cpp File Reference

#include <cerrno>
#include <iostream>
#include "allheaders.h"
#include <tesseract/baseapi.h>
#include "dict.h"
#include <tesseract/renderer.h>
#include "simddetect.h"
#include "tprintf.h"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 602 of file tesseractmain.cpp.

                                {
  const char* lang = nullptr;
  const char* image = nullptr;
  const char* outputbase = nullptr;
  const char* datapath = nullptr;
  bool list_langs = false;
  bool print_parameters = false;
  l_int32 dpi = 0;
  int arg_i = 1;
  tesseract::PageSegMode pagesegmode = tesseract::PSM_AUTO;
#ifdef DISABLED_LEGACY_ENGINE
  auto enginemode = tesseract::OEM_LSTM_ONLY;
#else
  tesseract::OcrEngineMode enginemode = tesseract::OEM_DEFAULT;
#endif
  /* main() calls functions like ParseArgs which call exit().
   * This results in memory leaks if vars_vec and vars_values are
   * declared as auto variables (destructor is not called then). */
  static GenericVector<STRING> vars_vec;
  static GenericVector<STRING> vars_values;
 
#if !defined(DEBUG)
  // Disable debugging and informational messages from Leptonica.
  setMsgSeverity(L_SEVERITY_ERROR);
#endif
 
#if defined(HAVE_TIFFIO_H) && defined(_WIN32)
  /* Show libtiff errors and warnings on console (not in GUI). */
  TIFFSetErrorHandler(Win32ErrorHandler);
  TIFFSetWarningHandler(Win32WarningHandler);
#endif // HAVE_TIFFIO_H && _WIN32
 
  ParseArgs(argc, argv, &lang, &image, &outputbase, &datapath, &dpi,
            &list_langs, &print_parameters, &vars_vec, &vars_values, &arg_i,
            &pagesegmode, &enginemode);
 
  if (lang == nullptr) {
    // Set default language if none was given.
    lang = "eng";
  }
 
  if (image == nullptr && !list_langs && !print_parameters)
    return EXIT_SUCCESS;
 
  // Call GlobalDawgCache here to create the global DawgCache object before
  // the TessBaseAPI object. This fixes the order of destructor calls:
  // first TessBaseAPI must be destructed, DawgCache must be the last object.
  tesseract::Dict::GlobalDawgCache();
 
  // Avoid memory leak caused by auto variable when return is called.
  static tesseract::TessBaseAPI api;
 
  api.SetOutputName(outputbase);
 
  const int init_failed = api.Init(datapath, lang, enginemode, &(argv[arg_i]),
                             argc - arg_i, &vars_vec, &vars_values, false);
 
  SetVariablesFromCLArgs(&api, argc, argv);
 
  // SIMD settings might be overridden by config variable.
  tesseract::SIMDDetect::Update();
 
  if (list_langs) {
    PrintLangsList(&api);
    return EXIT_SUCCESS;
  }
 
  if (init_failed) {
    fprintf(stderr, "Could not initialize tesseract.\n");
    return EXIT_FAILURE;
  }
 
  if (print_parameters) {
    FILE* fout = stdout;
    fprintf(stdout, "Tesseract parameters:\n");
    api.PrintVariables(fout);
    api.End();
    return EXIT_SUCCESS;
  }
 
  FixPageSegMode(&api, pagesegmode);
 
  if (dpi) {
    char dpi_string[255];
    snprintf(dpi_string, 254, "%d", dpi);
    api.SetVariable("user_defined_dpi", dpi_string);
  }
 
  if (pagesegmode == tesseract::PSM_AUTO_ONLY) {
    int ret_val = EXIT_SUCCESS;
 
    Pix* pixs = pixRead(image);
    if (!pixs) {
      fprintf(stderr, "Leptonica can't process input file: %s\n", image);
      return 2;
    }
 
    api.SetImage(pixs);
 
    tesseract::Orientation orientation;
    tesseract::WritingDirection direction;
    tesseract::TextlineOrder order;
    float deskew_angle;
 
    const tesseract::PageIterator* it = api.AnalyseLayout();
    if (it) {
      // TODO: Implement output of page segmentation, see documentation
      // ("Automatic page segmentation, but no OSD, or OCR").
      it->Orientation(&orientation, &direction, &order, &deskew_angle);
      tprintf(
          "Orientation: %d\nWritingDirection: %d\nTextlineOrder: %d\n"
          "Deskew angle: %.4f\n",
          orientation, direction, order, deskew_angle);
    } else {
      ret_val = EXIT_FAILURE;
    }
 
    delete it;
 
    pixDestroy(&pixs);
    return ret_val;
  }
 
  // Set in_training_mode to true when using one of these configs:
  // ambigs.train, box.train, box.train.stderr, linebox, rebox, lstm.train.
  // In this mode no other OCR result files are written.
  bool b = false;
  bool in_training_mode =
      (api.GetBoolVariable("tessedit_ambigs_training", &b) && b) ||
      (api.GetBoolVariable("tessedit_resegment_from_boxes", &b) && b) ||
      (api.GetBoolVariable("tessedit_make_boxes_from_boxes", &b) && b) ||
      (api.GetBoolVariable("tessedit_train_line_recognizer", &b) && b);
 
#ifdef DISABLED_LEGACY_ENGINE
  auto cur_psm = api.GetPageSegMode();
  auto osd_warning = std::string("");
  if (cur_psm == tesseract::PSM_OSD_ONLY) {
    const char* disabled_osd_msg =
        "\nERROR: The page segmentation mode 0 (OSD Only) is currently disabled.\n\n";
    fprintf(stderr, "%s",  disabled_osd_msg);
    return EXIT_FAILURE;
  } else if (cur_psm == tesseract::PSM_AUTO_OSD) {
      api.SetPageSegMode(tesseract::PSM_AUTO);
      osd_warning +=
          "\nWarning: The page segmentation mode 1 (Auto+OSD) is currently disabled. "
          "Using PSM 3 (Auto) instead.\n\n";
  } else if (cur_psm == tesseract::PSM_SPARSE_TEXT_OSD) {
      api.SetPageSegMode(tesseract::PSM_SPARSE_TEXT);
      osd_warning +=
          "\nWarning: The page segmentation mode 12 (Sparse text + OSD) is currently disabled. "
          "Using PSM 11 (Sparse text) instead.\n\n";
  }
#endif  // def DISABLED_LEGACY_ENGINE
 
  // Avoid memory leak caused by auto variable when exit() is called.
  static tesseract::PointerVector<tesseract::TessResultRenderer> renderers;
 
  if (in_training_mode) {
    renderers.push_back(nullptr);
  } else if (outputbase != nullptr) {
    PreloadRenderers(&api, &renderers, pagesegmode, outputbase);
  }
 
  bool banner = false;
  if (outputbase != nullptr && strcmp(outputbase, "-") &&
      strcmp(outputbase, "stdout")) {
    banner = true;
  }
 
  if (!renderers.empty()) {
    if (banner) PrintBanner();
#ifdef DISABLED_LEGACY_ENGINE
    if (!osd_warning.empty()) {
      fprintf(stderr, "%s",osd_warning.c_str());
    }
#endif
    bool succeed = api.ProcessPages(image, nullptr, 0, renderers[0]);
    if (!succeed) {
      fprintf(stderr, "Error during processing.\n");
      return EXIT_FAILURE;
    }
  }