tesseract::Dict Class Reference

#include <dict.h>

List of all members.

Public Member Functions

 Dict (Image *image_ptr)
 ~Dict ()
ImagegetImage ()
UNICHARSETgetUnicharset ()
const UnicharAmbigsgetUnicharAmbigs ()
bool hyphenated ()
 Returns true if we've recorded the beginning of a hyphenated word.
int hyphen_base_size ()
 Size of the base word (the part on the line before) of a hyphenated word.
void copy_hyphen_info (WERD_CHOICE *word)
void remove_hyphen_head (WERD_CHOICE *word)
bool has_hyphen_end (const WERD_CHOICE &word)
 Check whether the word has a hyphen at the end.
void reset_hyphen_vars (bool last_word_on_line)
void set_hyphen_word (const WERD_CHOICE &word, const DawgInfoVector &active_dawgs, const DawgInfoVector &constraints)
void update_best_choice (const WERD_CHOICE &word, WERD_CHOICE *best_choice)
void init_active_dawgs (DawgInfoVector *active_dawgs)
void init_constraints (DawgInfoVector *constraints)
WERD_CHOICEdawg_permute_and_select (const BLOB_CHOICE_LIST_VECTOR &char_choices, float rating_limit)
void adjust_word (WERD_CHOICE *best_choice, float *certainty_array)
void go_deeper_dawg_fxn (const char *debug, const BLOB_CHOICE_LIST_VECTOR &char_choices, int char_choice_index, const CHAR_FRAGMENT_INFO *prev_char_frag_info, bool word_ending, WERD_CHOICE *word, float certainties[], float *limit, WERD_CHOICE *best_choice, void *void_more_args)
void add_document_word (const WERD_CHOICE &best_choice)
void init_permute ()
WERD_CHOICEpermute_top_choice (const BLOB_CHOICE_LIST_VECTOR &char_choices, float *rating_limit, WERD_CHOICE *raw_choice, BOOL8 *any_alpha)
const char * choose_il1 (const char *first_char, const char *second_char, const char *third_char, const char *prev_char, const char *next_char, const char *next_next_char)
int valid_word (const WERD_CHOICE &word)
int valid_word_or_number (const WERD_CHOICE &word)
int valid_word (const WERD_CHOICE &word, bool numbers_ok)
bool valid_punctuation (const WERD_CHOICE &word)
WERD_CHOICEpermute_all (const BLOB_CHOICE_LIST_VECTOR &char_choices, float rating_limit, WERD_CHOICE *raw_choice)
void end_permute ()
void adjust_non_word (WERD_CHOICE *word, float *adjust_factor)
void permute_subword (const BLOB_CHOICE_LIST_VECTOR &char_choices, float rating_limit, int start, int end, WERD_CHOICE *current_word)
void permute_characters (const BLOB_CHOICE_LIST_VECTOR &char_choices, float limit, WERD_CHOICE *best_choice, WERD_CHOICE *raw_choice)
WERD_CHOICEpermute_compound_words (const BLOB_CHOICE_LIST_VECTOR &char_choices, float rating_limit)
bool word_script_eq (const BLOB_CHOICE_LIST_VECTOR &char_choices, int target_script_id)
 checks if the dominant word script, if there is one, is same as target.
void incorporate_segcost (WERD_CHOICE *word)
 Incoporate segmentation cost into word rating.
WERD_CHOICEpermute_script_words (const BLOB_CHOICE_LIST_VECTOR &char_choices)
 checks for script-consistent permutations
WERD_CHOICEtop_fragments_permute_and_select (const BLOB_CHOICE_LIST_VECTOR &char_choices, float rating_limit)
void go_deeper_top_fragments_fxn (const char *debug, const BLOB_CHOICE_LIST_VECTOR &char_choices, int char_choice_index, const CHAR_FRAGMENT_INFO *prev_char_frag_info, bool word_ending, WERD_CHOICE *word, float certainties[], float *limit, WERD_CHOICE *best_choice, void *more_args)
bool fragment_state_okay (UNICHAR_ID curr_unichar_id, float curr_rating, float curr_certainty, const CHAR_FRAGMENT_INFO *prev_char_frag_info, const char *debug, int word_ending, CHAR_FRAGMENT_INFO *char_frag_info)
 Semi-generic functions used by multiple permuters.
