tesseract::Wordrec Class Reference

#include <wordrec.h>

Inheritance diagram for tesseract::Wordrec:

Public Member Functions
	BOOL_VAR_H (merge_fragments_in_matrix)
	BOOL_VAR_H (wordrec_enable_assoc)
	BOOL_VAR_H (force_word_assoc)
	INT_VAR_H (repair_unchopped_blobs)
	double_VAR_H (tessedit_certainty_threshold)
	INT_VAR_H (chop_debug)
	BOOL_VAR_H (chop_enable)
	BOOL_VAR_H (chop_vertical_creep)
	INT_VAR_H (chop_split_length)
	INT_VAR_H (chop_same_distance)
	INT_VAR_H (chop_min_outline_points)
	INT_VAR_H (chop_seam_pile_size)
	BOOL_VAR_H (chop_new_seam_pile)
	INT_VAR_H (chop_inside_angle)
	INT_VAR_H (chop_min_outline_area)
	double_VAR_H (chop_split_dist_knob)
	double_VAR_H (chop_overlap_knob)
	double_VAR_H (chop_center_knob)
	INT_VAR_H (chop_centered_maxwidth)
	double_VAR_H (chop_sharpness_knob)
	double_VAR_H (chop_width_change_knob)
	double_VAR_H (chop_ok_split)
	double_VAR_H (chop_good_split)
	INT_VAR_H (chop_x_y_weight)
	BOOL_VAR_H (assume_fixed_pitch_char_segment)
	INT_VAR_H (wordrec_debug_level)
	INT_VAR_H (wordrec_max_join_chunks)
	BOOL_VAR_H (wordrec_skip_no_truth_words)
	BOOL_VAR_H (wordrec_debug_blamer)
	BOOL_VAR_H (wordrec_run_blamer)
	INT_VAR_H (segsearch_debug_level)
	INT_VAR_H (segsearch_max_pain_points)
	INT_VAR_H (segsearch_max_futile_classifications)
	double_VAR_H (segsearch_max_char_wh_ratio)
	BOOL_VAR_H (save_alt_choices)
	Wordrec ()
	~Wordrec () override=default
void	SaveAltChoices (const LIST &best_choices, WERD_RES *word)
void	FillLattice (const MATRIX &ratings, const WERD_CHOICE_LIST &best_choices, const UNICHARSET &unicharset, BlamerBundle *blamer_bundle)
void	CallFillLattice (const MATRIX &ratings, const WERD_CHOICE_LIST &best_choices, const UNICHARSET &unicharset, BlamerBundle *blamer_bundle)
void	SegSearch (WERD_RES *word_res, BestChoiceBundle *best_choice_bundle, BlamerBundle *blamer_bundle)
void	InitialSegSearch (WERD_RES *word_res, LMPainPoints *pain_points, std::vector< SegSearchPending > *pending, BestChoiceBundle *best_choice_bundle, BlamerBundle *blamer_bundle)
void	add_seam_to_queue (float new_priority, SEAM *new_seam, SeamQueue *seams)
void	choose_best_seam (SeamQueue *seam_queue, const SPLIT *split, PRIORITY priority, SEAM **seam_result, TBLOB *blob, SeamPile *seam_pile)
void	combine_seam (const SeamPile &seam_pile, const SEAM *seam, SeamQueue *seam_queue)
SEAM *	pick_good_seam (TBLOB *blob)
void	try_point_pairs (EDGEPT *points[MAX_NUM_POINTS], int16_t num_points, SeamQueue *seam_queue, SeamPile *seam_pile, SEAM **seam, TBLOB *blob)
void	try_vertical_splits (EDGEPT *points[MAX_NUM_POINTS], int16_t num_points, EDGEPT_CLIST *new_points, SeamQueue *seam_queue, SeamPile *seam_pile, SEAM **seam, TBLOB *blob)
PRIORITY	grade_split_length (SPLIT *split)
PRIORITY	grade_sharpness (SPLIT *split)
bool	near_point (EDGEPT *point, EDGEPT *line_pt_0, EDGEPT *line_pt_1, EDGEPT **near_pt)
virtual BLOB_CHOICE_LIST *	classify_piece (const std::vector< SEAM * > &seams, int16_t start, int16_t end, const char *description, TWERD *word, BlamerBundle *blamer_bundle)
program_editup
Initialize all the things in the program that need to be initialized. init_permute determines whether to initialize the permute functions and Dawg models.
void	program_editup (const std::string &textbase, TessdataManager *init_classifier, TessdataManager *init_dict)
cc_recog
Recognize a word.
void	cc_recog (WERD_RES *word)
program_editdown
This function holds any necessary post processing for the Wise Owl program.
void	program_editdown (int32_t elasped_time)
set_pass1
Get ready to do some pass 1 stuff.
void	set_pass1 ()
set_pass2
Get ready to do some pass 2 stuff.
void	set_pass2 ()
end_recog
Cleanup and exit the recog program.
int	end_recog ()
call_matcher
Called from Tess with a blob in tess form. The blob may need rotating to the correct orientation for classification.
BLOB_CHOICE_LIST *	call_matcher (TBLOB *blob)
dict_word()
Test the dictionaries, returning NO_PERM (0) if not found, or one of the PermuterType values if found, according to the dictionary.
int	dict_word (const WERD_CHOICE &word)
classify_blob
Classify the this blob if it is not already recorded in the match table. Attempt to recognize this blob as a character. The recognition rating for this blob will be stored as a part of the blob. This value will also be returned to the caller. Parameters blob Current blob string The string to display in ScrollView color The colour to use when displayed with ScrollView
BLOB_CHOICE_LIST *	classify_blob (TBLOB *blob, const char *string, ScrollView::Color color, BlamerBundle *blamer_bundle)
point_priority
Assign a priority to and edge point that might be used as part of a split. The argument should be of type EDGEPT.
PRIORITY	point_priority (EDGEPT *point)
add_point_to_list
Add an edge point to a POINT_GROUP containing a list of other points.
void	add_point_to_list (PointHeap *point_heap, EDGEPT *point)
bool	is_inside_angle (EDGEPT *pt)
angle_change
Return the change in angle (degrees) of the line segments between points one and two, and two and three.
int	angle_change (EDGEPT *point1, EDGEPT *point2, EDGEPT *point3)
pick_close_point
Choose the edge point that is closest to the critical point. This point may not be exactly vertical from the critical point.
EDGEPT *	pick_close_point (EDGEPT *critical_point, EDGEPT *vertical_point, int *best_dist)
prioritize_points
Find a list of edge points from the outer outline of this blob. For each of these points assign a priority. Sort these points using a heap structure so that they can be visited in order.
void	prioritize_points (TESSLINE *outline, PointHeap *points)
new_min_point
Found a new minimum point try to decide whether to save it or not. Return the new value for the local minimum. If a point is saved then the local minimum is reset to nullptr.
void	new_min_point (EDGEPT *local_min, PointHeap *points)
new_max_point
Found a new minimum point try to decide whether to save it or not. Return the new value for the local minimum. If a point is saved then the local minimum is reset to nullptr.
void	new_max_point (EDGEPT *local_max, PointHeap *points)
vertical_projection_point
For one point on the outline, find the corresponding point on the other side of the outline that is a likely projection for a split point. This is done by iterating through the edge points until the X value of the point being looked at is greater than the X value of the split point. Ensure that the point being returned is not right next to the split point. Return the edge point in *best_point as a result, and any points that were newly created are also saved on the new_points list.
void	vertical_projection_point (EDGEPT *split_point, EDGEPT *target_point, EDGEPT **best_point, EDGEPT_CLIST *new_points)
attempt_blob_chop
Try to split the this blob after this one. Check to make sure that it was successful.
SEAM *	attempt_blob_chop (TWERD *word, TBLOB *blob, int32_t blob_number, bool italic_blob, const std::vector< SEAM * > &seams)
SEAM *	chop_numbered_blob (TWERD *word, int32_t blob_number, bool italic_blob, const std::vector< SEAM * > &seams)
SEAM *	chop_overlapping_blob (const std::vector< TBOX > &boxes, bool italic_blob, WERD_RES *word_res, unsigned *blob_number)
improve_one_blob
Finds the best place to chop, based on the worst blob, fixpt, or next to a fragment, according to the input. Returns the SEAM corresponding to the chop point, if any is found, and the index in the ratings_matrix of the chopped blob. Note that blob_choices is just a copy of the pointers in the leading diagonal of the ratings MATRIX. Although the blob is chopped, the returned SEAM is yet to be inserted into word->seam_array and the resulting blobs are unclassified, so this function can be used by ApplyBox as well as during recognition.
SEAM *	improve_one_blob (const std::vector< BLOB_CHOICE * > &blob_choices, DANGERR *fixpt, bool split_next_to_fragment, bool italic_blob, WERD_RES *word, unsigned *blob_number)
chop_one_blob
Start with the current one-blob word and its classification. Find the worst blobs and try to divide it up to improve the ratings. Used for testing chopper.
SEAM *	chop_one_blob (const std::vector< TBOX > &boxes, const std::vector< BLOB_CHOICE * > &blob_choices, WERD_RES *word_res, unsigned *blob_number)
chop_word_main
Classify the blobs in this word and permute the results. Find the worst blob in the word and chop it up. Continue this process until a good answer has been found or all the blobs have been chopped up enough. The results are returned in the WERD_RES.
void	chop_word_main (WERD_RES *word)
improve_by_chopping
Repeatedly chops the worst blob, classifying the new blobs fixing up all the data, and incrementally runs the segmentation search until a good word is found, or no more chops can be found.
void	improve_by_chopping (float rating_cert_scale, WERD_RES *word, BestChoiceBundle *best_choice_bundle, BlamerBundle *blamer_bundle, LMPainPoints *pain_points, std::vector< SegSearchPending > *pending)
int	select_blob_to_split (const std::vector< BLOB_CHOICE * > &blob_choices, float rating_ceiling, bool split_next_to_fragment)
int	select_blob_to_split_from_fixpt (DANGERR *fixpt)
Public Member Functions inherited from tesseract::Classify
	Classify ()
	~Classify () override
