tesseract::TessdataManager Class Reference

#include <tessdatamanager.h>

Public Member Functions
	TessdataManager ()
	~TessdataManager ()
int	DebugLevel ()
bool	Init (const char *data_file_name, int debug_level)
const STRING &	GetDataFileName () const
FILE *	GetDataFilePtr () const
bool	SeekToStart (TessdataType tessdata_type)
inT64	GetEndOffset (TessdataType tessdata_type) const
void	End ()
bool	swap () const
bool	OverwriteComponents (const char *new_traineddata_filename, char **component_filenames, int num_new_components)
bool	ExtractToFile (const char *filename)

Static Public Member Functions
static bool	WriteMetadata (inT64 *offset_table, const char *language_data_path_prefix, FILE *output_file)
static bool	CombineDataFiles (const char *language_data_path_prefix, const char *output_filename)
static void	CopyFile (FILE *input_file, FILE *output_file, bool newline_end, inT64 num_bytes_to_copy)
static bool	TessdataTypeFromFileSuffix (const char *suffix, TessdataType *type, bool *text_file)
static bool	TessdataTypeFromFileName (const char *filename, TessdataType *type, bool *text_file)

Detailed Description

Definition at line 133 of file tessdatamanager.h.

Constructor & Destructor Documentation

TessdataManager()

tesseract::TessdataManager::TessdataManager ( )

inline

Definition at line 135 of file tessdatamanager.h.

                    {
    data_file_ = NULL;
    actual_tessdata_num_entries_ = 0;
    for (int i = 0; i < TESSDATA_NUM_ENTRIES; ++i) {
      offset_table_[i] = -1;
    }
  }

~TessdataManager()

tesseract::TessdataManager::~TessdataManager ( )

inline

Definition at line 142 of file tessdatamanager.h.

{}

Member Function Documentation

CombineDataFiles()

bool tesseract::TessdataManager::CombineDataFiles ( const char *  language_data_path_prefix, const char *  output_filename  )

static

Reads all the standard tesseract config and data files for a language at the given path and bundles them up into one binary data file. Returns true if the combined traineddata file was successfully written.

Definition at line 127 of file tessdatamanager.cpp.

                                 {
  int i;
  inT64 offset_table[TESSDATA_NUM_ENTRIES];
  for (i = 0; i < TESSDATA_NUM_ENTRIES; ++i) offset_table[i] = -1;
  FILE *output_file = fopen(output_filename, "wb");
  if (output_file == NULL) {
    tprintf("Error opening %s for writing\n", output_filename);
    return false;
  }
  // Leave some space for recording the offset_table.
  if (fseek(output_file,
            sizeof(inT32) + sizeof(inT64) * TESSDATA_NUM_ENTRIES, SEEK_SET)) {
    tprintf("Error seeking %s\n", output_filename);
    fclose(output_file);
    return false;
  }

  TessdataType type = TESSDATA_NUM_ENTRIES;
  bool text_file = false;
  FILE *file_ptr[TESSDATA_NUM_ENTRIES];

  // Load individual tessdata components from files.
  for (i = 0; i < TESSDATA_NUM_ENTRIES; ++i) {
    ASSERT_HOST(TessdataTypeFromFileSuffix(
        kTessdataFileSuffixes[i], &type, &text_file));
    STRING filename = language_data_path_prefix;
    filename += kTessdataFileSuffixes[i];
    file_ptr[i] =  fopen(filename.string(), "rb");
    if (file_ptr[i] != NULL) {
      offset_table[type] = ftell(output_file);
      CopyFile(file_ptr[i], output_file, text_file, -1);
      fclose(file_ptr[i]);
    }
  }

  // Make sure that the required components are present.
  if (file_ptr[TESSDATA_UNICHARSET] == NULL) {
    tprintf("Error opening %sunicharset file\n", language_data_path_prefix);
    fclose(output_file);
    return false;
  }
  if (file_ptr[TESSDATA_INTTEMP] != NULL &&
      (file_ptr[TESSDATA_PFFMTABLE] == NULL ||
       file_ptr[TESSDATA_NORMPROTO] == NULL)) {
    tprintf("Error opening %spffmtable and/or %snormproto files"
            " while %sinttemp file was present\n", language_data_path_prefix,
            language_data_path_prefix, language_data_path_prefix);
    fclose(output_file);
    return false;
  }

  return WriteMetadata(offset_table, language_data_path_prefix, output_file);
}