void permute_choices (const char *debug, const BLOB_CHOICE_LIST_VECTOR &char_choices, int char_choice_index, const CHAR_FRAGMENT_INFO *prev_char_frag_info, WERD_CHOICE *word, float certainties[], float *limit, WERD_CHOICE *best_choice, void *more_args)
void append_choices (const char *debug, const BLOB_CHOICE_LIST_VECTOR &char_choices, const BLOB_CHOICE &blob_choice, int char_choice_index, const CHAR_FRAGMENT_INFO *prev_char_frag_info, WERD_CHOICE *word, float certainties[], float *limit, WERD_CHOICE *best_choice, void *more_args)
int NoDangerousAmbig (WERD_CHOICE *BestChoice, DANGERR *fixpt, bool fix_replaceable, BLOB_CHOICE_LIST_VECTOR *Choices, bool *modified_blobs)
void ReplaceAmbig (int wrong_ngram_begin_index, int wrong_ngram_size, UNICHAR_ID correct_ngram_id, WERD_CHOICE *werd_choice, BLOB_CHOICE_LIST_VECTOR *blob_choices, bool *modified_blobs)
void DisableChoiceAccum ()
void EnableChoiceAccum ()
int LengthOfShortestAlphaRun (const WERD_CHOICE &WordChoice)
VIABLE_CHOICE NewViableChoice (const WERD_CHOICE &WordChoice, FLOAT32 AdjustFactor, const float Certainties[])
void PrintViableChoice (FILE *File, const char *Label, VIABLE_CHOICE Choice)
int StringSameAs (const char *String, const char *String_lengths, VIABLE_CHOICE ViableChoice)
bool StringSameAs (const WERD_CHOICE &WordChoice, VIABLE_CHOICE ViableChoice)
int AcceptableChoice (BLOB_CHOICE_LIST_VECTOR *Choices, WERD_CHOICE *BestChoice, const WERD_CHOICE &RawChoice, DANGERR *fixpt, ACCEPTABLE_CHOICE_CALLER caller, bool *modified_blobs)
int AcceptableResult (const WERD_CHOICE &BestChoice, const WERD_CHOICE &RawChoice)
int ChoiceSameAs (const WERD_CHOICE &WordChoice, VIABLE_CHOICE ViableChoice)
void LogNewChoice (const WERD_CHOICE &WordChoice, FLOAT32 AdjustFactor, const float Certainties[], bool raw_choice)
void EndDangerousAmbigs ()
int CurrentBestChoiceIs (const WERD_CHOICE &WordChoice)
FLOAT32 CurrentBestChoiceAdjustFactor ()
int CurrentWordAmbig ()
void DebugWordChoices ()
void PrintAmbigAlternatives (FILE *file, const char *label, int label_num_unichars)
void FillViableChoice (const WERD_CHOICE &WordChoice, FLOAT32 AdjustFactor, const float Certainties[], bool SameString, VIABLE_CHOICE ViableChoice)
int AlternativeChoicesWorseThan (FLOAT32 Threshold)
void FilterWordChoices ()
void FindClassifierErrors (FLOAT32 MinRating, FLOAT32 MaxRating, FLOAT32 RatingMargin, FLOAT32 Thresholds[])
void InitChoiceAccum ()
void LogNewSegmentation (PIECES_STATE BlobWidth)
void LogNewSplit (int Blob)
void SettupStopperPass1 ()
void SettupStopperPass2 ()
void print_word_string (const char *str)
void print_word_choice (const char *label, A_CHOICE *choice)
void print_choices (const char *label, CHOICES rating)
A_CHOICEngram_permute_and_select (CHOICES_LIST char_choices, float rating_limit, const Dawg *dawg)
int def_letter_is_okay (void *void_dawg_args, int word_index, const void *word, bool word_end)
int new_letter_is_okay (void *void_dawg_args, int word_index, const void *word, bool word_end)
const int NumDawgs () const
const DawgGetDawg (int index) const
bool ConstraintsOk (const DawgInfoVector &constraints, int word_end, DawgType current_dawg_type)
void LogNewWordChoice (A_CHOICE *a_choice, FLOAT32 adjust_factor, const float certainties[], const UNICHARSET &unicharset)
int valid_word (const char *string)

Static Public Member Functions

static void UpdatePermuter (PermuterType new_permuter, PermuterType *permuter)
 Record the maximum of the two permuters in permuter.

Public Attributes