virtual Dict &	getDict ()
const ShapeTable *	shape_table () const
void	SetStaticClassifier (ShapeClassifier *static_classifier)
void	AddLargeSpeckleTo (int blob_length, BLOB_CHOICE_LIST *choices)
bool	LargeSpeckle (const TBLOB &blob)
int	GetFontinfoId (ADAPT_CLASS_STRUCT *Class, uint8_t ConfigId)
int	PruneClasses (const INT_TEMPLATES_STRUCT *int_templates, int num_features, int keep_this, const INT_FEATURE_STRUCT *features, const uint8_t *normalization_factors, const uint16_t *expected_num_features, std::vector< CP_RESULT_STRUCT > *results)
void	ReadNewCutoffs (TFile *fp, uint16_t *Cutoffs)
void	PrintAdaptedTemplates (FILE *File, ADAPT_TEMPLATES_STRUCT *Templates)
void	WriteAdaptedTemplates (FILE *File, ADAPT_TEMPLATES_STRUCT *Templates)
ADAPT_TEMPLATES_STRUCT *	ReadAdaptedTemplates (TFile *File)
void	ConvertProto (PROTO_STRUCT *Proto, int ProtoId, INT_CLASS_STRUCT *Class)
INT_TEMPLATES_STRUCT *	CreateIntTemplates (CLASSES FloatProtos, const UNICHARSET &target_unicharset)
void	LearnWord (const char *fontname, WERD_RES *word)
void	LearnPieces (const char *fontname, int start, int length, float threshold, CharSegmentationType segmentation, const char *correct_text, WERD_RES *word)
void	InitAdaptiveClassifier (TessdataManager *mgr)
void	InitAdaptedClass (TBLOB *Blob, CLASS_ID ClassId, int FontinfoId, ADAPT_CLASS_STRUCT *Class, ADAPT_TEMPLATES_STRUCT *Templates)
void	AmbigClassifier (const std::vector< INT_FEATURE_STRUCT > &int_features, const INT_FX_RESULT_STRUCT &fx_info, const TBLOB *blob, INT_TEMPLATES_STRUCT *templates, ADAPT_CLASS_STRUCT **classes, UNICHAR_ID *ambiguities, ADAPT_RESULTS *results)
void	MasterMatcher (INT_TEMPLATES_STRUCT *templates, int16_t num_features, const INT_FEATURE_STRUCT *features, const uint8_t *norm_factors, ADAPT_CLASS_STRUCT **classes, int debug, int matcher_multiplier, const TBOX &blob_box, const std::vector< CP_RESULT_STRUCT > &results, ADAPT_RESULTS *final_results)
void	ExpandShapesAndApplyCorrections (ADAPT_CLASS_STRUCT **classes, bool debug, int class_id, int bottom, int top, float cp_rating, int blob_length, int matcher_multiplier, const uint8_t *cn_factors, UnicharRating *int_result, ADAPT_RESULTS *final_results)
double	ComputeCorrectedRating (bool debug, int unichar_id, double cp_rating, double im_rating, int feature_misses, int bottom, int top, int blob_length, int matcher_multiplier, const uint8_t *cn_factors)
void	ConvertMatchesToChoices (const DENORM &denorm, const TBOX &box, ADAPT_RESULTS *Results, BLOB_CHOICE_LIST *Choices)
void	AddNewResult (const UnicharRating &new_result, ADAPT_RESULTS *results)
int	GetAdaptiveFeatures (TBLOB *Blob, INT_FEATURE_ARRAY IntFeatures, FEATURE_SET *FloatFeatures)
void	DebugAdaptiveClassifier (TBLOB *Blob, ADAPT_RESULTS *Results)
PROTO_ID	MakeNewTempProtos (FEATURE_SET Features, int NumBadFeat, FEATURE_ID BadFeat[], INT_CLASS_STRUCT *IClass, ADAPT_CLASS_STRUCT *Class, BIT_VECTOR TempProtoMask)
int	MakeNewTemporaryConfig (ADAPT_TEMPLATES_STRUCT *Templates, CLASS_ID ClassId, int FontinfoId, int NumFeatures, INT_FEATURE_ARRAY Features, FEATURE_SET FloatFeatures)
void	MakePermanent (ADAPT_TEMPLATES_STRUCT *Templates, CLASS_ID ClassId, int ConfigId, TBLOB *Blob)
void	PrintAdaptiveMatchResults (const ADAPT_RESULTS &results)
void	RemoveExtraPuncs (ADAPT_RESULTS *Results)
void	RemoveBadMatches (ADAPT_RESULTS *Results)
void	SetAdaptiveThreshold (float Threshold)
void	ShowBestMatchFor (int shape_id, const INT_FEATURE_STRUCT *features, int num_features)
std::string	ClassIDToDebugStr (const INT_TEMPLATES_STRUCT *templates, int class_id, int config_id) const
int	ClassAndConfigIDToFontOrShapeID (int class_id, int int_result_config) const
int	ShapeIDToClassID (int shape_id) const
UNICHAR_ID *	BaselineClassifier (TBLOB *Blob, const std::vector< INT_FEATURE_STRUCT > &int_features, const INT_FX_RESULT_STRUCT &fx_info, ADAPT_TEMPLATES_STRUCT *Templates, ADAPT_RESULTS *Results)
int	CharNormClassifier (TBLOB *blob, const TrainingSample &sample, ADAPT_RESULTS *adapt_results)
int	CharNormTrainingSample (bool pruner_only, int keep_this, const TrainingSample &sample, std::vector< UnicharRating > *results)
UNICHAR_ID *	GetAmbiguities (TBLOB *Blob, CLASS_ID CorrectClass)
void	DoAdaptiveMatch (TBLOB *Blob, ADAPT_RESULTS *Results)
void	AdaptToChar (TBLOB *Blob, CLASS_ID ClassId, int FontinfoId, float Threshold, ADAPT_TEMPLATES_STRUCT *adaptive_templates)
void	DisplayAdaptedChar (TBLOB *blob, INT_CLASS_STRUCT *int_class)
bool	AdaptableWord (WERD_RES *word)
void	EndAdaptiveClassifier ()
void	SettupPass1 ()
void	SettupPass2 ()
void	AdaptiveClassifier (TBLOB *Blob, BLOB_CHOICE_LIST *Choices)
void	ClassifyAsNoise (ADAPT_RESULTS *Results)
void	ResetAdaptiveClassifierInternal ()
void	SwitchAdaptiveClassifier ()
void	StartBackupAdaptiveClassifier ()
int	GetCharNormFeature (const INT_FX_RESULT_STRUCT &fx_info, INT_TEMPLATES_STRUCT *templates, uint8_t *pruner_norm_array, uint8_t *char_norm_array)
void	ComputeCharNormArrays (FEATURE_STRUCT *norm_feature, INT_TEMPLATES_STRUCT *templates, uint8_t *char_norm_array, uint8_t *pruner_array)
bool	TempConfigReliable (CLASS_ID class_id, const TEMP_CONFIG_STRUCT *config)
void	UpdateAmbigsGroup (CLASS_ID class_id, TBLOB *Blob)
bool	AdaptiveClassifierIsFull () const
bool	AdaptiveClassifierIsEmpty () const
bool	LooksLikeGarbage (TBLOB *blob)
void	RefreshDebugWindow (ScrollView **win, const char *msg, int y_offset, const TBOX &wbox)
void	ClearCharNormArray (uint8_t *char_norm_array)
void	ComputeIntCharNormArray (const FEATURE_STRUCT &norm_feature, uint8_t *char_norm_array)
void	ComputeIntFeatures (FEATURE_SET Features, INT_FEATURE_ARRAY IntFeatures)
INT_TEMPLATES_STRUCT *	ReadIntTemplates (TFile *fp)
void	WriteIntTemplates (FILE *File, INT_TEMPLATES_STRUCT *Templates, const UNICHARSET &target_unicharset)
CLASS_ID	GetClassToDebug (const char *Prompt, bool *adaptive_on, bool *pretrained_on, int *shape_id)
void	ShowMatchDisplay ()
UnicityTable< FontInfo > &	get_fontinfo_table ()
const UnicityTable< FontInfo > &	get_fontinfo_table () const
UnicityTable< FontSet > &	get_fontset_table ()
void	NormalizeOutlines (LIST Outlines, float *XScale, float *YScale)
FEATURE_SET	ExtractOutlineFeatures (TBLOB *Blob)
FEATURE_SET	ExtractPicoFeatures (TBLOB *Blob)
FEATURE_SET	ExtractIntCNFeatures (const TBLOB &blob, const INT_FX_RESULT_STRUCT &fx_info)
FEATURE_SET	ExtractIntGeoFeatures (const TBLOB &blob, const INT_FX_RESULT_STRUCT &fx_info)
void	LearnBlob (const std::string &fontname, TBLOB *Blob, const DENORM &cn_denorm, const INT_FX_RESULT_STRUCT &fx_info, const char *blob_text)
bool	WriteTRFile (const char *filename)
	BOOL_VAR_H (allow_blob_division)
	BOOL_VAR_H (prioritize_division)
	BOOL_VAR_H (classify_enable_learning)
	INT_VAR_H (classify_debug_level)
	INT_VAR_H (classify_norm_method)
	double_VAR_H (classify_char_norm_range)
	double_VAR_H (classify_max_rating_ratio)
	double_VAR_H (classify_max_certainty_margin)
	BOOL_VAR_H (tess_cn_matching)
	BOOL_VAR_H (tess_bn_matching)
	BOOL_VAR_H (classify_enable_adaptive_matcher)
	BOOL_VAR_H (classify_use_pre_adapted_templates)
	BOOL_VAR_H (classify_save_adapted_templates)
	BOOL_VAR_H (classify_enable_adaptive_debugger)
	BOOL_VAR_H (classify_nonlinear_norm)
	INT_VAR_H (matcher_debug_level)
	INT_VAR_H (matcher_debug_flags)
	INT_VAR_H (classify_learning_debug_level)
	double_VAR_H (matcher_good_threshold)
	double_VAR_H (matcher_reliable_adaptive_result)
	double_VAR_H (matcher_perfect_threshold)
	double_VAR_H (matcher_bad_match_pad)
	double_VAR_H (matcher_rating_margin)
	double_VAR_H (matcher_avg_noise_size)
	INT_VAR_H (matcher_permanent_classes_min)
	INT_VAR_H (matcher_min_examples_for_prototyping)
	INT_VAR_H (matcher_sufficient_examples_for_prototyping)
	double_VAR_H (matcher_clustering_max_angle_delta)
	double_VAR_H (classify_misfit_junk_penalty)
	double_VAR_H (rating_scale)
	double_VAR_H (tessedit_class_miss_scale)
	double_VAR_H (classify_adapted_pruning_factor)
	double_VAR_H (classify_adapted_pruning_threshold)
	INT_VAR_H (classify_adapt_proto_threshold)
	INT_VAR_H (classify_adapt_feature_threshold)
	BOOL_VAR_H (disable_character_fragments)
	double_VAR_H (classify_character_fragments_garbage_certainty_threshold)
	BOOL_VAR_H (classify_debug_character_fragments)
	BOOL_VAR_H (matcher_debug_separate_windows)
	STRING_VAR_H (classify_learn_debug_str)
	INT_VAR_H (classify_class_pruner_threshold)
	INT_VAR_H (classify_class_pruner_multiplier)
	INT_VAR_H (classify_cp_cutoff_strength)
	INT_VAR_H (classify_integer_matcher_multiplier)
	BOOL_VAR_H (classify_bln_numeric_mode)
	double_VAR_H (speckle_large_max_size)
	double_VAR_H (speckle_rating_penalty)
float	ComputeNormMatch (CLASS_ID ClassId, const FEATURE_STRUCT &feature, bool DebugMatch)
void	FreeNormProtos ()
NORM_PROTOS *	ReadNormProtos (TFile *fp)
Public Member Functions inherited from tesseract::CCUtil
	CCUtil ()
virtual	~CCUtil ()
void	main_setup (const std::string &argv0, const std::string &basename)
	CCUtil::main_setup - set location of tessdata and name of image. More...
ParamsVectors *	params ()
	INT_VAR_H (ambigs_debug_level)
	BOOL_VAR_H (use_ambigs_for_adaption)

