#include <classify.h>
tesseract::Classify::Classify | ( | ) |
tesseract::Classify::~Classify | ( | ) | [virtual] |
int tesseract::Classify::AdaptableWord | ( | TWERD * | Word, | |
const WERD_CHOICE & | BestChoiceWord, | |||
const WERD_CHOICE & | RawChoiceWord | |||
) |
Return TRUE if the specified word is acceptable for adaptation.
Globals: none
Word | current word | |
BestChoiceWord | best overall choice for word with context | |
RawChoiceWord | best choice for word without context |
void tesseract::Classify::AdaptiveClassifier | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
BLOB_CHOICE_LIST * | Choices, | |||
CLASS_PRUNER_RESULTS | CPResults | |||
) |
This routine calls the adaptive matcher which returns (in an array) the class id of each class matched.
It also returns the number of classes matched. For each class matched it places the best rating found for that class into the Ratings array.
Bad matches are then removed so that they don't need to be sorted. The remaining good matches are then sorted and converted to choices.
This routine also performs some simple speckle filtering.
Blob | blob to be classified | |
[out] | Choices | List of choices found by adaptive matcher. |
[out] | CPResults | Array of CPResultStruct of size MAX_NUM_CLASSES is filled on return with the choices found by the class pruner and the ratings therefrom. Also contains the detailed results of the integer matcher. |
bool tesseract::Classify::AdaptiveClassifierIsFull | ( | ) | [inline] |
void tesseract::Classify::AdaptToChar | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
CLASS_ID | ClassId, | |||
int | FontinfoId, | |||
FLOAT32 | Threshold | |||
) |
Blob | blob to add to templates for ClassId | |
LineStats | statistics about text line blob is in | |
ClassId | class to add blob to | |
FontinfoId | font information from pre-trained templates | |
Threshold | minimum match rating to existing template |
Globals:
void tesseract::Classify::AdaptToPunc | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
CLASS_ID | ClassId, | |||
int | FontinfoId, | |||
FLOAT32 | Threshold | |||
) |
Blob | blob to add to templates for ClassId | |
LineStats | statistics about text line blob is in | |
ClassId | class to add blob to | |
FontinfoId | font information from pre-trained teamples | |
Threshold | minimum match rating to existing template |
Globals:
void tesseract::Classify::AddNewResult | ( | ADAPT_RESULTS * | results, | |
CLASS_ID | class_id, | |||
int | shape_id, | |||
FLOAT32 | rating, | |||
bool | adapted, | |||
int | config, | |||
int | fontinfo_id, | |||
int | fontinfo_id2 | |||
) |
This routine adds the result of a classification into Results. If the new rating is much worse than the current best rating, it is not entered into results because it would end up being stripped later anyway. If the new rating is better than the old rating for the class, it replaces the old rating. If this is the first rating for the class, the class is added to the list of matched classes in Results. If the new rating is better than the best so far, it becomes the best so far.
Globals:
[out] | results | results to add new result to |
class_id | class of new result | |
rating | rating of new result | |
config | config id of new result | |
config2 | config id of 2nd choice result | |
fontinfo_id | font information of the new result | |
fontinfo_id2 | font information of the 2nd choice result |
void tesseract::Classify::AmbigClassifier | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
INT_TEMPLATES | Templates, | |||
ADAPT_CLASS * | Classes, | |||
UNICHAR_ID * | Ambiguities, | |||
ADAPT_RESULTS * | Results | |||
) |
This routine is identical to CharNormClassifier() except that it does no class pruning. It simply matches the unknown blob against the classes listed in Ambiguities.
Globals:
Blob | blob to be classified | |
Templates | built-in templates to classify against | |
Ambiguities | array of class id's to match against | |
[out] | Results | place to put match results |
UNICHAR_ID * tesseract::Classify::BaselineClassifier | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
ADAPT_TEMPLATES | Templates, | |||
ADAPT_RESULTS * | Results | |||
) |
This routine extracts baseline normalized features from the unknown character and matches them against the specified set of templates. The classes which match are added to Results.
Globals:
Blob | blob to be classified | |
Templates | current set of adapted templates | |
Results | place to put match results |
int tesseract::Classify::CharNormClassifier | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
INT_TEMPLATES | Templates, | |||
ADAPT_RESULTS * | Results | |||
) |
This routine extracts character normalized features from the unknown character and matches them against the specified set of templates. The classes which match are added to Results.
Blob | blob to be classified | |
Templates | templates to classify unknown against | |
Results | place to put match results |
Globals:
int tesseract::Classify::CharNormTrainingSample | ( | bool | pruner_only, | |
const TrainingSample & | sample, | |||
GenericVector< ShapeRating > * | results | |||
) |
int tesseract::Classify::ClassAndConfigIDToFontOrShapeID | ( | int | class_id, | |
int | int_result_config | |||
) | const |
STRING tesseract::Classify::ClassIDToDebugStr | ( | const INT_TEMPLATES_STRUCT * | templates, | |
int | class_id, | |||
int | config_id | |||
) | const |
void tesseract::Classify::ClassifyAsNoise | ( | ADAPT_RESULTS * | Results | ) |
This routine computes a rating which reflects the likelihood that the blob being classified is a noise blob. NOTE: assumes that the blob length has already been computed and placed into Results.
Results | results to add noise classification to |
Globals:
void tesseract::Classify::ClearCharNormArray | ( | uinT8 * | char_norm_array | ) |
For each class in the unicharset, clears the corresponding entry in char_norm_array. char_norm_array is indexed by unichar_id.
Globals:
char_norm_array | array to be cleared |
void tesseract::Classify::ComputeCharNormArrays | ( | FEATURE_STRUCT * | norm_feature, | |
INT_TEMPLATES_STRUCT * | templates, | |||
uinT8 * | char_norm_array, | |||
uinT8 * | pruner_array | |||
) |
double tesseract::Classify::ComputeCorrectedRating | ( | bool | debug, | |
int | unichar_id, | |||
double | cp_rating, | |||
double | im_rating, | |||
int | feature_misses, | |||
int | bottom, | |||
int | top, | |||
int | blob_length, | |||
const uinT8 * | cn_factors | |||
) |
void tesseract::Classify::ComputeIntCharNormArray | ( | const FEATURE_STRUCT & | norm_feature, | |
uinT8 * | char_norm_array | |||
) |
For each class in unicharset, computes the match between norm_feature and the normalization protos for that class. Converts this number to the range from 0 - 255 and stores it into char_norm_array. CharNormArray is indexed by unichar_id.
Globals:
norm_feature | character normalization feature | |
[out] | char_norm_array | place to put results of size unicharset.size() |
void tesseract::Classify::ComputeIntFeatures | ( | FEATURE_SET | Features, | |
INT_FEATURE_ARRAY | IntFeatures | |||
) |
This routine converts each floating point pico-feature in Features into integer format and saves it into IntFeatures.
Globals:
Features | floating point pico-features to be converted | |
[out] | IntFeatures | array to put converted features into |
FLOAT32 tesseract::Classify::ComputeNormMatch | ( | CLASS_ID | ClassId, | |
const FEATURE_STRUCT & | feature, | |||
BOOL8 | DebugMatch | |||
) |
void tesseract::Classify::ConvertMatchesToChoices | ( | const DENORM & | denorm, | |
const TBOX & | box, | |||
ADAPT_RESULTS * | Results, | |||
BLOB_CHOICE_LIST * | Choices | |||
) |
The function converts the given match ratings to the list of blob choices with ratings and certainties (used by the context checkers). If character fragments are present in the results, this function also makes sure that there is at least one non-fragmented classification included. For each classification result check the unicharset for "definite" ambiguities and modify the resulting Choices accordingly.
INT_TEMPLATES tesseract::Classify::CreateIntTemplates | ( | CLASSES | FloatProtos, | |
const UNICHARSET & | target_unicharset | |||
) |
void tesseract::Classify::DebugAdaptiveClassifier | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
ADAPT_RESULTS * | Results | |||
) |
Blob | blob whose classification is being debugged | |
Results | results of match being debugged |
Globals: none
void tesseract::Classify::DisplayAdaptedChar | ( | TBLOB * | blob, | |
const DENORM & | denorm, | |||
INT_CLASS_STRUCT * | int_class | |||
) |
void tesseract::Classify::DoAdaptiveMatch | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
ADAPT_RESULTS * | Results | |||
) |
This routine performs an adaptive classification. If we have not yet adapted to enough classes, a simple classification to the pre-trained templates is performed. Otherwise, we match the blob against the adapted templates. If the adapted templates do not match well, we try a match against the pre-trained templates. If an adapted template match is found, we do a match to any pre-trained templates which could be ambiguous. The results from all of these classifications are merged together into Results.
Blob | blob to be classified | |
Results | place to put match results |
Globals:
void tesseract::Classify::EndAdaptiveClassifier | ( | ) |
This routine performs cleanup operations on the adaptive classifier. It should be called before the program is terminated. Its main function is to save the adapted templates to a file.
Globals:
void tesseract::Classify::ExpandShapesAndApplyCorrections | ( | ADAPT_CLASS * | classes, | |
bool | debug, | |||
int | class_id, | |||
int | bottom, | |||
int | top, | |||
float | cp_rating, | |||
int | blob_length, | |||
const uinT8 * | cn_factors, | |||
INT_RESULT_STRUCT & | int_result, | |||
ADAPT_RESULTS * | final_results | |||
) |
FEATURE_SET tesseract::Classify::ExtractOutlineFeatures | ( | TBLOB * | Blob | ) |
FEATURE_SET tesseract::Classify::ExtractPicoFeatures | ( | TBLOB * | Blob | ) |
void tesseract::Classify::FreeNormProtos | ( | ) |
UnicityTable<FontInfo>& tesseract::Classify::get_fontinfo_table | ( | ) | [inline] |
UnicityTable<FontSet>& tesseract::Classify::get_fontset_table | ( | ) | [inline] |
int tesseract::Classify::GetAdaptiveFeatures | ( | TBLOB * | Blob, | |
INT_FEATURE_ARRAY | IntFeatures, | |||
FEATURE_SET * | FloatFeatures | |||
) |
This routine sets up the feature extractor to extract baseline normalized pico-features.
The extracted pico-features are converted to integer form and placed in IntFeatures. The original floating-pt. features are returned in FloatFeatures.
Globals: none
Blob | blob to extract features from | |
LineStats | statistics about text row blob is in | |
[out] | IntFeatures | array to fill with integer features |
[out] | FloatFeatures | place to return actual floating-pt features |
void tesseract::Classify::GetAdaptThresholds | ( | TWERD * | Word, | |
const DENORM & | denorm, | |||
const WERD_CHOICE & | BestChoice, | |||
const WERD_CHOICE & | BestRawChoice, | |||
FLOAT32 | Thresholds[] | |||
) |
This routine tries to estimate how tight the adaptation threshold should be set for each character in the current word. In general, the routine tries to set tighter thresholds for a character when the current set of templates would have made an error on that character. It tries to set a threshold tight enough to eliminate the error. Two different sets of rules can be used to determine the desired thresholds.
Word | current word | |
BestChoice | best choice for current word with context | |
BestRawChoice | best choice for current word without context | |
[out] | Thresholds | array of thresholds to be filled in |
Globals:
UNICHAR_ID * tesseract::Classify::GetAmbiguities | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
CLASS_ID | CorrectClass | |||
) |
This routine matches blob to the built-in templates to find out if there are any classes other than the correct class which are potential ambiguities.
Blob | blob to get classification ambiguities for | |
CorrectClass | correct class for Blob |
Globals:
int tesseract::Classify::GetBaselineFeatures | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
INT_TEMPLATES | Templates, | |||
INT_FEATURE_ARRAY | IntFeatures, | |||
uinT8 * | CharNormArray, | |||
inT32 * | BlobLength | |||
) |
This routine calls the integer (Hardware) feature extractor if it has not been called before for this blob. The results from the feature extractor are placed into globals so that they can be used in other routines without re-extracting the features. It then copies the baseline features into the IntFeatures array provided by the caller.
Blob | blob to extract features from | |
Templates | used to compute char norm adjustments | |
IntFeatures | array to fill with integer features | |
CharNormArray | array to fill with dummy char norm adjustments | |
BlobLength | length of blob in baseline-normalized units |
Globals:
int tesseract::Classify::GetCharNormFeatures | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
INT_TEMPLATES | Templates, | |||
INT_FEATURE_ARRAY | IntFeatures, | |||
uinT8 * | PrunerNormArray, | |||
uinT8 * | CharNormArray, | |||
inT32 * | BlobLength, | |||
inT32 * | FeatureOutlineArray | |||
) |
This routine calls the integer (Hardware) feature extractor if it has not been called before for this blob.
The results from the feature extractor are placed into globals so that they can be used in other routines without re-extracting the features.
It then copies the char norm features into the IntFeatures array provided by the caller.
Blob | blob to extract features from | |
Templates | used to compute char norm adjustments | |
IntFeatures | array to fill with integer features | |
CharNormArray | array to fill with dummy char norm adjustments | |
BlobLength | length of blob in baseline-normalized units |
Globals:
CLASS_ID tesseract::Classify::GetClassToDebug | ( | const char * | Prompt, | |
bool * | adaptive_on, | |||
bool * | pretrained_on, | |||
int * | shape_id | |||
) |
Dict& tesseract::Classify::getDict | ( | ) | [inline] |
int tesseract::Classify::GetFontinfoId | ( | ADAPT_CLASS | Class, | |
uinT8 | ConfigId | |||
) |
void tesseract::Classify::InitAdaptedClass | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
CLASS_ID | ClassId, | |||
int | FontinfoId, | |||
ADAPT_CLASS | Class, | |||
ADAPT_TEMPLATES | Templates | |||
) |
This routine creates a new adapted class and uses Blob as the model for the first config in that class.
Blob | blob to model new class after | |
ClassId | id of the class to be initialized | |
FontinfoId | font information inferred from pre-trained templates | |
Class | adapted class to be initialized | |
Templates | adapted templates to add new class to |
Globals:
void tesseract::Classify::InitAdaptiveClassifier | ( | bool | load_pre_trained_templates | ) |
This routine reads in the training information needed by the adaptive classifier and saves it into global variables. Parameters: load_pre_trained_templates Indicates whether the pre-trained templates (inttemp, normproto and pffmtable components) should be lodaded. Should only be set to true if the necesary classifier components are present in the [lang].traineddata file. Globals: BuiltInTemplatesFile file to get built-in temps from BuiltInCutoffsFile file to get avg. feat per class from classify_use_pre_adapted_templates enables use of pre-adapted templates
void tesseract::Classify::LearnPieces | ( | const char * | filename, | |
int | start, | |||
int | length, | |||
float | threshold, | |||
CharSegmentationType | segmentation, | |||
const char * | correct_text, | |||
WERD_RES * | word | |||
) |
void tesseract::Classify::LearnWord | ( | const char * | filename, | |
const char * | rejmap, | |||
WERD_RES * | word | |||
) |
int tesseract::Classify::MakeNewTemporaryConfig | ( | ADAPT_TEMPLATES | Templates, | |
CLASS_ID | ClassId, | |||
int | FontinfoId, | |||
int | NumFeatures, | |||
INT_FEATURE_ARRAY | Features, | |||
FEATURE_SET | FloatFeatures | |||
) |
Templates | adapted templates to add new config to | |
ClassId | class id to associate with new config | |
FontinfoId | font information inferred from pre-trained templates | |
NumFeatures | number of features in IntFeatures | |
Features | features describing model for new config | |
FloatFeatures | floating-pt representation of features |
PROTO_ID tesseract::Classify::MakeNewTempProtos | ( | FEATURE_SET | Features, | |
int | NumBadFeat, | |||
FEATURE_ID | BadFeat[], | |||
INT_CLASS | IClass, | |||
ADAPT_CLASS | Class, | |||
BIT_VECTOR | TempProtoMask | |||
) |
This routine finds sets of sequential bad features that all have the same angle and converts each set into a new temporary proto. The temp proto is added to the proto pruner for IClass, pushed onto the list of temp protos in Class, and added to TempProtoMask.
Features | floating-pt features describing new character | |
NumBadFeat | number of bad features to turn into protos | |
BadFeat | feature id's of bad features | |
IClass | integer class templates to add new protos to | |
Class | adapted class templates to add new protos to | |
TempProtoMask | proto mask to add new protos to |
Globals: none
void tesseract::Classify::MakePermanent | ( | ADAPT_TEMPLATES | Templates, | |
CLASS_ID | ClassId, | |||
int | ConfigId, | |||
const DENORM & | denorm, | |||
TBLOB * | Blob | |||
) |
Templates | current set of adaptive templates | |
ClassId | class containing config to be made permanent | |
ConfigId | config to be made permanent | |
Blob | current blob being adapted to |
Globals: none
void tesseract::Classify::MasterMatcher | ( | INT_TEMPLATES | templates, | |
inT16 | num_features, | |||
const INT_FEATURE_STRUCT * | features, | |||
const uinT8 * | norm_factors, | |||
ADAPT_CLASS * | classes, | |||
int | debug, | |||
int | num_classes, | |||
const TBOX & | blob_box, | |||
CLASS_PRUNER_RESULTS | results, | |||
ADAPT_RESULTS * | final_results | |||
) |
Factored-out calls to IntegerMatcher based on class pruner results. Returns integer matcher results inside CLASS_PRUNER_RESULTS structure.
ADAPT_TEMPLATES tesseract::Classify::NewAdaptedTemplates | ( | bool | InitFromUnicharset | ) |
Allocates memory for adapted tempates. each char in unicharset to the newly created templates
PopulateFromUnicharset | if true, add an empty class for |
void tesseract::Classify::PrintAdaptedTemplates | ( | FILE * | File, | |
ADAPT_TEMPLATES | Templates | |||
) |
This routine prints a summary of the adapted templates in Templates to File.
File | open text file to print Templates to | |
Templates | adapted templates to print to File |
void tesseract::Classify::PrintAdaptiveMatchResults | ( | FILE * | File, | |
ADAPT_RESULTS * | Results | |||
) |
This routine writes the matches in Results to File.
File | open text file to write Results to | |
Results | match results to write to File |
Globals: none
void tesseract::Classify::PrintAdaptiveStatistics | ( | FILE * | File | ) |
Print to File the statistics which have been gathered for the adaptive matcher.
File | open text file to print adaptive statistics to |
Globals: none
int tesseract::Classify::PruneClasses | ( | const INT_TEMPLATES_STRUCT * | int_templates, | |
int | num_features, | |||
const INT_FEATURE_STRUCT * | features, | |||
const uinT8 * | normalization_factors, | |||
const uinT16 * | expected_num_features, | |||
CP_RESULT_STRUCT * | results | |||
) |
ADAPT_TEMPLATES tesseract::Classify::ReadAdaptedTemplates | ( | FILE * | File | ) |
Read a set of adapted templates from File and return a ptr to the templates.
File | open text file to read adapted templates from |
void tesseract::Classify::ReadClassFile | ( | ) |
INT_TEMPLATES tesseract::Classify::ReadIntTemplates | ( | FILE * | File | ) |
void tesseract::Classify::ReadNewCutoffs | ( | FILE * | CutoffFile, | |
bool | swap, | |||
inT64 | end_offset, | |||
CLASS_CUTOFF_ARRAY | Cutoffs | |||
) |
NORM_PROTOS * tesseract::Classify::ReadNormProtos | ( | FILE * | File, | |
inT64 | end_offset | |||
) |
void tesseract::Classify::RefreshDebugWindow | ( | ScrollView ** | win, | |
const char * | msg, | |||
int | y_offset, | |||
const TBOX & | wbox | |||
) |
void tesseract::Classify::RemoveBadMatches | ( | ADAPT_RESULTS * | Results | ) |
This routine steps thru each matching class in Results and removes it from the match list if its rating is worse than the BestRating plus a pad. In other words, all good matches get moved to the front of the classes array.
Results | contains matches to be filtered |
Globals:
void tesseract::Classify::RemoveExtraPuncs | ( | ADAPT_RESULTS * | Results | ) |
This routine steps thru each matching class in Results and removes it from the match list if its rating is worse than the BestRating plus a pad. In other words, all good matches get moved to the front of the classes array.
Results contains matches to be filtered
Globals:
void tesseract::Classify::ResetAdaptiveClassifierInternal | ( | ) |
void tesseract::Classify::ResetFeaturesHaveBeenExtracted | ( | ) |
void tesseract::Classify::SetAdaptiveThreshold | ( | FLOAT32 | Threshold | ) |
This routine resets the internal thresholds inside the integer matcher to correspond to the specified threshold.
Threshold | threshold for creating new templates |
Globals:
void tesseract::Classify::SettupPass1 | ( | ) |
This routine prepares the adaptive matcher for the start of the first pass. Learning is enabled (unless it is disabled for the whole program).
Globals:
void tesseract::Classify::SettupPass2 | ( | ) |
This routine prepares the adaptive matcher for the start of the second pass. Further learning is disabled.
Globals:
const ShapeTable* tesseract::Classify::shape_table | ( | ) | const [inline] |
int tesseract::Classify::ShapeIDToClassID | ( | int | shape_id | ) | const |
void tesseract::Classify::ShowBestMatchFor | ( | TBLOB * | Blob, | |
const DENORM & | denorm, | |||
CLASS_ID | ClassId, | |||
int | shape_id, | |||
BOOL8 | AdaptiveOn, | |||
BOOL8 | PreTrainedOn, | |||
ADAPT_RESULTS * | Results | |||
) |
This routine compares Blob to both sets of templates (adaptive and pre-trained) and then displays debug information for the config which matched best.
Blob | blob to show best matching config for | |
ClassId | class whose configs are to be searched | |
AdaptiveOn | TRUE if adaptive configs are enabled | |
PreTrainedOn | TRUE if pretrained configs are enabled |
Globals:
void tesseract::Classify::ShowMatchDisplay | ( | ) |
bool tesseract::Classify::TempConfigReliable | ( | CLASS_ID | class_id, | |
const TEMP_CONFIG & | config | |||
) |
void tesseract::Classify::UpdateAmbigsGroup | ( | CLASS_ID | class_id, | |
const DENORM & | denorm, | |||
TBLOB * | Blob | |||
) |
void tesseract::Classify::WriteAdaptedTemplates | ( | FILE * | File, | |
ADAPT_TEMPLATES | Templates | |||
) |
This routine saves Templates to File in a binary format.
File | open text file to write Templates to | |
Templates | set of adapted templates to write to File |
void tesseract::Classify::WriteIntTemplates | ( | FILE * | File, | |
INT_TEMPLATES | Templates, | |||
const UNICHARSET & | target_unicharset | |||
) |
double tesseract::Classify::certainty_scale = 20.0 |
"Certainty scaling factor"
"Threshold for good features during adaptive 0-255"
"Threshold for good protos during adaptive 0-255"
"Assume the input is numbers [0-9]."
double tesseract::Classify::classify_char_norm_range = 0.2 |
"Character Normalization Range ..."
"Exclude fragments that do not match any whole character" " with at least this certainty"
"Class Pruner Multiplier 0-255: "
"Class Pruner Threshold 0-255"
"Class Pruner CutoffStrength: "
"Bring up graphical debugging windows for fragments training"
"Classify debug level"
"Enable match debugger"
"Enable adaptive classifier"
bool tesseract::Classify::classify_enable_learning = true |
"Enable adaptive classifier"
"Integer Matcher Multiplier 0-255: "
"Class str to debug learning"
"Learning Debug Level: "
double tesseract::Classify::classify_max_norm_scale_x = 0.325 |
"Max char x-norm scale ..."
double tesseract::Classify::classify_max_norm_scale_y = 0.325 |
"Max char y-norm scale ..."
double tesseract::Classify::classify_min_norm_scale_x = 0.0 |
"Min char x-norm scale ..."
double tesseract::Classify::classify_min_norm_scale_y = 0.0 |
"Min char y-norm scale ..."
double tesseract::Classify::classify_misfit_junk_penalty = 0.0 |
"Penalty to apply when a non-alnum is vertically out of " "its expected textline position"
int tesseract::Classify::classify_norm_method = character |
"Normalization Method ..."
"Save adapted templates to a file"
"Use pre-adapted classifier templates"
bool tesseract::Classify::disable_character_fragments = TRUE |
"Do not include character fragments in the" " results of the classifier"
"Dont adapt to i/I at beginning of word"
IntegerMatcher tesseract::Classify::im_ [protected] |
double tesseract::Classify::matcher_avg_noise_size = 12.0 |
"Avg. noise blob length: "
double tesseract::Classify::matcher_bad_match_pad = 0.15 |
"Bad Match Pad (0-1)"
double tesseract::Classify::matcher_clustering_max_angle_delta = 0.015 |
"Maximum angle delta for prototype clustering"
"Matcher Debug Flags"
"Matcher Debug Level"
bool tesseract::Classify::matcher_debug_separate_windows = FALSE |
"Use two different windows for debugging the matching: " "One for the protos and one for the features."
double tesseract::Classify::matcher_good_threshold = 0.125 |
"Good Match (0-1)"
double tesseract::Classify::matcher_great_threshold = 0.0 |
"Great Match (0-1)"
"Reliable Config Threshold"
double tesseract::Classify::matcher_perfect_threshold = 0.02 |
"Perfect Match (0-1)"
"Min # of permanent classes"
double tesseract::Classify::matcher_rating_margin = 0.1 |
"New template margin (0-1)"
"Enable adaption even if the ambiguities have not been seen"
bool tesseract::Classify::prioritize_division = FALSE |
"Prioritize blob division over chopping"
double tesseract::Classify::rating_scale = 1.5 |
"Rating scaling factor"
ShapeTable* tesseract::Classify::shape_table_ [protected] |
"Baseline Normalized Matching"
"Character Normalized Matching"
double tesseract::Classify::tessedit_class_miss_scale = 0.00390625 |
"Scale factor for features not used"
int tesseract::Classify::tessedit_single_match = FALSE |
"Top choice only from CP"