void(Dict::* go_deeper_fxn_ )(const char *debug, const BLOB_CHOICE_LIST_VECTOR &char_choices, int char_choice_index, const CHAR_FRAGMENT_INFO *prev_char_frag_info, bool word_ending, WERD_CHOICE *word, float certainties[], float *limit, WERD_CHOICE *best_choice, void *void_more_args)
int(Dict::* letter_is_okay_ )(void *void_dawg_args, int word_index, const void *word, bool word_end)

Constructor & Destructor Documentation

tesseract::Dict::Dict ( Image image_ptr  ) 
tesseract::Dict::~Dict (  ) 

Member Function Documentation

int tesseract::Dict::AcceptableChoice ( BLOB_CHOICE_LIST_VECTOR Choices,
WERD_CHOICE BestChoice,
const WERD_CHOICE RawChoice,
DANGERR fixpt,
ACCEPTABLE_CHOICE_CALLER  caller,
bool modified_blobs 
)
int tesseract::Dict::AcceptableResult ( const WERD_CHOICE BestChoice,
const WERD_CHOICE RawChoice 
)
void tesseract::Dict::add_document_word ( const WERD_CHOICE best_choice  ) 
void tesseract::Dict::adjust_non_word ( WERD_CHOICE word,
float *  adjust_factor 
)
void tesseract::Dict::adjust_word ( WERD_CHOICE best_choice,
float *  certainty_array 
)
int tesseract::Dict::AlternativeChoicesWorseThan ( FLOAT32  Threshold  ) 
void tesseract::Dict::append_choices ( const char *  debug,
const BLOB_CHOICE_LIST_VECTOR char_choices,
const BLOB_CHOICE blob_choice,
int  char_choice_index,
const CHAR_FRAGMENT_INFO prev_char_frag_info,
WERD_CHOICE word,
float  certainties[],
float *  limit,
WERD_CHOICE best_choice,
void *  more_args 
)
int tesseract::Dict::ChoiceSameAs ( const WERD_CHOICE WordChoice,
VIABLE_CHOICE  ViableChoice 
)
const char * tesseract::Dict::choose_il1 ( const char *  first_char,
const char *  second_char,
const char *  third_char,
const char *  prev_char,
const char *  next_char,
const char *  next_next_char 
)
bool tesseract::Dict::ConstraintsOk ( const DawgInfoVector constraints,
int  word_end,
DawgType  current_dawg_type 
) [inline]

At word ending make sure all the recorded constraints are satisfied. Each constraint signifies that we found a beginning pattern in a pattern dawg. Check that this pattern can end here (e.g. if some leading punctuation is found this would ensure that we are not expecting any particular trailing punctuation after the word).

void tesseract::Dict::copy_hyphen_info ( WERD_CHOICE word  )  [inline]

If this word is hyphenated copy the base word (the part on the line before) of a hyphenated word into the given word. This function assumes that word is not NULL.

FLOAT32 tesseract::Dict::CurrentBestChoiceAdjustFactor (  ) 
int tesseract::Dict::CurrentBestChoiceIs ( const WERD_CHOICE WordChoice  ) 
int tesseract::Dict::CurrentWordAmbig (  ) 
WERD_CHOICE * tesseract::Dict::dawg_permute_and_select ( const BLOB_CHOICE_LIST_VECTOR char_choices,
float  rating_limit 
)

Recursively explore all the possible character combinations in the given char_choices. Use go_deeper_dawg_fxn() to explore all the dawgs in the dawgs_ vector in parallel and discard invalid words.

Allocate and return a WERD_CHOICE with the best valid word found.

void tesseract::Dict::DebugWordChoices (  ) 
int tesseract::Dict::def_letter_is_okay ( void *  void_dawg_args,
int  word_index,
const void *  word,
bool  word_end 
)

Returns the maximal permuter code (from ccstruct/ratngs.h) if in light of the current state the letter at word_index in the given word is allowed according to at least one of the dawgs in dawgs_, otherwise returns NO_PERM.

The state is described by void_dawg_args, which are interpreted as DawgArgs and contain two relevant input vectors: active_dawgs and constraints. Each entry in the active_dawgs vector contains an index into the dawgs_ vector and an EDGE_REF that indicates the last edge followed in the dawg. Each entry in the constraints vector contains an index into the dawgs_ vector and an EDGE_REF that indicates an edge in a pattern dawg followed to match a pattern. Currently constraints are used to save the state of punctuation dawgs after leading punctuation was found.