Public Attributes
std::unique_ptr< LanguageModel >	language_model_
PRIORITY	pass2_ok_split
WERD_CHOICE *	prev_word_best_choice_
void(Wordrec::*	fill_lattice_ )(const MATRIX &ratings, const WERD_CHOICE_LIST &best_choices, const UNICHARSET &unicharset, BlamerBundle *blamer_bundle)
Public Attributes inherited from tesseract::Classify
INT_TEMPLATES_STRUCT *	PreTrainedTemplates = nullptr
ADAPT_TEMPLATES_STRUCT *	AdaptedTemplates = nullptr
ADAPT_TEMPLATES_STRUCT *	BackupAdaptedTemplates = nullptr
BIT_VECTOR	AllProtosOn = nullptr
BIT_VECTOR	AllConfigsOn = nullptr
BIT_VECTOR	AllConfigsOff = nullptr
BIT_VECTOR	TempProtoMask = nullptr
NORM_PROTOS *	NormProtos = nullptr
UnicityTable< FontInfo >	fontinfo_table_
UnicityTable< FontSet >	fontset_table_
bool	EnableLearning = true
Public Attributes inherited from tesseract::CCUtil
std::string	datadir
std::string	imagebasename
std::string	lang
std::string	language_data_path_prefix
UNICHARSET	unicharset
UnicharAmbigs	unichar_ambigs
std::string	imagefile
std::string	directory

Protected Member Functions
bool	SegSearchDone (int num_futile_classifications)
void	UpdateSegSearchNodes (float rating_cert_scale, int starting_col, std::vector< SegSearchPending > *pending, WERD_RES *word_res, LMPainPoints *pain_points, BestChoiceBundle *best_choice_bundle, BlamerBundle *blamer_bundle)
void	ProcessSegSearchPainPoint (float pain_point_priority, const MATRIX_COORD &pain_point, const char *pain_point_type, std::vector< SegSearchPending > *pending, WERD_RES *word_res, LMPainPoints *pain_points, BlamerBundle *blamer_bundle)
void	ResetNGramSearch (WERD_RES *word_res, BestChoiceBundle *best_choice_bundle, std::vector< SegSearchPending > &pending)
void	InitBlamerForSegSearch (WERD_RES *word_res, LMPainPoints *pain_points, BlamerBundle *blamer_bundle, std::string &blamer_debug)

Additional Inherited Members
Static Public Member Functions inherited from tesseract::Classify
static void	SetupBLCNDenorms (const TBLOB &blob, bool nonlinear_norm, DENORM *bl_denorm, DENORM *cn_denorm, INT_FX_RESULT_STRUCT *fx_info)
static void	ExtractFeatures (const TBLOB &blob, bool nonlinear_norm, std::vector< INT_FEATURE_STRUCT > *bl_features, std::vector< INT_FEATURE_STRUCT > *cn_features, INT_FX_RESULT_STRUCT *results, std::vector< int > *outline_cn_counts)
Static Public Attributes inherited from tesseract::CCStruct
static const double	kDescenderFraction = 0.25
static const double	kXHeightFraction = 0.5
static const double	kAscenderFraction = 0.25
static const double	kXHeightCapRatio
Protected Attributes inherited from tesseract::Classify
IntegerMatcher	im_
FEATURE_DEFS_STRUCT	feature_defs_
ShapeTable *	shape_table_ = nullptr

Detailed Description

Definition at line 186 of file wordrec.h.

Constructor & Destructor Documentation

Wordrec()

tesseract::Wordrec::Wordrec

(

)

Definition at line 46 of file wordrec.cpp.

    : // control parameters
    BOOL_MEMBER(merge_fragments_in_matrix, true,
                "Merge the fragments in the ratings matrix and delete them"
                " after merging",
                params())
    , BOOL_MEMBER(wordrec_enable_assoc, true, "Associator Enable", params())
    , BOOL_MEMBER(force_word_assoc, false,
                  "force associator to run regardless of what enable_assoc is."
                  " This is used for CJK where component grouping is necessary.",
                  CCUtil::params())
    , INT_MEMBER(repair_unchopped_blobs, 1, "Fix blobs that aren't chopped", params())
    , double_MEMBER(tessedit_certainty_threshold, -2.25, "Good blob limit", params())
    , INT_MEMBER(chop_debug, 0, "Chop debug", params())
    , BOOL_MEMBER(chop_enable, 1, "Chop enable", params())
    , BOOL_MEMBER(chop_vertical_creep, 0, "Vertical creep", params())
    , INT_MEMBER(chop_split_length, 10000, "Split Length", params())
    , INT_MEMBER(chop_same_distance, 2, "Same distance", params())
    , INT_MEMBER(chop_min_outline_points, 6, "Min Number of Points on Outline", params())
    , INT_MEMBER(chop_seam_pile_size, 150, "Max number of seams in seam_pile", params())
    , BOOL_MEMBER(chop_new_seam_pile, 1, "Use new seam_pile", params())
    , INT_MEMBER(chop_inside_angle, -50, "Min Inside Angle Bend", params())
    , INT_MEMBER(chop_min_outline_area, 2000, "Min Outline Area", params())
    , double_MEMBER(chop_split_dist_knob, 0.5, "Split length adjustment", params())
    , double_MEMBER(chop_overlap_knob, 0.9, "Split overlap adjustment", params())
    , double_MEMBER(chop_center_knob, 0.15, "Split center adjustment", params())
    , INT_MEMBER(chop_centered_maxwidth, 90,
                 "Width of (smaller) chopped blobs "
                 "above which we don't care that a chop is not near the center.",
                 params())
    , double_MEMBER(chop_sharpness_knob, 0.06, "Split sharpness adjustment", params())
    , double_MEMBER(chop_width_change_knob, 5.0, "Width change adjustment", params())
    , double_MEMBER(chop_ok_split, 100.0, "OK split limit", params())
    , double_MEMBER(chop_good_split, 50.0, "Good split limit", params())
    , INT_MEMBER(chop_x_y_weight, 3, "X / Y  length weight", params())
    , BOOL_MEMBER(assume_fixed_pitch_char_segment, false,
                  "include fixed-pitch heuristics in char segmentation", params())
    , INT_MEMBER(wordrec_debug_level, 0, "Debug level for wordrec", params())
    , INT_MEMBER(wordrec_max_join_chunks, 4, "Max number of broken pieces to associate", params())
    , BOOL_MEMBER(wordrec_skip_no_truth_words, false,
                  "Only run OCR for words that had truth recorded in BlamerBundle", params())
    , BOOL_MEMBER(wordrec_debug_blamer, false, "Print blamer debug messages", params())
    , BOOL_MEMBER(wordrec_run_blamer, false, "Try to set the blame for errors", params())
    , INT_MEMBER(segsearch_debug_level, 0, "SegSearch debug level", params())
    , INT_MEMBER(segsearch_max_pain_points, 2000,
                 "Maximum number of pain points stored in the queue", params())
    , INT_MEMBER(segsearch_max_futile_classifications, 20,
                 "Maximum number of pain point classifications per chunk that"
                 " did not result in finding a better word choice.",
                 params())
    , double_MEMBER(segsearch_max_char_wh_ratio, 2.0, "Maximum character width-to-height ratio",
                    params())
    , BOOL_MEMBER(save_alt_choices, true,
                  "Save alternative paths found during chopping"
                  " and segmentation search",
                  params())
    , pass2_ok_split(0.0f) {
  prev_word_best_choice_ = nullptr;
  language_model_ = std::make_unique<LanguageModel>(&get_fontinfo_table(), &(getDict()));
  fill_lattice_ = nullptr;
}

~Wordrec()

tesseract::Wordrec::~Wordrec ( )

overridedefault

Member Function Documentation

add_point_to_list()

void tesseract::Wordrec::add_point_to_list	(	PointHeap *	point_heap,
		EDGEPT *	point
	)

Definition at line 73 of file chop.cpp.

                                                                    {
  if (point_heap->size() < MAX_NUM_POINTS - 2) {
    PointPair pair(point_priority(point), point);
    point_heap->Push(&pair);
  }
 
#ifndef GRAPHICS_DISABLED
  if (chop_debug > 2) {
    mark_outline(point);
  }
#endif
}

add_seam_to_queue()

void tesseract::Wordrec::add_seam_to_queue	(	float	new_priority,
		SEAM *	new_seam,
		SeamQueue *	seams
	)

Definition at line 64 of file findseam.cpp.

                                                                                    {
  if (new_seam == nullptr) {
    return;
  }
  if (chop_debug) {
    tprintf("Pushing new seam with priority %g :", new_priority);
    new_seam->Print("seam: ");
  }
  if (seams->size() >= MAX_NUM_SEAMS) {
    SeamPair old_pair(0, nullptr);
    if (seams->PopWorst(&old_pair) && old_pair.key() <= new_priority) {
      if (chop_debug) {
        tprintf("Old seam staying with priority %g\n", old_pair.key());
      }
      delete new_seam;
      seams->Push(&old_pair);
      return;
    } else if (chop_debug) {
      tprintf("New seam with priority %g beats old worst seam with %g\n", new_priority,
              old_pair.key());
    }
  }
  SeamPair new_pair(new_priority, new_seam);
  seams->Push(&new_pair);
}

angle_change()

int tesseract::Wordrec::angle_change	(	EDGEPT *	point1,
		EDGEPT *	point2,
		EDGEPT *	point3
	)

Definition at line 98 of file chop.cpp.

                                                                        {
  VECTOR vector1;
  VECTOR vector2;
 
  int angle;
 
  /* Compute angle */
  vector1.x = point2->pos.x - point1->pos.x;
  vector1.y = point2->pos.y - point1->pos.y;
  vector2.x = point3->pos.x - point2->pos.x;
  vector2.y = point3->pos.y - point2->pos.y;
  /* Use cross product */
  float length = std::sqrt(static_cast<float>(vector1.length()) * vector2.length());
  if (static_cast<int>(length) == 0) {
    return (0);
  }
  angle = static_cast<int>(floor(std::asin(vector1.cross(vector2) / length) / M_PI * 180.0 + 0.5));
 
  /* Use dot product */
  if (vector1.dot(vector2) < 0) {
    angle = 180 - angle;
  }
  /* Adjust angle */
  if (angle > 180) {
    angle -= 360;
  }
  if (angle <= -180) {
    angle += 360;
  }
  return (angle);
}

attempt_blob_chop()

SEAM * tesseract::Wordrec::attempt_blob_chop	(	TWERD *	word,
		TBLOB *	blob,
		int32_t	blob_number,
		bool	italic_blob,
		const std::vector< SEAM * > &	seams
	)

Definition at line 207 of file chopper.cpp.

                                                                 {
  if (repair_unchopped_blobs) {
    preserve_outline_tree(blob->outlines);
  }
  TBLOB *other_blob = TBLOB::ShallowCopy(*blob); /* Make new blob */
  // Insert it into the word.
  word->blobs.insert(word->blobs.begin() + blob_number + 1, other_blob);
 
  SEAM *seam = nullptr;
  if (prioritize_division) {
    TPOINT location;
    if (divisible_blob(blob, italic_blob, &location)) {
      seam = new SEAM(0.0f, location);
    }
  }
  if (seam == nullptr) {
    seam = pick_good_seam(blob);
  }
  if (chop_debug) {
    if (seam != nullptr) {
      seam->Print("Good seam picked=");
    } else {
      tprintf("\n** no seam picked *** \n");
    }
  }
  if (seam) {
    seam->ApplySeam(italic_blob, blob, other_blob);
  }
 
  seam = CheckSeam(chop_debug, blob_number, word, blob, other_blob, seams, seam);
  if (seam == nullptr) {
    if (repair_unchopped_blobs) {
      restore_outline_tree(blob->outlines);
    }
    if (allow_blob_division && !prioritize_division) {
      // If the blob can simply be divided into outlines, then do that.
      TPOINT location;
      if (divisible_blob(blob, italic_blob, &location)) {
        other_blob = TBLOB::ShallowCopy(*blob); /* Make new blob */
        word->blobs.insert(word->blobs.begin() + blob_number + 1, other_blob);
        seam = new SEAM(0.0f, location);
        seam->ApplySeam(italic_blob, blob, other_blob);
        seam = CheckSeam(chop_debug, blob_number, word, blob, other_blob, seams, seam);
      }
    }
  }
  if (seam != nullptr) {
    // Make sure this seam doesn't get chopped again.
    seam->Finalize();
  }
  return seam;
}