CopyFile()

void tesseract::TessdataManager::CopyFile ( FILE *  input_file, FILE *  output_file, bool  newline_end, inT64  num_bytes_to_copy  )

static

Copies data from the given input file to the output_file provided. If num_bytes_to_copy is >= 0, only num_bytes_to_copy is copied from the input file, otherwise all the data in the input file is copied.

Definition at line 74 of file tessdatamanager.cpp.

                                                                          {
  if (num_bytes_to_copy == 0) return;
  int buffer_size = 1024;
  if (num_bytes_to_copy > 0 && buffer_size > num_bytes_to_copy) {
    buffer_size = num_bytes_to_copy;
  }
  inT64 num_bytes_copied = 0;
  char *chunk = new char[buffer_size];
  int bytes_read;
  char last_char = 0x0;
  while ((bytes_read = fread(chunk, sizeof(char),
                             buffer_size, input_file))) {
    fwrite(chunk, sizeof(char), bytes_read, output_file);
    last_char = chunk[bytes_read-1];
    if (num_bytes_to_copy > 0) {
      num_bytes_copied += bytes_read;
      if (num_bytes_copied == num_bytes_to_copy) break;
      if (num_bytes_copied + buffer_size > num_bytes_to_copy) {
        buffer_size = num_bytes_to_copy - num_bytes_copied;
      }
    }
  }
  if (newline_end) ASSERT_HOST(last_char == '\n');
  delete[] chunk;
}

DebugLevel()

int tesseract::TessdataManager::DebugLevel ( )

inline

Definition at line 143 of file tessdatamanager.h.

{ return debug_level_; }

End()

void tesseract::TessdataManager::End ( )

inline

Closes data_file_ (if it was opened by Init()).

Definition at line 192 of file tessdatamanager.h.

                    {
    if (data_file_ != NULL) {
      fclose(data_file_);
      data_file_ = NULL;
    }
  }

ExtractToFile()

bool tesseract::TessdataManager::ExtractToFile

(

const char *

filename

)

Extracts tessdata component implied by the name of the input file from the combined traineddata loaded into TessdataManager. Writes the extracted component to the file indicated by the file name. E.g. if the filename given is somepath/somelang.unicharset, unicharset will be extracted from the data loaded into the TessdataManager and will be written to somepath/somelang.unicharset.

Returns

true if the component was successfully extracted, false if the component was not present in the traineddata loaded into TessdataManager.

Definition at line 259 of file tessdatamanager.cpp.

                                                        {
  TessdataType type = TESSDATA_NUM_ENTRIES;
  bool text_file = false;
  ASSERT_HOST(tesseract::TessdataManager::TessdataTypeFromFileName(
      filename, &type, &text_file));
  if (!SeekToStart(type)) return false;

  FILE *output_file = fopen(filename, "wb");
  if (output_file == NULL) {
    tprintf("Error opening %s\n", filename);
    exit(1);
  }
  inT64 begin_offset = ftell(GetDataFilePtr());
  inT64 end_offset = GetEndOffset(type);
  tesseract::TessdataManager::CopyFile(
      GetDataFilePtr(), output_file, text_file,
      end_offset - begin_offset + 1);
  fclose(output_file);
  return true;
}

GetDataFileName()

const STRING& tesseract::TessdataManager::GetDataFileName ( ) const

inline

Definition at line 152 of file tessdatamanager.h.

{ return data_file_name_; }

GetDataFilePtr()

FILE* tesseract::TessdataManager::GetDataFilePtr ( ) const

inline

Returns data file pointer.

Definition at line 155 of file tessdatamanager.h.

{ return data_file_; }

GetEndOffset()

inT64 tesseract::TessdataManager::GetEndOffset ( TessdataType  tessdata_type ) const

inline

Returns the end offset for the given tesseract data file type.

Definition at line 178 of file tessdatamanager.h.

                                                              {
    int index = tessdata_type + 1;
    while (index < actual_tessdata_num_entries_ && offset_table_[index] == -1) {
      ++index;  // skip tessdata types not present in the combined file
    }
    if (debug_level_) {
      tprintf("TessdataManager: end offset for type %d is %lld\n",
              tessdata_type,
              (index == actual_tessdata_num_entries_) ? -1
              : offset_table_[index]);
    }
    return (index == actual_tessdata_num_entries_) ? -1 : offset_table_[index] - 1;
  }