Input: At word_index 0 dawg_args->active_dawgs should contain an entry for each dawg whose type has a bit set in kBeginningDawgsType, dawg_args->constraints should be empty. EDGE_REFs in active_dawgs and constraints vectors should be initialized to NO_EDGE. If hyphen state needs to be applied, initial dawg_args->active_dawgs and dawg_args->constrains can be copied from the saved hyphen state (maintained by Dict). For word_index > 0 the corresponding state (active_dawgs and constraints) can be obtained from dawg_args->updated_* passed to def_letter_is_okay for word_index-1. Note: the function assumes that active_dags, constraints and updated_* member variables of dawg_args are not NULL.

Output: The function fills in dawg_args->updated_active_dawgs vector with the entries for dawgs that contain the word up to the letter at word_index. The new constraints (if any) are added to dawg_args->updated_constraints, the constraints from dawg_args->constraints are also copied into it.

Detailed description: In order to determine whether the word is still valid after considering all the letters up to the one at word_index the following is done for each entry in dawg_args->active_dawgs:

  • next starting node is obtained from entry.ref and edge_char_of() is called to obtain the next edge
  • if a valid edge is found, the function returns the updated permuter code true and an entry [entry.dawg_index, edge] is inserted in dawg_args->updated_active_dawgs otherwise:
    • if we are dealing with dawg of type DAWG_TYPE_PUNCTUATION, edge_char_of() is called again, but now with kPatternUnicharID as unichar_id; if a valid edge is found it is recorded in dawg_args->updated_constraints
    • the function checks whether the word can end with the previous letter
    • each successor of the dawg (e.g. dawgs with type DAWG_TYPE_WORD could be successors to dawgs with type DAWG_TYPE_PUNCTUATION; the successors are defined by successors_ vector) is explored and if a letter is found in the successor dawg, a new entry is inserted into dawg_args->updated_active_dawgs with EDGE_REF being either NO_EDGE or an EDGE_REF recorded in constraints vector for the corresponding dawg index
void tesseract::Dict::DisableChoiceAccum (  )  [inline]
void tesseract::Dict::EnableChoiceAccum (  )  [inline]
void tesseract::Dict::end_permute (  ) 
void tesseract::Dict::EndDangerousAmbigs (  ) 
void tesseract::Dict::FillViableChoice ( const WERD_CHOICE WordChoice,
FLOAT32  AdjustFactor,
const float  Certainties[],
bool  SameString,
VIABLE_CHOICE  ViableChoice 
)
void tesseract::Dict::FilterWordChoices (  ) 
void tesseract::Dict::FindClassifierErrors ( FLOAT32  MinRating,
FLOAT32  MaxRating,
FLOAT32  RatingMargin,
FLOAT32  Thresholds[] 
)
bool tesseract::Dict::fragment_state_okay ( UNICHAR_ID  curr_unichar_id,
float  curr_rating,
float  curr_certainty,
const CHAR_FRAGMENT_INFO prev_char_frag_info,
const char *  debug,
int  word_ending,
CHAR_FRAGMENT_INFO char_frag_info 
)

Semi-generic functions used by multiple permuters.

const Dawg* tesseract::Dict::GetDawg ( int  index  )  const [inline]

Return i-th dawg pointer recorded in the dawgs_ vector.

Image* tesseract::Dict::getImage (  )  [inline]
const UnicharAmbigs& tesseract::Dict::getUnicharAmbigs (  )  [inline]
UNICHARSET& tesseract::Dict::getUnicharset (  )  [inline]
void tesseract::Dict::go_deeper_dawg_fxn ( const char *  debug,
const BLOB_CHOICE_LIST_VECTOR char_choices,
int  char_choice_index,
const CHAR_FRAGMENT_INFO prev_char_frag_info,
bool  word_ending,
WERD_CHOICE word,
float  certainties[],
float *  limit,
WERD_CHOICE best_choice,
void *  void_more_args 
)

If the choice being composed so far could be a dictionary word and we have not reached the end of the word keep exploring the char_choices further. Also: -- set hyphen word if needed -- if word_ending is true and word is better than best_choice copy word to best_choice log new word choice