BOOL_VAR_H() [1/11]

tesseract::Wordrec::BOOL_VAR_H

(

assume_fixed_pitch_char_segment

)

BOOL_VAR_H() [2/11]

tesseract::Wordrec::BOOL_VAR_H

(

chop_enable

)

BOOL_VAR_H() [3/11]

tesseract::Wordrec::BOOL_VAR_H

(

chop_new_seam_pile

)

BOOL_VAR_H() [4/11]

tesseract::Wordrec::BOOL_VAR_H

(

chop_vertical_creep

)

BOOL_VAR_H() [5/11]

tesseract::Wordrec::BOOL_VAR_H

(

force_word_assoc

)

BOOL_VAR_H() [6/11]

tesseract::Wordrec::BOOL_VAR_H

(

merge_fragments_in_matrix

)

BOOL_VAR_H() [7/11]

tesseract::Wordrec::BOOL_VAR_H

(

save_alt_choices

)

BOOL_VAR_H() [8/11]

tesseract::Wordrec::BOOL_VAR_H

(

wordrec_debug_blamer

)

BOOL_VAR_H() [9/11]

tesseract::Wordrec::BOOL_VAR_H

(

wordrec_enable_assoc

)

BOOL_VAR_H() [10/11]

tesseract::Wordrec::BOOL_VAR_H

(

wordrec_run_blamer

)

BOOL_VAR_H() [11/11]

tesseract::Wordrec::BOOL_VAR_H

(

wordrec_skip_no_truth_words

)

call_matcher()

BLOB_CHOICE_LIST * tesseract::Wordrec::call_matcher

(

TBLOB *

blob

)

Definition at line 132 of file tface.cpp.

                                                       {
  // Rotate the blob for classification if necessary.
  TBLOB *rotated_blob = tessblob->ClassifyNormalizeIfNeeded();
  if (rotated_blob == nullptr) {
    rotated_blob = tessblob;
  }
  auto *ratings = new BLOB_CHOICE_LIST(); // matcher result
  AdaptiveClassifier(rotated_blob, ratings);
  if (rotated_blob != tessblob) {
    delete rotated_blob;
  }
  return ratings;
}

CallFillLattice()

void tesseract::Wordrec::CallFillLattice ( const MATRIX &  ratings, const WERD_CHOICE_LIST &  best_choices, const UNICHARSET &  unicharset, BlamerBundle *  blamer_bundle  )

inline

Definition at line 240 of file wordrec.h.

                                                                                  {
    (this->*fill_lattice_)(ratings, best_choices, unicharset, blamer_bundle);
  }

cc_recog()

void tesseract::Wordrec::cc_recog

(

WERD_RES *

word

)

Definition at line 119 of file tface.cpp.

                                     {
  getDict().reset_hyphen_vars(word->word->flag(W_EOL));
  chop_word_main(word);
  word->DebugWordChoices(getDict().stopper_debug_level >= 1, getDict().word_to_debug.c_str());
  ASSERT_HOST(word->StatesAllValid());
}

choose_best_seam()

void tesseract::Wordrec::choose_best_seam	(	SeamQueue *	seam_queue,
		const SPLIT *	split,
		PRIORITY	priority,
		SEAM **	seam_result,
		TBLOB *	blob,
		SeamPile *	seam_pile
	)

Definition at line 103 of file findseam.cpp.

                                                                                     {
  SEAM *seam;
  float my_priority;
  /* Add seam of split */
  my_priority = priority;
  if (split != nullptr) {
    TPOINT split_point = split->point1->pos;
    split_point += split->point2->pos;
    split_point /= 2;
    seam = new SEAM(my_priority, split_point, *split);
    if (chop_debug > 1) {
      seam->Print("Partial priority    ");
    }
    add_seam_to_queue(my_priority, seam, seam_queue);
 
    if (my_priority > chop_good_split) {
      return;
    }
  }
 
  TBOX bbox = blob->bounding_box();
  /* Queue loop */
  while (!seam_queue->empty()) {
    SeamPair seam_pair;
    seam_queue->Pop(&seam_pair);
    seam = seam_pair.extract_data();
    /* Set full priority */
    my_priority =
        seam->FullPriority(bbox.left(), bbox.right(), chop_overlap_knob, chop_centered_maxwidth,
                           chop_center_knob, chop_width_change_knob);
    if (chop_debug) {
      char str[80];
      snprintf(str, sizeof(str), "Full my_priority %0.0f,  ", my_priority);
      seam->Print(str);
    }
 
    if ((*seam_result == nullptr || (*seam_result)->priority() > my_priority) &&
        my_priority < chop_ok_split) {
      /* No crossing */
      if (seam->IsHealthy(*blob, chop_min_outline_points, chop_min_outline_area)) {
        delete *seam_result;
        *seam_result = new SEAM(*seam);
        (*seam_result)->set_priority(my_priority);
      } else {
        delete seam;
        seam = nullptr;
        my_priority = BAD_PRIORITY;
      }
    }
 
    if (my_priority < chop_good_split) {
      delete seam;
      return; /* Made good answer */
    }
 
    if (seam) {
      /* Combine with others */
      if (seam_pile->size() < chop_seam_pile_size) {
        combine_seam(*seam_pile, seam, seam_queue);
        SeamDecPair pair(seam_pair.key(), seam);
        seam_pile->Push(&pair);
      } else if (chop_new_seam_pile && seam_pile->size() == chop_seam_pile_size &&
                 seam_pile->PeekTop().key() > seam_pair.key()) {
        combine_seam(*seam_pile, seam, seam_queue);
        SeamDecPair pair;
        seam_pile->Pop(&pair); // pop the worst.
        // Replace the seam in pair (deleting the old one) with
        // the new seam and score, then push back into the heap.
        pair.set_key(seam_pair.key());
        pair.set_data(seam);
        seam_pile->Push(&pair);
      } else {
        delete seam;
      }
    }
 
    my_priority = seam_queue->empty() ? NO_FULL_PRIORITY : seam_queue->PeekTop().key();
    if ((my_priority > chop_ok_split) || (my_priority > chop_good_split && split)) {
      return;
    }
  }
}

chop_numbered_blob()

SEAM * tesseract::Wordrec::chop_numbered_blob	(	TWERD *	word,
		int32_t	blob_number,
		bool	italic_blob,
		const std::vector< SEAM * > &	seams
	)

Definition at line 261 of file chopper.cpp.

                                                                  {
  return attempt_blob_chop(word, word->blobs[blob_number], blob_number, italic_blob, seams);
}

chop_one_blob()

SEAM * tesseract::Wordrec::chop_one_blob	(	const std::vector< TBOX > &	boxes,
		const std::vector< BLOB_CHOICE * > &	blob_choices,
		WERD_RES *	word_res,
		unsigned *	blob_number
	)

Definition at line 367 of file chopper.cpp.

                                                    {
  if (prioritize_division) {
    return chop_overlapping_blob(boxes, true, word_res, blob_number);
  } else {
    return improve_one_blob(blob_choices, nullptr, false, true, word_res, blob_number);
  }
}

chop_overlapping_blob()

SEAM * tesseract::Wordrec::chop_overlapping_blob	(	const std::vector< TBOX > &	boxes,
		bool	italic_blob,
		WERD_RES *	word_res,
		unsigned *	blob_number
	)

Definition at line 266 of file chopper.cpp.

                                                                                {
  TWERD *word = word_res->chopped_word;
  for (*blob_number = 0; *blob_number < word->NumBlobs(); ++*blob_number) {
    TBLOB *blob = word->blobs[*blob_number];
    TPOINT topleft, botright;
    topleft.x = blob->bounding_box().left();
    topleft.y = blob->bounding_box().top();
    botright.x = blob->bounding_box().right();
    botright.y = blob->bounding_box().bottom();
 
    TPOINT original_topleft, original_botright;
    word_res->denorm.DenormTransform(nullptr, topleft, &original_topleft);
    word_res->denorm.DenormTransform(nullptr, botright, &original_botright);
 
    TBOX original_box =
        TBOX(original_topleft.x, original_botright.y, original_botright.x, original_topleft.y);
 
    bool almost_equal_box = false;
    int num_overlap = 0;
    for (auto &&boxe : boxes) {
      if (original_box.overlap_fraction(boxe) > 0.125) {
        num_overlap++;
      }
      if (original_box.almost_equal(boxe, 3)) {
        almost_equal_box = true;
      }
    }
 
    TPOINT location;
    if (divisible_blob(blob, italic_blob, &location) || (!almost_equal_box && num_overlap > 1)) {
      SEAM *seam = attempt_blob_chop(word, blob, *blob_number, italic_blob, word_res->seam_array);
      if (seam != nullptr) {
        return seam;
      }
    }
  }
 
  *blob_number = UINT_MAX;
  return nullptr;
}

chop_word_main()

void tesseract::Wordrec::chop_word_main

(

WERD_RES *

word

)

Definition at line 385 of file chopper.cpp.

                                           {
  int num_blobs = word->chopped_word->NumBlobs();
  if (word->ratings == nullptr) {
    word->ratings = new MATRIX(num_blobs, wordrec_max_join_chunks);
  }
  if (word->ratings->get(0, 0) == nullptr) {
    // Run initial classification.
    for (int b = 0; b < num_blobs; ++b) {
      BLOB_CHOICE_LIST *choices = classify_piece(
          word->seam_array, b, b, "Initial:", word->chopped_word, word->blamer_bundle);
      word->ratings->put(b, b, choices);
    }
  } else {
    // Blobs have been pre-classified. Set matrix cell for all blob choices
    for (int col = 0; col < word->ratings->dimension(); ++col) {
      for (int row = col;
           row < word->ratings->dimension() && row < col + word->ratings->bandwidth(); ++row) {
        BLOB_CHOICE_LIST *choices = word->ratings->get(col, row);
        if (choices != nullptr) {
          BLOB_CHOICE_IT bc_it(choices);
          for (bc_it.mark_cycle_pt(); !bc_it.cycled_list(); bc_it.forward()) {
            bc_it.data()->set_matrix_cell(col, row);
          }
        }
      }
    }
  }
 
  // Run Segmentation Search.
  BestChoiceBundle best_choice_bundle(word->ratings->dimension());
  SegSearch(word, &best_choice_bundle, word->blamer_bundle);
 
  if (word->best_choice == nullptr) {
    // SegSearch found no valid paths, so just use the leading diagonal.
    word->FakeWordFromRatings(TOP_CHOICE_PERM);
  }
  word->RebuildBestState();
  // If we finished without a hyphen at the end of the word, let the next word
  // be found in the dictionary.
  if (word->word->flag(W_EOL) && !getDict().has_hyphen_end(*word->best_choice)) {
    getDict().reset_hyphen_vars(true);
  }
 
  if (word->blamer_bundle != nullptr && this->fill_lattice_ != nullptr) {
    CallFillLattice(*word->ratings, word->best_choices, *word->uch_set, word->blamer_bundle);
  }
  if (wordrec_debug_level > 0) {
    tprintf("Final Ratings Matrix:\n");
    word->ratings->print(getDict().getUnicharset());
  }
  word->FilterWordChoices(getDict().stopper_debug_level);
}