Init()

bool tesseract::TessdataManager::Init	(	const char *	data_file_name,
		int	debug_level
	)

Opens the given data file and reads the offset table.

Returns

true on success.

Definition at line 36 of file tessdatamanager.cpp.

                                                                      {
  int i;
  debug_level_ = debug_level;
  data_file_name_ = data_file_name;
  data_file_ = fopen(data_file_name, "rb");
  if (data_file_ == NULL) {
    tprintf("Error opening data file %s\n", data_file_name);
    tprintf("Please make sure the TESSDATA_PREFIX environment variable is set "
            "to the parent directory of your \"tessdata\" directory.\n");
    return false;
  }
  fread(&actual_tessdata_num_entries_, sizeof(inT32), 1, data_file_);
  swap_ = (actual_tessdata_num_entries_ > kMaxNumTessdataEntries);
  if (swap_) {
    ReverseN(&actual_tessdata_num_entries_,
             sizeof(actual_tessdata_num_entries_));
  }
  if (actual_tessdata_num_entries_ > TESSDATA_NUM_ENTRIES) {
    // For forward compatibility, truncate to the number we can handle.
    actual_tessdata_num_entries_ = TESSDATA_NUM_ENTRIES;
  }
  fread(offset_table_, sizeof(inT64),
        actual_tessdata_num_entries_, data_file_);
  if (swap_) {
    for (i = 0 ; i < actual_tessdata_num_entries_; ++i) {
      ReverseN(&offset_table_[i], sizeof(offset_table_[i]));
    }
  }
  if (debug_level_) {
    tprintf("TessdataManager loaded %d types of tesseract data files.\n",
            actual_tessdata_num_entries_);
    for (i = 0; i < actual_tessdata_num_entries_; ++i) {
      tprintf("Offset for type %d is %lld\n", i, offset_table_[i]);
    }
  }
  return true;
}

OverwriteComponents()

bool tesseract::TessdataManager::OverwriteComponents	(	const char *	new_traineddata_filename,
		char **	component_filenames,
		int	num_new_components
	)

Gets the individual components from the data_file_ with which the class was initialized. Overwrites the components specified by component_filenames. Writes the updated traineddata file to new_traineddata_filename.

Definition at line 183 of file tessdatamanager.cpp.

                            {
  int i;
  inT64 offset_table[TESSDATA_NUM_ENTRIES];
  TessdataType type = TESSDATA_NUM_ENTRIES;
  bool text_file = false;
  FILE *file_ptr[TESSDATA_NUM_ENTRIES];
  for (i = 0; i < TESSDATA_NUM_ENTRIES; ++i) {
    offset_table[i] = -1;
    file_ptr[i] = NULL;
  }
  FILE *output_file = fopen(new_traineddata_filename, "wb");
  if (output_file == NULL) {
    tprintf("Error opening %s for writing\n", new_traineddata_filename);
    return false;
  }

  // Leave some space for recording the offset_table.
  if (fseek(output_file,
            sizeof(inT32) + sizeof(inT64) * TESSDATA_NUM_ENTRIES, SEEK_SET)) {
    fclose(output_file);
    tprintf("Error seeking %s\n", new_traineddata_filename);
    return false;
  }

  // Open the files with the new components.
  for (i = 0; i < num_new_components; ++i) {
    if (TessdataTypeFromFileName(component_filenames[i], &type, &text_file))
      file_ptr[type] = fopen(component_filenames[i], "rb");
  }

  // Write updated data to the output traineddata file.
  for (i = 0; i < TESSDATA_NUM_ENTRIES; ++i) {
    if (file_ptr[i] != NULL) {
      // Get the data from the opened component file.
      offset_table[i] = ftell(output_file);
      CopyFile(file_ptr[i], output_file, kTessdataFileIsText[i], -1);
      fclose(file_ptr[i]);
    } else {
      // Get this data component from the loaded data file.
      if (SeekToStart(static_cast<TessdataType>(i))) {
        offset_table[i] = ftell(output_file);
        CopyFile(data_file_, output_file, kTessdataFileIsText[i],
                 GetEndOffset(static_cast<TessdataType>(i)) -
                 ftell(data_file_) + 1);
      }
    }
  }
  const char *language_data_path_prefix = strchr(new_traineddata_filename, '.');
  return WriteMetadata(offset_table, language_data_path_prefix, output_file);
}