void tesseract::Dict::go_deeper_top_fragments_fxn ( const char *  debug,
const BLOB_CHOICE_LIST_VECTOR char_choices,
int  char_choice_index,
const CHAR_FRAGMENT_INFO prev_char_frag_info,
bool  word_ending,
WERD_CHOICE word,
float  certainties[],
float *  limit,
WERD_CHOICE best_choice,
void *  more_args 
)

If the choice being composed so far could be better than best_choice keep exploring char_choices. If we have reached the end of the word and word is better than best_choice, copy word to best_choice and log a new word choice.

bool tesseract::Dict::has_hyphen_end ( const WERD_CHOICE word  )  [inline]

Check whether the word has a hyphen at the end.

int tesseract::Dict::hyphen_base_size (  )  [inline]

Size of the base word (the part on the line before) of a hyphenated word.

bool tesseract::Dict::hyphenated (  )  [inline]

Returns true if we've recorded the beginning of a hyphenated word.

void tesseract::Dict::incorporate_segcost ( WERD_CHOICE word  ) 

Incoporate segmentation cost into word rating.

void tesseract::Dict::init_active_dawgs ( DawgInfoVector active_dawgs  ) 

Fill the given active_dawgs vector with dawgs that could contain the beginning of the word. If hyphenated() returns true, copy the entries from hyphen_active_dawgs_ instead.

void tesseract::Dict::init_constraints ( DawgInfoVector constraints  ) 

If hyphenated() returns true, copy the entries from hyphen_constraints_ into the given constraints vector.

void tesseract::Dict::init_permute (  ) 
void tesseract::Dict::InitChoiceAccum (  ) 
int tesseract::Dict::LengthOfShortestAlphaRun ( const WERD_CHOICE WordChoice  ) 
void tesseract::Dict::LogNewChoice ( const WERD_CHOICE WordChoice,
FLOAT32  AdjustFactor,
const float  Certainties[],
bool  raw_choice 
)
void tesseract::Dict::LogNewSegmentation ( PIECES_STATE  BlobWidth  ) 
void tesseract::Dict::LogNewSplit ( int  Blob  ) 
void tesseract::Dict::LogNewWordChoice ( A_CHOICE a_choice,
FLOAT32  adjust_factor,
const float  certainties[],
const UNICHARSET unicharset 
)
int tesseract::Dict::new_letter_is_okay ( void *  void_dawg_args,
int  word_index,
const void *  word,
bool  word_end 
)
VIABLE_CHOICE tesseract::Dict::NewViableChoice ( const WERD_CHOICE WordChoice,
FLOAT32  AdjustFactor,
const float  Certainties[] 
)
A_CHOICE * tesseract::Dict::ngram_permute_and_select ( CHOICES_LIST  char_choices,
float  rating_limit,
const Dawg dawg 
)
int tesseract::Dict::NoDangerousAmbig ( WERD_CHOICE BestChoice,
DANGERR fixpt,
bool  fix_replaceable,
BLOB_CHOICE_LIST_VECTOR Choices,
bool modified_blobs 
)
const int tesseract::Dict::NumDawgs (  )  const [inline]

Return the number of dawgs in the dawgs_ vector.

WERD_CHOICE * tesseract::Dict::permute_all ( const BLOB_CHOICE_LIST_VECTOR char_choices,
float  rating_limit,
WERD_CHOICE raw_choice 
)
void tesseract::Dict::permute_characters ( const BLOB_CHOICE_LIST_VECTOR char_choices,
float  limit,
WERD_CHOICE best_choice,
WERD_CHOICE raw_choice 
)
void tesseract::Dict::permute_choices ( const char *  debug,
const BLOB_CHOICE_LIST_VECTOR char_choices,
int  char_choice_index,
const CHAR_FRAGMENT_INFO prev_char_frag_info,
WERD_CHOICE word,
float  certainties[],
float *  limit,
WERD_CHOICE best_choice,
void *  more_args 
)
WERD_CHOICE * tesseract::Dict::permute_compound_words ( const BLOB_CHOICE_LIST_VECTOR char_choices,
float  rating_limit 
)
WERD_CHOICE * tesseract::Dict::permute_script_words ( const BLOB_CHOICE_LIST_VECTOR char_choices  ) 

checks for script-consistent permutations