classify_blob()

BLOB_CHOICE_LIST * tesseract::Wordrec::classify_blob	(	TBLOB *	blob,
		const char *	string,
		ScrollView::Color	color,
		BlamerBundle *	blamer_bundle
	)

Definition at line 50 of file wordclass.cpp.

                                                                      {
#ifndef GRAPHICS_DISABLED
  if (wordrec_display_all_blobs) {
    display_blob(blob, color);
  }
#endif
  // TODO(rays) collapse with call_matcher and move all to wordrec.cpp.
  BLOB_CHOICE_LIST *choices = call_matcher(blob);
  // If a blob with the same bounding box as one of the truth character
  // bounding boxes is not classified as the corresponding truth character
  // blame character classifier for incorrect answer.
  if (blamer_bundle != nullptr) {
    blamer_bundle->BlameClassifier(getDict().getUnicharset(), blob->bounding_box(), *choices,
                                   wordrec_debug_blamer);
  }
#ifndef GRAPHICS_DISABLED
  if (classify_debug_level && string) {
    print_ratings_list(string, choices, getDict().getUnicharset());
  }
 
  if (wordrec_blob_pause) {
    blob_window->Wait();
  }
#endif
 
  return choices;
}

classify_piece()

BLOB_CHOICE_LIST * tesseract::Wordrec::classify_piece ( const std::vector< SEAM * > &  seams, int16_t  start, int16_t  end, const char *  description, TWERD *  word, BlamerBundle *  blamer_bundle  )

virtual

Definition at line 49 of file pieces.cpp.

                                                                       {
  if (end > start) {
    SEAM::JoinPieces(seams, word->blobs, start, end);
  }
  BLOB_CHOICE_LIST *choices =
      classify_blob(word->blobs[start], description, ScrollView::WHITE, blamer_bundle);
  // Set the matrix_cell_ entries in all the BLOB_CHOICES.
  BLOB_CHOICE_IT bc_it(choices);
  for (bc_it.mark_cycle_pt(); !bc_it.cycled_list(); bc_it.forward()) {
    bc_it.data()->set_matrix_cell(start, end);
  }
 
  if (end > start) {
    SEAM::BreakPieces(seams, word->blobs, start, end);
  }
 
  return (choices);
}

combine_seam()

void tesseract::Wordrec::combine_seam	(	const SeamPile &	seam_pile,
		const SEAM *	seam,
		SeamQueue *	seam_queue
	)

Definition at line 194 of file findseam.cpp.

                                                                                             {
  for (int x = 0; x < seam_pile.size(); ++x) {
    const SEAM *this_one = seam_pile.get(x).data();
    if (seam->CombineableWith(*this_one, SPLIT_CLOSENESS, chop_ok_split)) {
      SEAM *new_one = new SEAM(*seam);
      new_one->CombineWith(*this_one);
      if (chop_debug > 1) {
        new_one->Print("Combo priority       ");
      }
      add_seam_to_queue(new_one->priority(), new_one, seam_queue);
    }
  }
}

dict_word()

int tesseract::Wordrec::dict_word

(

const WERD_CHOICE &

word

)

Definition at line 86 of file tface.cpp.

                                              {
  return getDict().valid_word(word);
}

double_VAR_H() [1/9]

tesseract::Wordrec::double_VAR_H

(

chop_center_knob

)

double_VAR_H() [2/9]

tesseract::Wordrec::double_VAR_H

(

chop_good_split

)

double_VAR_H() [3/9]

tesseract::Wordrec::double_VAR_H

(

chop_ok_split

)

double_VAR_H() [4/9]

tesseract::Wordrec::double_VAR_H

(

chop_overlap_knob

)

double_VAR_H() [5/9]

tesseract::Wordrec::double_VAR_H

(

chop_sharpness_knob

)

double_VAR_H() [6/9]

tesseract::Wordrec::double_VAR_H

(

chop_split_dist_knob

)

double_VAR_H() [7/9]

tesseract::Wordrec::double_VAR_H

(

chop_width_change_knob

)

double_VAR_H() [8/9]

tesseract::Wordrec::double_VAR_H

(

segsearch_max_char_wh_ratio

)

double_VAR_H() [9/9]

tesseract::Wordrec::double_VAR_H

(

tessedit_certainty_threshold

)

end_recog()

int tesseract::Wordrec::end_recog

(

)

Definition at line 61 of file tface.cpp.

                       {
  program_editdown(0);
 
  return (0);
}

FillLattice()

void tesseract::Wordrec::FillLattice	(	const MATRIX &	ratings,
		const WERD_CHOICE_LIST &	best_choices,
		const UNICHARSET &	unicharset,
		BlamerBundle *	blamer_bundle
	)

grade_sharpness()

PRIORITY tesseract::Wordrec::grade_sharpness

(

SPLIT *

split

)

Definition at line 67 of file gradechop.cpp.

                                              {
  PRIORITY grade;
 
  grade = point_priority(split->point1) + point_priority(split->point2);
 
  if (grade < -360.0) {
    grade = 0;
  } else {
    grade += 360.0;
  }
 
  grade *= chop_sharpness_knob; /* Values 0 to -360 */
 
  return (grade);
}

grade_split_length()

PRIORITY tesseract::Wordrec::grade_split_length

(

SPLIT *

split

)

Definition at line 45 of file gradechop.cpp.

                                                 {
  PRIORITY grade;
  float split_length;
 
  split_length = split->point1->WeightedDistance(*split->point2, chop_x_y_weight);
 
  if (split_length <= 0) {
    grade = 0;
  } else {
    grade = std::sqrt(split_length) * chop_split_dist_knob;
  }
 
  return (std::max(0.0f, grade));
}

improve_by_chopping()

void tesseract::Wordrec::improve_by_chopping	(	float	rating_cert_scale,
		WERD_RES *	word,
		BestChoiceBundle *	best_choice_bundle,
		BlamerBundle *	blamer_bundle,
		LMPainPoints *	pain_points,
		std::vector< SegSearchPending > *	pending
	)

Definition at line 445 of file chopper.cpp.

                                                                        {
  unsigned blob_number;
  do { // improvement loop.
    // Make a simple vector of BLOB_CHOICEs to make it easy to pick which
    // one to chop.
    std::vector<BLOB_CHOICE *> blob_choices;
    int num_blobs = word->ratings->dimension();
    for (int i = 0; i < num_blobs; ++i) {
      BLOB_CHOICE_LIST *choices = word->ratings->get(i, i);
      if (choices == nullptr || choices->empty()) {
        blob_choices.push_back(nullptr);
      } else {
        BLOB_CHOICE_IT bc_it(choices);
        blob_choices.push_back(bc_it.data());
      }
    }
    SEAM *seam = improve_one_blob(blob_choices, &best_choice_bundle->fixpt, false, false, word,
                                  &blob_number);
    if (seam == nullptr) {
      break;
    }
    // A chop has been made. We have to correct all the data structures to
    // take into account the extra bottom-level blob.
    // Put the seam into the seam_array and correct everything else on the
    // word: ratings matrix (including matrix location in the BLOB_CHOICES),
    // states in WERD_CHOICEs, and blob widths.
    word->InsertSeam(blob_number, seam);
    // Insert a new entry in the beam array.
    best_choice_bundle->beam.insert(best_choice_bundle->beam.begin() + blob_number, new LanguageModelState);
    // Fixpts are outdated, but will get recalculated.
    best_choice_bundle->fixpt.clear();
    // Remap existing pain points.
    pain_points->RemapForSplit(blob_number);
    // Insert a new pending at the chop point.
    pending->insert(pending->begin() + blob_number, SegSearchPending());
 
    // Classify the two newly created blobs using ProcessSegSearchPainPoint,
    // as that updates the pending correctly and adds new pain points.
    MATRIX_COORD pain_point(blob_number, blob_number);
    ProcessSegSearchPainPoint(0.0f, pain_point, "Chop1", pending, word, pain_points, blamer_bundle);
    pain_point.col = blob_number + 1;
    pain_point.row = blob_number + 1;
    ProcessSegSearchPainPoint(0.0f, pain_point, "Chop2", pending, word, pain_points, blamer_bundle);
    if (language_model_->language_model_ngram_on) {
      // N-gram evaluation depends on the number of blobs in a chunk, so we
      // have to re-evaluate everything in the word.
      ResetNGramSearch(word, best_choice_bundle, *pending);
      blob_number = 0;
    }
    // Run language model incrementally. (Except with the n-gram model on.)
    UpdateSegSearchNodes(rating_cert_scale, blob_number, pending, word, pain_points,
                         best_choice_bundle, blamer_bundle);
  } while (!language_model_->AcceptableChoiceFound() && word->ratings->dimension() < kMaxNumChunks);
 
  // If after running only the chopper best_choice is incorrect and no blame
  // has been yet set, blame the classifier if best_choice is classifier's
  // top choice and is a dictionary word (i.e. language model could not have
  // helped). Otherwise blame the tradeoff between the classifier and
  // the old language model (permuters).
  if (word->blamer_bundle != nullptr &&
      word->blamer_bundle->incorrect_result_reason() == IRR_CORRECT &&
      !word->blamer_bundle->ChoiceIsCorrect(word->best_choice)) {
    bool valid_permuter = word->best_choice != nullptr &&
                          Dict::valid_word_permuter(word->best_choice->permuter(), false);
    word->blamer_bundle->BlameClassifierOrLangModel(word, getDict().getUnicharset(), valid_permuter,
                                                    wordrec_debug_blamer);
  }
}

improve_one_blob()

SEAM * tesseract::Wordrec::improve_one_blob	(	const std::vector< BLOB_CHOICE * > &	blob_choices,
		DANGERR *	fixpt,
		bool	split_next_to_fragment,
		bool	italic_blob,
		WERD_RES *	word,
		unsigned *	blob_number
	)

Definition at line 320 of file chopper.cpp.

                                                       {
  float rating_ceiling = FLT_MAX;
  SEAM *seam = nullptr;
  do {
    auto blob = select_blob_to_split_from_fixpt(fixpt);
    if (chop_debug) {
      tprintf("blob_number from fixpt = %d\n", blob);
    }
    bool split_point_from_dict = (blob != -1);
    if (split_point_from_dict) {
      fixpt->clear();
    } else {
      blob = select_blob_to_split(blob_choices, rating_ceiling, split_next_to_fragment);
    }
    if (chop_debug) {
      tprintf("blob_number = %d\n", blob);
    }
    *blob_number = blob;
    if (blob == -1) {
      return nullptr;
    }
 
    // TODO(rays) it may eventually help to allow italic_blob to be true,
    seam = chop_numbered_blob(word->chopped_word, *blob_number, italic_blob, word->seam_array);
    if (seam != nullptr) {
      return seam; // Success!
    }
    if (blob_choices[*blob_number] == nullptr) {
      return nullptr;
    }
    if (!split_point_from_dict) {
      // We chopped the worst rated blob, try something else next time.
      rating_ceiling = blob_choices[*blob_number]->rating();
    }
  } while (true);
  return seam;
}