SeekToStart()

bool tesseract::TessdataManager::SeekToStart ( TessdataType  tessdata_type )

inline

Returns false if there is no data of the given type. Otherwise does a seek on the data_file_ to position the pointer at the start of the data of the given type.

Definition at line 162 of file tessdatamanager.h.

                                                      {
    if (debug_level_) {
      tprintf("TessdataManager: seek to offset %lld - start of tessdata"
              "type %d (%s))\n", offset_table_[tessdata_type],
              tessdata_type, kTessdataFileSuffixes[tessdata_type]);
    }
    if (offset_table_[tessdata_type] < 0) {
      return false;
    } else {
      ASSERT_HOST(fseek(data_file_,
                        static_cast<size_t>(offset_table_[tessdata_type]),
                        SEEK_SET) == 0);
      return true;
    }
  }

swap()

bool tesseract::TessdataManager::swap ( ) const

inline

Definition at line 198 of file tessdatamanager.h.

                    {
    return swap_;
  }

TessdataTypeFromFileName()

bool tesseract::TessdataManager::TessdataTypeFromFileName ( const char *  filename, TessdataType *  type, bool *  text_file  )

static

Tries to determine tessdata component file suffix from filename, returns true on success.

Definition at line 251 of file tessdatamanager.cpp.

                                                               {
  // Get the file suffix (extension)
  const char *suffix = strrchr(filename, '.');
  if (suffix == NULL || *(++suffix) == '\0') return false;
  return TessdataTypeFromFileSuffix(suffix, type, text_file);
}

TessdataTypeFromFileSuffix()

bool tesseract::TessdataManager::TessdataTypeFromFileSuffix ( const char *  suffix, TessdataType *  type, bool *  text_file  )

static

Fills type with TessdataType of the tessdata component represented by the given file name. E.g. tessdata/eng.unicharset -> TESSDATA_UNICHARSET. Sets *text_file to true if the component is in text format (e.g. unicharset, unichar ambigs, config, etc).

Returns

true if the tessdata component type could be determined from the given file name.

Definition at line 237 of file tessdatamanager.cpp.

                                                             {
  for (int i = 0; i < TESSDATA_NUM_ENTRIES; ++i) {
    if (strcmp(kTessdataFileSuffixes[i], suffix) == 0) {
      *type = static_cast<TessdataType>(i);
      *text_file = kTessdataFileIsText[i];
      return true;
    }
  }
  tprintf("TessdataManager can't determine which tessdata"
         " component is represented by %s\n", suffix);
  return false;
}

WriteMetadata()

bool tesseract::TessdataManager::WriteMetadata ( inT64 *  offset_table, const char *  language_data_path_prefix, FILE *  output_file  )

static

Writes the number of entries and the given offset table to output_file. Returns false on error.

Definition at line 101 of file tessdatamanager.cpp.

                                                       {
  inT32 num_entries = TESSDATA_NUM_ENTRIES;
  bool result = true;
  if (fseek(output_file, 0, SEEK_SET) != 0 ||
      fwrite(&num_entries, sizeof(inT32), 1, output_file) != 1 ||
      fwrite(offset_table, sizeof(inT64), TESSDATA_NUM_ENTRIES,
             output_file) != TESSDATA_NUM_ENTRIES) {
    fclose(output_file);
    result = false;
    tprintf("WriteMetadata failed in TessdataManager!\n");
  } else if (fclose(output_file)) {
    result = false;
    tprintf("WriteMetadata failed to close file!\n");
  } else {
    tprintf("TessdataManager combined tesseract data files.\n");
    for (int i = 0; i < TESSDATA_NUM_ENTRIES; ++i) {
      tprintf("Offset for type %2d (%s%-22s) is %lld\n", i,
              language_data_path_prefix, kTessdataFileSuffixes[i],
              offset_table[i]);
    }
  }
  return result;
}

---

The documentation for this class was generated from the following files:

• ccutil/tessdatamanager.h
• ccutil/tessdatamanager.cpp