void tesseract::Dict::permute_subword ( const BLOB_CHOICE_LIST_VECTOR char_choices,
float  rating_limit,
int  start,
int  end,
WERD_CHOICE current_word 
)
WERD_CHOICE * tesseract::Dict::permute_top_choice ( const BLOB_CHOICE_LIST_VECTOR char_choices,
float *  rating_limit,
WERD_CHOICE raw_choice,
BOOL8 any_alpha 
)
void tesseract::Dict::print_choices ( const char *  label,
CHOICES  rating 
)
void tesseract::Dict::print_word_choice ( const char *  label,
A_CHOICE choice 
)
void tesseract::Dict::print_word_string ( const char *  str  ) 
void tesseract::Dict::PrintAmbigAlternatives ( FILE *  file,
const char *  label,
int  label_num_unichars 
)
void tesseract::Dict::PrintViableChoice ( FILE *  File,
const char *  Label,
VIABLE_CHOICE  Choice 
)
void tesseract::Dict::remove_hyphen_head ( WERD_CHOICE word  )  [inline]

Erase the unichar ids corresponding to the portion of the word from the previous line. The word is not changed if it is not split between lines and hyphenated.

void tesseract::Dict::ReplaceAmbig ( int  wrong_ngram_begin_index,
int  wrong_ngram_size,
UNICHAR_ID  correct_ngram_id,
WERD_CHOICE werd_choice,
BLOB_CHOICE_LIST_VECTOR blob_choices,
bool modified_blobs 
)
void tesseract::Dict::reset_hyphen_vars ( bool  last_word_on_line  ) 

Unless the previous word was the last one on the line, and the current one is not (thus it is the first one on the line), erase hyphen_word_, clear hyphen_active_dawgs_, hyphen_constraints_ update last_word_on_line_.

void tesseract::Dict::set_hyphen_word ( const WERD_CHOICE word,
const DawgInfoVector active_dawgs,
const DawgInfoVector constraints 
)

Update hyphen_word_, and copy the given DawgInfoVectors into hyphen_active_dawgs_ and hyphen_constraints_.

void tesseract::Dict::SettupStopperPass1 (  ) 
void tesseract::Dict::SettupStopperPass2 (  ) 
bool tesseract::Dict::StringSameAs ( const WERD_CHOICE WordChoice,
VIABLE_CHOICE  ViableChoice 
)
int tesseract::Dict::StringSameAs ( const char *  String,
const char *  String_lengths,
VIABLE_CHOICE  ViableChoice 
)
WERD_CHOICE * tesseract::Dict::top_fragments_permute_and_select ( const BLOB_CHOICE_LIST_VECTOR char_choices,
float  rating_limit 
)
void tesseract::Dict::update_best_choice ( const WERD_CHOICE word,
WERD_CHOICE best_choice 
) [inline]

If new_rating < best_choice->rating(), copy word int best_choice and update rating and permuter of best_choice to the new given values.

static void tesseract::Dict::UpdatePermuter ( PermuterType  new_permuter,
PermuterType *  permuter 
) [inline, static]

Record the maximum of the two permuters in permuter.

bool tesseract::Dict::valid_punctuation ( const WERD_CHOICE word  ) 
int tesseract::Dict::valid_word ( const char *  string  ) 
int tesseract::Dict::valid_word ( const WERD_CHOICE word,
bool  numbers_ok 
)
int tesseract::Dict::valid_word ( const WERD_CHOICE word  )  [inline]
Returns:
NO_PERM for words with digits
int tesseract::Dict::valid_word_or_number ( const WERD_CHOICE word  )  [inline]
Returns:
NUMBER_PERM for valid numbers
bool tesseract::Dict::word_script_eq ( const BLOB_CHOICE_LIST_VECTOR char_choices,
int  target_script_id 
)

checks if the dominant word script, if there is one, is same as target.


Member Data Documentation

void(Dict::* tesseract::Dict::go_deeper_fxn_)(const char *debug, const BLOB_CHOICE_LIST_VECTOR &char_choices, int char_choice_index, const CHAR_FRAGMENT_INFO *prev_char_frag_info, bool word_ending, WERD_CHOICE *word, float certainties[], float *limit, WERD_CHOICE *best_choice, void *void_more_args)
int(Dict::* tesseract::Dict::letter_is_okay_)(void *void_dawg_args, int word_index, const void *word, bool word_end)

The documentation for this class was generated from the following files:
Generated on Sun Jul 18 17:11:24 2010 for Tesseract by  doxygen 1.6.3