InitBlamerForSegSearch()

void tesseract::Wordrec::InitBlamerForSegSearch ( WERD_RES *  word_res, LMPainPoints *  pain_points, BlamerBundle *  blamer_bundle, std::string &  blamer_debug  )

protected

Definition at line 296 of file segsearch.cpp.

                                                                                           {
  pain_points->Clear(); // Clear pain points heap.
  blamer_bundle->InitForSegSearch(word_res->best_choice, word_res->ratings, getDict().WildcardID(),
                                  wordrec_debug_blamer, blamer_debug, pain_points,
                                  segsearch_max_char_wh_ratio, word_res);
}

InitialSegSearch()

void tesseract::Wordrec::InitialSegSearch	(	WERD_RES *	word_res,
		LMPainPoints *	pain_points,
		std::vector< SegSearchPending > *	pending,
		BestChoiceBundle *	best_choice_bundle,
		BlamerBundle *	blamer_bundle
	)

Definition at line 120 of file segsearch.cpp.

                                                                                                  {
  if (segsearch_debug_level > 0) {
    tprintf("Starting SegSearch on ratings matrix%s:\n",
            wordrec_enable_assoc ? " (with assoc)" : "");
    word_res->ratings->print(getDict().getUnicharset());
  }
 
  pain_points->GenerateInitial(word_res);
 
  // Compute scaling factor that will help us recover blob outline length
  // from classifier rating and certainty for the blob.
  float rating_cert_scale = -1.0 * getDict().certainty_scale / rating_scale;
 
  language_model_->InitForWord(prev_word_best_choice_, assume_fixed_pitch_char_segment,
                               segsearch_max_char_wh_ratio, rating_cert_scale);
 
  // Initialize blamer-related information: map character boxes recorded in
  // blamer_bundle->norm_truth_word to the corresponding i,j indices in the
  // ratings matrix. We expect this step to succeed, since when running the
  // chopper we checked that the correct chops are present.
  if (blamer_bundle != nullptr) {
    blamer_bundle->SetupCorrectSegmentation(word_res->chopped_word, wordrec_debug_blamer);
  }
 
  // pending[col] tells whether there is update work to do to combine
  // best_choice_bundle->beam[col - 1] with some BLOB_CHOICEs in matrix[col, *].
  // As the language model state is updated, pending entries are modified to
  // minimize duplication of work. It is important that during the update the
  // children are considered in the non-decreasing order of their column, since
  // this guarantees that all the parents would be up to date before an update
  // of a child is done.
  pending->clear();
  pending->resize(word_res->ratings->dimension(), SegSearchPending());
 
  // Search the ratings matrix for the initial best path.
  (*pending)[0].SetColumnClassified();
  UpdateSegSearchNodes(rating_cert_scale, 0, pending, word_res, pain_points, best_choice_bundle,
                       blamer_bundle);
}

INT_VAR_H() [1/15]

tesseract::Wordrec::INT_VAR_H

(

chop_centered_maxwidth

)

INT_VAR_H() [2/15]

tesseract::Wordrec::INT_VAR_H

(

chop_debug

)

INT_VAR_H() [3/15]

tesseract::Wordrec::INT_VAR_H

(

chop_inside_angle

)

INT_VAR_H() [4/15]

tesseract::Wordrec::INT_VAR_H

(

chop_min_outline_area

)

INT_VAR_H() [5/15]

tesseract::Wordrec::INT_VAR_H

(

chop_min_outline_points

)

INT_VAR_H() [6/15]

tesseract::Wordrec::INT_VAR_H

(

chop_same_distance

)

INT_VAR_H() [7/15]

tesseract::Wordrec::INT_VAR_H

(

chop_seam_pile_size

)

INT_VAR_H() [8/15]

tesseract::Wordrec::INT_VAR_H

(

chop_split_length

)

INT_VAR_H() [9/15]

tesseract::Wordrec::INT_VAR_H

(

chop_x_y_weight

)

INT_VAR_H() [10/15]

tesseract::Wordrec::INT_VAR_H

(

repair_unchopped_blobs

)

INT_VAR_H() [11/15]

tesseract::Wordrec::INT_VAR_H

(

segsearch_debug_level

)

INT_VAR_H() [12/15]

tesseract::Wordrec::INT_VAR_H

(

segsearch_max_futile_classifications

)

INT_VAR_H() [13/15]

tesseract::Wordrec::INT_VAR_H

(

segsearch_max_pain_points

)

INT_VAR_H() [14/15]

tesseract::Wordrec::INT_VAR_H

(

wordrec_debug_level

)

INT_VAR_H() [15/15]

tesseract::Wordrec::INT_VAR_H

(

wordrec_max_join_chunks

)

is_inside_angle()

bool tesseract::Wordrec::is_inside_angle

(

EDGEPT *

pt

)

Definition at line 88 of file chop.cpp.

                                        {
  return angle_change(pt->prev, pt, pt->next) < chop_inside_angle;
}

near_point()

bool tesseract::Wordrec::near_point	(	EDGEPT *	point,
		EDGEPT *	line_pt_0,
		EDGEPT *	line_pt_1,
		EDGEPT **	near_pt
	)

Definition at line 36 of file outlines.cpp.

                                                                                              {
  TPOINT p;
 
  float slope;
  float intercept;
 
  float x0 = line_pt_0->pos.x;
  float x1 = line_pt_1->pos.x;
  float y0 = line_pt_0->pos.y;
  float y1 = line_pt_1->pos.y;
 
  if (x0 == x1) {
    /* Handle vertical line */
    p.x = static_cast<int16_t>(x0);
    p.y = point->pos.y;
  } else {
    /* Slope and intercept */
    slope = (y0 - y1) / (x0 - x1);
    intercept = y1 - x1 * slope;
 
    /* Find perpendicular */
    p.x = static_cast<int16_t>((point->pos.x + (point->pos.y - intercept) * slope) /
                               (slope * slope + 1));
    p.y = static_cast<int16_t>(slope * p.x + intercept);
  }
 
  if (is_on_line(p, line_pt_0->pos, line_pt_1->pos) && (!same_point(p, line_pt_0->pos)) &&
      (!same_point(p, line_pt_1->pos))) {
    /* Intersection on line */
    *near_pt = make_edgept(p.x, p.y, line_pt_1, line_pt_0);
    return true;
  } else { /* Intersection not on line */
    *near_pt = closest(point, line_pt_0, line_pt_1);
    return false;
  }
}

new_max_point()

void tesseract::Wordrec::new_max_point	(	EDGEPT *	local_max,
		PointHeap *	points
	)

Definition at line 249 of file chop.cpp.

                                                                {
  int16_t dir;
 
  dir = direction(local_max);
 
  if (dir > 0) {
    add_point_to_list(points, local_max);
    return;
  }
 
  if (dir == 0 && point_priority(local_max) < 0) {
    add_point_to_list(points, local_max);
    return;
  }
}

new_min_point()

void tesseract::Wordrec::new_min_point	(	EDGEPT *	local_min,
		PointHeap *	points
	)

Definition at line 226 of file chop.cpp.

                                                                {
  int16_t dir;
 
  dir = direction(local_min);
 
  if (dir < 0) {
    add_point_to_list(points, local_min);
    return;
  }
 
  if (dir == 0 && point_priority(local_min) < 0) {
    add_point_to_list(points, local_min);
    return;
  }
}

pick_close_point()

EDGEPT * tesseract::Wordrec::pick_close_point	(	EDGEPT *	critical_point,
		EDGEPT *	vertical_point,
		int *	best_dist
	)

Definition at line 136 of file chop.cpp.

                                                                                                {
  EDGEPT *best_point = nullptr;
  int this_distance;
  bool found_better;
 
  do {
    found_better = false;
 
    this_distance = edgept_dist(critical_point, vertical_point);
    if (this_distance <= *best_dist) {
      if (!(same_point(critical_point->pos, vertical_point->pos) ||
            same_point(critical_point->pos, vertical_point->next->pos) ||
            (best_point && same_point(best_point->pos, vertical_point->pos)) ||
            is_exterior_point(critical_point, vertical_point))) {
        *best_dist = this_distance;
        best_point = vertical_point;
        if (chop_vertical_creep) {
          found_better = true;
        }
      }
    }
    vertical_point = vertical_point->next;
  } while (found_better == true);
 
  return (best_point);
}

pick_good_seam()

SEAM * tesseract::Wordrec::pick_good_seam

(

TBLOB *

blob

)

Definition at line 214 of file findseam.cpp.

                                         {
  SeamPile seam_pile(chop_seam_pile_size);
  EDGEPT *points[MAX_NUM_POINTS];
  EDGEPT_CLIST new_points;
  SEAM *seam = nullptr;
  TESSLINE *outline;
  int16_t num_points = 0;
 
#ifndef GRAPHICS_DISABLED
  if (chop_debug > 2) {
    wordrec_display_splits.set_value(true);
  }
 
  draw_blob_edges(blob);
#endif
 
  PointHeap point_heap(MAX_NUM_POINTS);
  for (outline = blob->outlines; outline; outline = outline->next) {
    prioritize_points(outline, &point_heap);
  }
 
  while (!point_heap.empty() && num_points < MAX_NUM_POINTS) {
    points[num_points++] = point_heap.PeekTop().data();
    point_heap.Pop(nullptr);
  }
 
  /* Initialize queue */
  SeamQueue seam_queue(MAX_NUM_SEAMS);
 
  try_point_pairs(points, num_points, &seam_queue, &seam_pile, &seam, blob);
  try_vertical_splits(points, num_points, &new_points, &seam_queue, &seam_pile, &seam, blob);
 
  if (seam == nullptr) {
    choose_best_seam(&seam_queue, nullptr, BAD_PRIORITY, &seam, blob, &seam_pile);
  } else if (seam->priority() > chop_good_split) {
    choose_best_seam(&seam_queue, nullptr, seam->priority(), &seam, blob, &seam_pile);
  }
 
  EDGEPT_C_IT it(&new_points);
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    EDGEPT *inserted_point = it.data();
    if (seam == nullptr || !seam->UsesPoint(inserted_point)) {
      for (outline = blob->outlines; outline; outline = outline->next) {
        if (outline->loop == inserted_point) {
          outline->loop = outline->loop->next;
        }
      }
      remove_edgept(inserted_point);
    }
  }
 
  if (seam) {
    if (seam->priority() > chop_ok_split) {
      delete seam;
      seam = nullptr;
    }
#ifndef GRAPHICS_DISABLED
    else if (wordrec_display_splits) {
      seam->Mark(edge_window);
      if (chop_debug > 2) {
        edge_window->Update();
        edge_window->Wait();
      }
    }
#endif
  }
 
  if (chop_debug) {
    wordrec_display_splits.set_value(false);
  }
 
  return (seam);
}

point_priority()

PRIORITY tesseract::Wordrec::point_priority

