Tesseract 3.01
|
#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, |
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, |
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, |
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, | ||
FLOAT32 | rating, | ||
int | config, | ||
int | config2, | ||
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, |
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, |
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, |
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:
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:
int tesseract::Classify::ClassPruner | ( | INT_TEMPLATES | IntTemplates, |
inT16 | NumFeatures, | ||
INT_FEATURE_ARRAY | Features, | ||
CLASS_NORMALIZATION_ARRAY | NormalizationFactors, | ||
CLASS_CUTOFF_ARRAY | ExpectedNumFeatures, | ||
CLASS_PRUNER_RESULTS | Results | ||
) |
void tesseract::Classify::ComputeIntCharNormArray | ( | FEATURE | NormFeature, |
INT_TEMPLATES | Templates, | ||
CLASS_NORMALIZATION_ARRAY | CharNormArray | ||
) |
For each class in Templates, compute the match between NormFeature and the normalization protos for that class. Convert this number to the range from 0 - 255 and store it into CharNormArray. CharNormArray is indexed by class indicies (as obtained from Templates) rather than class id's.
Globals:
NormFeature | character normalization feature | |
Templates | specifies classes currently defined | |
[out] | CharNormArray | place to put results |
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, |
FEATURE | Feature, | ||
BOOL8 | DebugMatch | ||
) |
void tesseract::Classify::ConvertMatchesToChoices | ( | 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, |
ADAPT_RESULTS * | Results | ||
) |
Blob | blob whose classification is being debugged |
Results | results of match being debugged |
Globals: none
void tesseract::Classify::DisplayAdaptedChar | ( | TBLOB * | blob, |
INT_CLASS_STRUCT * | int_class | ||
) |
void tesseract::Classify::DoAdaptiveMatch | ( | TBLOB * | Blob, |
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:
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 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, |
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, |
INT_TEMPLATES | Templates, | ||
INT_FEATURE_ARRAY | IntFeatures, | ||
CLASS_NORMALIZATION_ARRAY | CharNormArray, | ||
inT32 * | BlobLength | ||
) |
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. CharNormArray is filled with 0's to indicate to the matcher that no character normalization adjustment needs to be done.
The total length of all blob outlines in baseline normalized units is also returned.
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: none
This routine classifies Blob against both sets of templates for the specified class and returns the best rating found.
Blob | blob to get best rating for |
ClassId | class blob is to be compared to |
Globals:
int tesseract::Classify::GetCharNormFeatures | ( | TBLOB * | Blob, |
INT_TEMPLATES | Templates, | ||
INT_FEATURE_ARRAY | IntFeatures, | ||
CLASS_NORMALIZATION_ARRAY | CharNormArray, | ||
inT32 * | BlobLength, | ||
inT32 * | FeatureOutlineIndex | ||
) |
This routine sets up the feature extractor to extract character normalization features and character normalized pico-features. The extracted pico-features are converted to integer form and placed in IntFeatures. The character normalization features are matched to each class in templates and the resulting adjustment factors are returned in CharNormArray. The total length of all blob outlines in baseline normalized units is also returned.
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 char norm adjustments |
BlobLength | length of blob in baseline-normalized units |
Globals: none
CLASS_ID tesseract::Classify::GetClassToDebug | ( | const char * | Prompt, |
bool * | adaptive_on, | ||
bool * | pretrained_on | ||
) |
Dict& tesseract::Classify::getDict | ( | ) | [inline] |
int tesseract::Classify::GetFontinfoId | ( | ADAPT_CLASS | Class, |
uinT8 | ConfigId | ||
) |
int tesseract::Classify::GetIntBaselineFeatures | ( | TBLOB * | Blob, |
INT_TEMPLATES | Templates, | ||
INT_FEATURE_ARRAY | IntFeatures, | ||
CLASS_NORMALIZATION_ARRAY | 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::GetIntCharNormFeatures | ( | TBLOB * | Blob, |
INT_TEMPLATES | Templates, | ||
INT_FEATURE_ARRAY | IntFeatures, | ||
CLASS_NORMALIZATION_ARRAY | 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:
void tesseract::Classify::InitAdaptedClass | ( | TBLOB * | Blob, |
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 | ||
) |
bool tesseract::Classify::LooksLikeGarbage | ( | TBLOB * | blob | ) |
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, | ||
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, | ||
INT_FEATURE_ARRAY | features, | ||
CLASS_NORMALIZATION_ARRAY | 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
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, |
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::ResetAdaptiveClassifier | ( | ) |
void tesseract::Classify::ResetFeaturesHaveBeenExtracted | ( | ) |
void tesseract::Classify::set_denorm | ( | const DENORM * | denorm | ) | [inline] |
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:
void tesseract::Classify::ShowBestMatchFor | ( | TBLOB * | Blob, |
CLASS_ID | ClassId, | ||
BOOL8 | AdaptiveOn, | ||
BOOL8 | PreTrainedOn | ||
) |
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::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"
"Enable integer fx"
bool tesseract::Classify::classify_enable_learning = true |
"Enable adaptive classifier"
"Enable new adaptation rules"
"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"
DENORM tesseract::Classify::denorm_ [protected] |
"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"
"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"
double tesseract::Classify::rating_scale = 1.5 |
"Rating scaling factor"
"Baseline Normalized Matching"
"Character Normalized Matching"
double tesseract::Classify::tessedit_class_miss_scale = 0.00390625 |
"Scale factor for features not used"
"Top choice only from CP"