(

EDGEPT *

point

)

Definition at line 64 of file chop.cpp.

                                              {
  return static_cast<PRIORITY>(angle_change(point->prev, point, point->next));
}

prioritize_points()

void tesseract::Wordrec::prioritize_points	(	TESSLINE *	outline,
		PointHeap *	points
	)

Definition at line 170 of file chop.cpp.

                                                                    {
  EDGEPT *this_point;
  EDGEPT *local_min = nullptr;
  EDGEPT *local_max = nullptr;
 
  this_point = outline->loop;
  local_min = this_point;
  local_max = this_point;
  do {
    if (this_point->vec.y < 0) {
      /* Look for minima */
      if (local_max != nullptr) {
        new_max_point(local_max, points);
      } else if (is_inside_angle(this_point)) {
        add_point_to_list(points, this_point);
      }
      local_max = nullptr;
      local_min = this_point->next;
    } else if (this_point->vec.y > 0) {
      /* Look for maxima */
      if (local_min != nullptr) {
        new_min_point(local_min, points);
      } else if (is_inside_angle(this_point)) {
        add_point_to_list(points, this_point);
      }
      local_min = nullptr;
      local_max = this_point->next;
    } else {
      /* Flat area */
      if (local_max != nullptr) {
        if (local_max->prev->vec.y != 0) {
          new_max_point(local_max, points);
        }
        local_max = this_point->next;
        local_min = nullptr;
      } else {
        if (local_min->prev->vec.y != 0) {
          new_min_point(local_min, points);
        }
        local_min = this_point->next;
        local_max = nullptr;
      }
    }
 
    /* Next point */
    this_point = this_point->next;
  } while (this_point != outline->loop);
}

ProcessSegSearchPainPoint()

void tesseract::Wordrec::ProcessSegSearchPainPoint ( float  pain_point_priority, const MATRIX_COORD &  pain_point, const char *  pain_point_type, std::vector< SegSearchPending > *  pending, WERD_RES *  word_res, LMPainPoints *  pain_points, BlamerBundle *  blamer_bundle  )

protected

Definition at line 222 of file segsearch.cpp.

                                                                     {
  if (segsearch_debug_level > 0) {
    tprintf("Classifying pain point %s priority=%.4f, col=%d, row=%d\n", pain_point_type,
            pain_point_priority, pain_point.col, pain_point.row);
  }
  ASSERT_HOST(pain_points != nullptr);
  MATRIX *ratings = word_res->ratings;
  // Classify blob [pain_point.col pain_point.row]
  if (!pain_point.Valid(*ratings)) {
    ratings->IncreaseBandSize(pain_point.row + 1 - pain_point.col);
  }
  ASSERT_HOST(pain_point.Valid(*ratings));
  BLOB_CHOICE_LIST *classified =
      classify_piece(word_res->seam_array, pain_point.col, pain_point.row, pain_point_type,
                     word_res->chopped_word, blamer_bundle);
  BLOB_CHOICE_LIST *lst = ratings->get(pain_point.col, pain_point.row);
  if (lst == nullptr) {
    ratings->put(pain_point.col, pain_point.row, classified);
  } else {
    // We cannot delete old BLOB_CHOICEs, since they might contain
    // ViterbiStateEntries that are parents of other "active" entries.
    // Thus if the matrix cell already contains classifications we add
    // the new ones to the beginning of the list.
    BLOB_CHOICE_IT it(lst);
    it.add_list_before(classified);
    delete classified; // safe to delete, since empty after add_list_before()
    classified = nullptr;
  }
 
  if (segsearch_debug_level > 0) {
    print_ratings_list("Updated ratings matrix with a new entry:",
                       ratings->get(pain_point.col, pain_point.row), getDict().getUnicharset());
    ratings->print(getDict().getUnicharset());
  }
 
  // Insert initial "pain points" to join the newly classified blob
  // with its left and right neighbors.
  if (classified != nullptr && !classified->empty()) {
    if (pain_point.col > 0) {
      pain_points->GeneratePainPoint(pain_point.col - 1, pain_point.row, LM_PPTYPE_SHAPE, 0.0, true,
                                     segsearch_max_char_wh_ratio, word_res);
    }
    if (pain_point.row + 1 < ratings->dimension()) {
      pain_points->GeneratePainPoint(pain_point.col, pain_point.row + 1, LM_PPTYPE_SHAPE, 0.0, true,
                                     segsearch_max_char_wh_ratio, word_res);
    }
  }
  (*pending)[pain_point.col].SetBlobClassified(pain_point.row);
}

program_editdown()

void tesseract::Wordrec::program_editdown

(

int32_t

elasped_time

)

Definition at line 73 of file tface.cpp.

                                                   {
#ifndef DISABLED_LEGACY_ENGINE
  EndAdaptiveClassifier();
#endif // ndef DISABLED_LEGACY_ENGINE
  getDict().End();
}

program_editup()

void tesseract::Wordrec::program_editup	(	const std::string &	textbase,
		TessdataManager *	init_classifier,
		TessdataManager *	init_dict
	)

Definition at line 39 of file tface.cpp.

                                                         {
  if (!textbase.empty()) {
    imagefile = textbase;
  }
#ifndef DISABLED_LEGACY_ENGINE
  InitFeatureDefs(&feature_defs_);
  InitAdaptiveClassifier(init_classifier);
  if (init_dict) {
    getDict().SetupForLoad(Dict::GlobalDawgCache());
    getDict().Load(lang, init_dict);
    getDict().FinishLoad();
  }
  pass2_ok_split = chop_ok_split;
#endif // ndef DISABLED_LEGACY_ENGINE
}

ResetNGramSearch()

void tesseract::Wordrec::ResetNGramSearch ( WERD_RES *  word_res, BestChoiceBundle *  best_choice_bundle, std::vector< SegSearchPending > &  pending  )

protected

Definition at line 279 of file segsearch.cpp.

                                                                     {
  // TODO(rays) More refactoring required here.
  // Delete existing viterbi states.
  for (auto &col : best_choice_bundle->beam) {
    col->Clear();
  }
  // Reset best_choice_bundle.
  word_res->ClearWordChoices();
  best_choice_bundle->best_vse = nullptr;
  // Clear out all existing pendings and add a new one for the first column.
  pending[0].SetColumnClassified();
  for (auto &data : pending) {
    data.Clear();
  }
}

SaveAltChoices()

void tesseract::Wordrec::SaveAltChoices	(	const LIST &	best_choices,
		WERD_RES *	word
	)

SegSearch()

void tesseract::Wordrec::SegSearch	(	WERD_RES *	word_res,
		BestChoiceBundle *	best_choice_bundle,
		BlamerBundle *	blamer_bundle
	)

Definition at line 33 of file segsearch.cpp.

                                                     {
  LMPainPoints pain_points(segsearch_max_pain_points, segsearch_max_char_wh_ratio,
                           assume_fixed_pitch_char_segment, &getDict(), segsearch_debug_level);
  // Compute scaling factor that will help us recover blob outline length
  // from classifier rating and certainty for the blob.
  float rating_cert_scale = -1.0 * getDict().certainty_scale / rating_scale;
  std::vector<SegSearchPending> pending;
  InitialSegSearch(word_res, &pain_points, &pending, best_choice_bundle, blamer_bundle);
 
  if (!SegSearchDone(0)) { // find a better choice
    if (chop_enable && word_res->chopped_word != nullptr) {
      improve_by_chopping(rating_cert_scale, word_res, best_choice_bundle, blamer_bundle,
                          &pain_points, &pending);
    }
    if (chop_debug) {
      SEAM::PrintSeams("Final seam list:", word_res->seam_array);
    }
 
    if (blamer_bundle != nullptr && !blamer_bundle->ChoiceIsCorrect(word_res->best_choice)) {
      blamer_bundle->SetChopperBlame(word_res, wordrec_debug_blamer);
    }
  }
  // Keep trying to find a better path by fixing the "pain points".
 
  MATRIX_COORD pain_point;
  float pain_point_priority;
  int num_futile_classifications = 0;
  std::string blamer_debug;
  while (wordrec_enable_assoc &&
         (!SegSearchDone(num_futile_classifications) ||
          (blamer_bundle != nullptr && blamer_bundle->GuidedSegsearchStillGoing()))) {
    // Get the next valid "pain point".
    bool found_nothing = true;
    LMPainPointsType pp_type;
    while ((pp_type = pain_points.Deque(&pain_point, &pain_point_priority)) != LM_PPTYPE_NUM) {
      if (!pain_point.Valid(*word_res->ratings)) {
        word_res->ratings->IncreaseBandSize(pain_point.row - pain_point.col + 1);
      }
      if (pain_point.Valid(*word_res->ratings) &&
          !word_res->ratings->Classified(pain_point.col, pain_point.row, getDict().WildcardID())) {
        found_nothing = false;
        break;
      }
    }
    if (found_nothing) {
      if (segsearch_debug_level > 0) {
        tprintf("Pain points queue is empty\n");
      }
      break;
    }
    ProcessSegSearchPainPoint(pain_point_priority, pain_point,
                              LMPainPoints::PainPointDescription(pp_type), &pending, word_res,
                              &pain_points, blamer_bundle);
 
    UpdateSegSearchNodes(rating_cert_scale, pain_point.col, &pending, word_res, &pain_points,
                         best_choice_bundle, blamer_bundle);
    if (!best_choice_bundle->updated) {
      ++num_futile_classifications;
    }
 
    if (segsearch_debug_level > 0) {
      tprintf("num_futile_classifications %d\n", num_futile_classifications);
    }
 
    best_choice_bundle->updated = false; // reset updated
 
    // See if it's time to terminate SegSearch or time for starting a guided
    // search for the true path to find the blame for the incorrect best_choice.
    if (SegSearchDone(num_futile_classifications) && blamer_bundle != nullptr &&
        blamer_bundle->GuidedSegsearchNeeded(word_res->best_choice)) {
      InitBlamerForSegSearch(word_res, &pain_points, blamer_bundle, blamer_debug);
    }
  } // end while loop exploring alternative paths
  if (blamer_bundle != nullptr) {
    blamer_bundle->FinishSegSearch(word_res->best_choice, wordrec_debug_blamer, blamer_debug);
  }
 
  if (segsearch_debug_level > 0) {
    tprintf("Done with SegSearch (AcceptableChoiceFound: %d)\n",
            language_model_->AcceptableChoiceFound());
  }
}

SegSearchDone()

bool tesseract::Wordrec::SegSearchDone ( int  num_futile_classifications )

inlineprotected

Definition at line 394 of file wordrec.h.

                                                            {
    return (language_model_->AcceptableChoiceFound() ||
            num_futile_classifications >= segsearch_max_futile_classifications);
  }

select_blob_to_split()

int tesseract::Wordrec::select_blob_to_split	(	const std::vector< BLOB_CHOICE * > &	blob_choices,
		float	rating_ceiling,
		bool	split_next_to_fragment
	)

Definition at line 523 of file chopper.cpp.

                                                                                     {
  BLOB_CHOICE *blob_choice;
  float worst = -FLT_MAX;
  int worst_index = -1;
  float worst_near_fragment = -FLT_MAX;
  int worst_index_near_fragment = -1;
  std::vector<const CHAR_FRAGMENT *> fragments;
 
  if (chop_debug) {
    if (rating_ceiling < FLT_MAX) {
      tprintf("rating_ceiling = %8.4f\n", rating_ceiling);
    } else {
      tprintf("rating_ceiling = No Limit\n");
    }
  }
 
  if (split_next_to_fragment && blob_choices.size() > 0) {
    fragments.resize(blob_choices.size());
    if (blob_choices[0] != nullptr) {
      fragments[0] = getDict().getUnicharset().get_fragment(blob_choices[0]->unichar_id());
    } else {
      fragments[0] = nullptr;
    }
  }
 
  for (unsigned x = 0; x < blob_choices.size(); ++x) {
    if (blob_choices[x] == nullptr) {
      return x;
    } else {
      blob_choice = blob_choices[x];
      // Populate fragments for the following position.
      if (split_next_to_fragment && x + 1 < blob_choices.size()) {
        if (blob_choices[x + 1] != nullptr) {
          fragments[x + 1] =
              getDict().getUnicharset().get_fragment(blob_choices[x + 1]->unichar_id());
        } else {
          fragments[x + 1] = nullptr;
        }
      }
      if (blob_choice->rating() < rating_ceiling &&
          blob_choice->certainty() < tessedit_certainty_threshold) {
        // Update worst and worst_index.
        if (blob_choice->rating() > worst) {
          worst_index = x;
          worst = blob_choice->rating();
        }
        if (split_next_to_fragment) {
          // Update worst_near_fragment and worst_index_near_fragment.
          bool expand_following_fragment =
              (x + 1 < blob_choices.size() && fragments[x + 1] != nullptr &&
               !fragments[x + 1]->is_beginning());
          bool expand_preceding_fragment =
              (x > 0 && fragments[x - 1] != nullptr && !fragments[x - 1]->is_ending());
          if ((expand_following_fragment || expand_preceding_fragment) &&
              blob_choice->rating() > worst_near_fragment) {
            worst_index_near_fragment = x;
            worst_near_fragment = blob_choice->rating();
            if (chop_debug) {
              tprintf(
                  "worst_index_near_fragment=%d"
                  " expand_following_fragment=%d"
                  " expand_preceding_fragment=%d\n",
                  worst_index_near_fragment, expand_following_fragment, expand_preceding_fragment);
            }
          }
        }
      }
    }
  }
  // TODO(daria): maybe a threshold of badness for
  // worst_near_fragment would be useful.
  return worst_index_near_fragment != -1 ? worst_index_near_fragment : worst_index;
}

select_blob_to_split_from_fixpt()

int tesseract::Wordrec::select_blob_to_split_from_fixpt

(

DANGERR *

fixpt

)

Definition at line 605 of file chopper.cpp.

                                                           {
  if (!fixpt) {
    return -1;
  }
  for (auto &i : *fixpt) {
    if (i.begin + 1 == i.end && i.dangerous && i.correct_is_ngram) {
      return i.begin;
    }
  }
  return -1;
}

set_pass1()

void tesseract::Wordrec::set_pass1

(

)

Definition at line 97 of file tface.cpp.

                        {
  chop_ok_split.set_value(70.0);
  language_model_->getParamsModel().SetPass(ParamsModel::PTRAIN_PASS1);
  SettupPass1();
}

set_pass2()

void tesseract::Wordrec::set_pass2

(

)

Definition at line 108 of file tface.cpp.

                        {
  chop_ok_split.set_value(pass2_ok_split);
  language_model_->getParamsModel().SetPass(ParamsModel::PTRAIN_PASS2);
  SettupPass2();
}

try_point_pairs()

void tesseract::Wordrec::try_point_pairs	(	EDGEPT *	points[MAX_NUM_POINTS],
		int16_t	num_points,
		SeamQueue *	seam_queue,
		SeamPile *	seam_pile,
		SEAM **	seam,
		TBLOB *	blob
	)

Definition at line 295 of file findseam.cpp.

                                           {
  int16_t x;
  int16_t y;
  PRIORITY priority;
 
  for (x = 0; x < num_points; x++) {
    for (y = x + 1; y < num_points; y++) {
      if (points[y] &&
          points[x]->WeightedDistance(*points[y], chop_x_y_weight) < chop_split_length &&
          points[x] != points[y]->next && points[y] != points[x]->next &&
          !is_exterior_point(points[x], points[y]) && !is_exterior_point(points[y], points[x])) {
        SPLIT split(points[x], points[y]);
        priority = partial_split_priority(&split);
 
        choose_best_seam(seam_queue, &split, priority, seam, blob, seam_pile);
      }
    }
  }
}

try_vertical_splits()

void tesseract::Wordrec::try_vertical_splits	(	EDGEPT *	points[MAX_NUM_POINTS],
		int16_t	num_points,
		EDGEPT_CLIST *	new_points,
		SeamQueue *	seam_queue,
		SeamPile *	seam_pile,
		SEAM **	seam,
		TBLOB *	blob
	)

Definition at line 327 of file findseam.cpp.

                                                                                 {
  EDGEPT *vertical_point = nullptr;
  int16_t x;
  PRIORITY priority;
  TESSLINE *outline;
 
  for (x = 0; x < num_points; x++) {
    vertical_point = nullptr;
    for (outline = blob->outlines; outline; outline = outline->next) {
      vertical_projection_point(points[x], outline->loop, &vertical_point, new_points);
    }
 
    if (vertical_point && points[x] != vertical_point->next && vertical_point != points[x]->next &&
        points[x]->WeightedDistance(*vertical_point, chop_x_y_weight) < chop_split_length) {
      SPLIT split(points[x], vertical_point);
      priority = partial_split_priority(&split);
      choose_best_seam(seam_queue, &split, priority, seam, blob, seam_pile);
    }
  }
}

UpdateSegSearchNodes()

void tesseract::Wordrec::UpdateSegSearchNodes ( float  rating_cert_scale, int  starting_col, std::vector< SegSearchPending > *  pending, WERD_RES *  word_res, LMPainPoints *  pain_points, BestChoiceBundle *  best_choice_bundle, BlamerBundle *  blamer_bundle  )

protected

Definition at line 162 of file segsearch.cpp.

                                                                {
  MATRIX *ratings = word_res->ratings;
  ASSERT_HOST(static_cast<unsigned>(ratings->dimension()) == pending->size());
  ASSERT_HOST(static_cast<unsigned>(ratings->dimension()) == best_choice_bundle->beam.size());
  for (int col = starting_col; col < ratings->dimension(); ++col) {
    if (!(*pending)[col].WorkToDo()) {
      continue;
    }
    int first_row = col;
    int last_row = std::min(ratings->dimension() - 1, col + ratings->bandwidth() - 1);
    if ((*pending)[col].SingleRow() >= 0) {
      first_row = last_row = (*pending)[col].SingleRow();
    }
    if (segsearch_debug_level > 0) {
      tprintf("\n\nUpdateSegSearchNodes: col=%d, rows=[%d,%d], alljust=%d\n", col, first_row,
              last_row, (*pending)[col].IsRowJustClassified(INT32_MAX));
    }
    // Iterate over the pending list for this column.
    for (int row = first_row; row <= last_row; ++row) {
      // Update language model state of this child+parent pair.
      BLOB_CHOICE_LIST *current_node = ratings->get(col, row);
      LanguageModelState *parent_node = col == 0 ? nullptr : best_choice_bundle->beam[col - 1];
      if (current_node != nullptr &&
          language_model_->UpdateState((*pending)[col].IsRowJustClassified(row), col, row,
                                       current_node, parent_node, pain_points, word_res,
                                       best_choice_bundle, blamer_bundle) &&
          row + 1 < ratings->dimension()) {
        // Since the language model state of this entry changed, process all
        // the child column.
        (*pending)[row + 1].RevisitWholeColumn();
        if (segsearch_debug_level > 0) {
          tprintf("Added child col=%d to pending\n", row + 1);
        }
      } // end if UpdateState.
    }   // end for row.
  }     // end for col.
  if (best_choice_bundle->best_vse != nullptr) {
    ASSERT_HOST(word_res->StatesAllValid());
    if (best_choice_bundle->best_vse->updated) {
      pain_points->GenerateFromPath(rating_cert_scale, best_choice_bundle->best_vse, word_res);
      if (!best_choice_bundle->fixpt.empty()) {
        pain_points->GenerateFromAmbigs(best_choice_bundle->fixpt, best_choice_bundle->best_vse,
                                        word_res);
      }
    }
  }
  // The segsearch is completed. Reset all updated flags on all VSEs and reset
  // all pendings.
  for (unsigned col = 0; col < pending->size(); ++col) {
    (*pending)[col].Clear();
    ViterbiStateEntry_IT vse_it(&best_choice_bundle->beam[col]->viterbi_state_entries);
    for (vse_it.mark_cycle_pt(); !vse_it.cycled_list(); vse_it.forward()) {
      vse_it.data()->updated = false;
    }
  }
}

vertical_projection_point()

void tesseract::Wordrec::vertical_projection_point	(	EDGEPT *	split_point,
		EDGEPT *	target_point,
		EDGEPT **	best_point,
		EDGEPT_CLIST *	new_points
	)

Definition at line 277 of file chop.cpp.

                                                                                       {
  EDGEPT *p;           /* Iterator */
  EDGEPT *this_edgept; /* Iterator */
  EDGEPT_C_IT new_point_it(new_points);
  int x = split_point->pos.x;     /* X value of vertical */
  int best_dist = LARGE_DISTANCE; /* Best point found */
 
  if (*best_point != nullptr) {
    best_dist = edgept_dist(split_point, *best_point);
  }
 
  p = target_point;
  /* Look at each edge point */
  do {
    if (((p->pos.x <= x && x <= p->next->pos.x) || (p->next->pos.x <= x && x <= p->pos.x)) &&
        !same_point(split_point->pos, p->pos) && !same_point(split_point->pos, p->next->pos) &&
        !p->IsChopPt() && (*best_point == nullptr || !same_point((*best_point)->pos, p->pos))) {
      if (near_point(split_point, p, p->next, &this_edgept)) {
        new_point_it.add_before_then_move(this_edgept);
      }
 
      if (*best_point == nullptr) {
        best_dist = edgept_dist(split_point, this_edgept);
      }
 
      this_edgept = pick_close_point(split_point, this_edgept, &best_dist);
      if (this_edgept) {
        *best_point = this_edgept;
      }
    }
 
    p = p->next;
  } while (p != target_point);
}

Member Data Documentation

fill_lattice_

void(Wordrec::* tesseract::Wordrec::fill_lattice_) (const MATRIX &ratings, const WERD_CHOICE_LIST &best_choices, const UNICHARSET &unicharset, BlamerBundle *blamer_bundle)

Definition at line 390 of file wordrec.h.

language_model_

std::unique_ptr<LanguageModel> tesseract::Wordrec::language_model_

Definition at line 382 of file wordrec.h.

pass2_ok_split

PRIORITY tesseract::Wordrec::pass2_ok_split

Definition at line 383 of file wordrec.h.

prev_word_best_choice_

WERD_CHOICE* tesseract::Wordrec::prev_word_best_choice_

Definition at line 387 of file wordrec.h.

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/wordrec.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/chop.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/chopper.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/findseam.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/gradechop.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/outlines.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/pieces.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/segsearch.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/tface.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/wordclass.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/wordrec/wordrec.cpp