mirror/tesseract
1
0
Fork 0
mirror of https://github.com/tesseract-ocr/tesseract.git synced 2024-12-12 23:49:06 +08:00
Code Issues Actions 10 Packages Projects Releases Wiki Activity

More fixes BOOL8 -> bool

Browse Source
This commit is contained in:
Alexander Zaitsev 2018-05-21 00:40:58 +03:00
parent 6f580bad77
commit 6ff0b56597
29 changed files with 244 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/ccmain/adaptions.cpp
View File

@ -37,9 +37,9 @@
#endif
namespace tesseract {
BOOL8 Tesseract::word_adaptable( //should we adapt?
WERD_RES *word,
uint16_t mode) {
bool Tesseract::word_adaptable( //should we adapt?
WERD_RES* word,
uint16_t mode) {
if (tessedit_adaption_debug) {
tprintf("Running word_adaptable() for %s rating %.4f certainty %.4f\n",
word->best_choice == nullptr ? "" :
@ -65,7 +65,7 @@ BOOL8 Tesseract::word_adaptable( //should we adapt?
*/
if (mode == 0) {
if (tessedit_adaption_debug) tprintf("adaption disabled\n");
return FALSE;
return false;
}
if (flags.bit (ADAPTABLE_WERD)) {
@ -83,7 +83,7 @@ BOOL8 Tesseract::word_adaptable( //should we adapt?
}
if (!status) { // If not set then
return FALSE; // ignore other checks
return false; // ignore other checks
}
if (flags.bit (CHECK_DAWGS) &&
@ -92,24 +92,24 @@ BOOL8 Tesseract::word_adaptable( //should we adapt?
(word->best_choice->permuter () != USER_DAWG_PERM) &&
(word->best_choice->permuter () != NUMBER_PERM)) {
if (tessedit_adaption_debug) tprintf("word not in dawgs\n");
return FALSE;
return false;
}
if (flags.bit (CHECK_ONE_ELL_CONFLICT) && one_ell_conflict (word, false)) {
if (tessedit_adaption_debug) tprintf("word has ell conflict\n");
return FALSE;
return false;
}
if (flags.bit (CHECK_SPACES) &&
(strchr(word->best_choice->unichar_string().string(), ' ') != nullptr)) {
if (tessedit_adaption_debug) tprintf("word contains spaces\n");
return FALSE;
return false;
}
if (flags.bit (CHECK_AMBIG_WERD) &&
word->best_choice->dangerous_ambig_found()) {
if (tessedit_adaption_debug) tprintf("word is ambiguous\n");
return FALSE;
return false;
}
if (tessedit_adaption_debug) {

4
src/ccmain/control.cpp
View File

@ -80,7 +80,7 @@ void Tesseract::recog_pseudo_word(PAGE_RES* page_res,
*
* @param pr_it the page results iterator
*/
BOOL8 Tesseract::recog_interactive(PAGE_RES_IT* pr_it) {
bool Tesseract::recog_interactive(PAGE_RES_IT* pr_it) {
int16_t char_qual;
int16_t good_char_qual;
@ -101,7 +101,7 @@ BOOL8 Tesseract::recog_interactive(PAGE_RES_IT* pr_it) {
word_blob_quality(word_res, pr_it->row()->row),
word_outline_errs(word_res), char_qual, good_char_qual);
}
return TRUE;
return true;
}
// Helper function to check for a target word and handle it appropriately.

22
src/ccmain/docqual.cpp
View File

@ -304,7 +304,7 @@ void Tesseract::doc_and_block_rejection( //reject big chunks
prev_word_rejected &&
page_res_it.prev_row() == page_res_it.row() &&
word->word->space() == 1)
word->reject_spaces = TRUE;
word->reject_spaces = true;
word->reject_map.rej_word_block_rej();
}
prev_word_rejected = rej_word;
@ -375,7 +375,7 @@ void Tesseract::doc_and_block_rejection( //reject big chunks
prev_word_rejected &&
page_res_it.prev_row() == page_res_it.row() &&
word->word->space () == 1)
word->reject_spaces = TRUE;
word->reject_spaces = true;
word->reject_map.rej_word_row_rej();
}
prev_word_rejected = rej_word;
@ -411,7 +411,7 @@ void reject_whole_page(PAGE_RES_IT &page_res_it) {
page_res_it.forward ();
}
//whole page is rejected
page_res_it.page_res->rejected = TRUE;
page_res_it.page_res->rejected = true;
}
namespace tesseract {
@ -501,8 +501,8 @@ void Tesseract::tilde_crunch(PAGE_RES_IT &page_res_it) {
}
BOOL8 Tesseract::terrible_word_crunch(WERD_RES *word,
GARBAGE_LEVEL garbage_level) {
bool Tesseract::terrible_word_crunch(WERD_RES* word,
GARBAGE_LEVEL garbage_level) {
float rating_per_ch;
int adjusted_len;
int crunch_mode = 0;
@ -533,15 +533,15 @@ BOOL8 Tesseract::terrible_word_crunch(WERD_RES *word,
tprintf ("Terrible_word_crunch (%d) on \"%s\"\n",
crunch_mode, word->best_choice->unichar_string().string());
}
return TRUE;
return true;
}
else
return FALSE;
return false;
}
BOOL8 Tesseract::potential_word_crunch(WERD_RES *word,
GARBAGE_LEVEL garbage_level,
BOOL8 ok_dict_word) {
bool Tesseract::potential_word_crunch(WERD_RES* word,
GARBAGE_LEVEL garbage_level,
bool ok_dict_word) {
float rating_per_ch;
int adjusted_len;
const char *str = word->best_choice->unichar_string().string();
@ -975,7 +975,7 @@ int16_t Tesseract::failure_count(WERD_RES *word) {
}
BOOL8 Tesseract::noise_outlines(TWERD *word) {
bool Tesseract::noise_outlines(TWERD* word) {
TBOX box; // BB of outline
int16_t outline_count = 0;
int16_t small_outline_count = 0;

14
src/ccmain/fixspace.cpp
View File

@ -184,8 +184,8 @@ void initialise_search(WERD_RES_LIST &src_list, WERD_RES_LIST &new_list) {
src_wd = src_it.data();
if (!src_wd->combination) {
new_wd = WERD_RES::deep_copy(src_wd);
new_wd->combination = FALSE;
new_wd->part_of_combo = FALSE;
new_wd->combination = false;
new_wd->part_of_combo = false;
new_it.add_after_then_move(new_wd);
}
}
@ -417,7 +417,7 @@ void transform_to_next_perm(WERD_RES_LIST &words) {
combo = new WERD_RES(copy_word);
combo->combination = TRUE;
combo->x_height = prev_word->x_height;
prev_word->part_of_combo = TRUE;
prev_word->part_of_combo = true;
prev_word_it.add_before_then_move(combo);
}
combo->word->set_flag(W_EOL, word->word->flag(W_EOL));
@ -429,7 +429,7 @@ void transform_to_next_perm(WERD_RES_LIST &words) {
} else {
// Copy current wd to combo
combo->copy_on(word);
word->part_of_combo = TRUE;
word->part_of_combo = true;
}
combo->done = FALSE;
combo->ClearResults();
@ -583,9 +583,9 @@ void Tesseract::fix_noisy_space_list(WERD_RES_LIST &best_perm, ROW *row,
old_word_res = best_perm_it.data();
// Even deep_copy doesn't copy the underlying WERD unless its combination
// flag is true!.
old_word_res->combination = TRUE; // Kludge to force deep copy
old_word_res->combination = true; // Kludge to force deep copy
current_perm_it.add_to_end(WERD_RES::deep_copy(old_word_res));
old_word_res->combination = FALSE; // Undo kludge
old_word_res->combination = false; // Undo kludge
break_noisiest_blob_word(current_perm);
@ -671,7 +671,7 @@ void Tesseract::break_noisiest_blob_word(WERD_RES_LIST &words) {
}
WERD_RES* new_word_res = new WERD_RES(new_word);
new_word_res->combination = TRUE;
new_word_res->combination = true;
worst_word_it.add_before_then_move(new_word_res);
word_res->ClearResults();

18
src/ccmain/output.cpp
View File

@ -412,9 +412,9 @@ int16_t Tesseract::count_alphanums(const WERD_CHOICE &word) {
}
BOOL8 Tesseract::acceptable_number_string(const char *s,
const char *lengths) {
BOOL8 prev_digit = FALSE;
bool Tesseract::acceptable_number_string(const char* s,
const char* lengths) {
bool prev_digit = false;
if (*lengths == 1 && *s == '(')
s++;
@ -425,21 +425,21 @@ BOOL8 Tesseract::acceptable_number_string(const char *s,
for (; *s != '\0'; s += *(lengths++)) {
if (unicharset.get_isdigit(s, *lengths))
prev_digit = TRUE;
prev_digit = true;
else if (prev_digit &&
(*lengths == 1 && ((*s == '.') || (*s == ',') || (*s == '-'))))
prev_digit = FALSE;
prev_digit = false;
else if (prev_digit && *lengths == 1 &&
(*(s + *lengths) == '\0') && ((*s == '%') || (*s == ')')))
return TRUE;
return true;
else if (prev_digit &&
*lengths == 1 && (*s == '%') &&
(*(lengths + 1) == 1 && *(s + *lengths) == ')') &&
(*(s + *lengths + *(lengths + 1)) == '\0'))
return TRUE;
return true;
else
return FALSE;
return false;
}
return TRUE;
return true;
}
} // namespace tesseract

20
src/ccmain/pgedit.cpp
View File

@ -302,7 +302,7 @@ SVMenuNode *Tesseract::build_menu_new() {
* Redisplay page
*/
void Tesseract::do_re_display(
BOOL8 (tesseract::Tesseract::*word_painter)(PAGE_RES_IT* pr_it)) {
bool (tesseract::Tesseract::* word_painter)(PAGE_RES_IT* pr_it)) {
int block_count = 1;
image_win->Clear();
@ -710,7 +710,7 @@ void show_point(PAGE_RES* page_res, float x, float y) {
#endif // GRAPHICS_DISABLED
namespace tesseract {
#ifndef GRAPHICS_DISABLED
BOOL8 Tesseract:: word_blank_and_set_display(PAGE_RES_IT* pr_it) {
bool Tesseract::word_blank_and_set_display(PAGE_RES_IT* pr_it) {
pr_it->word()->word->bounding_box().plot(image_win, ScrollView::BLACK,
ScrollView::BLACK);
return word_set_display(pr_it);
@ -722,7 +722,7 @@ BOOL8 Tesseract:: word_blank_and_set_display(PAGE_RES_IT* pr_it) {
*
* Normalize word and display in word window
*/
BOOL8 Tesseract::word_bln_display(PAGE_RES_IT* pr_it) {
bool Tesseract::word_bln_display(PAGE_RES_IT* pr_it) {
WERD_RES* word_res = pr_it->word();
if (word_res->chopped_word == nullptr) {
// Setup word normalization parameters.
@ -744,7 +744,7 @@ BOOL8 Tesseract::word_bln_display(PAGE_RES_IT* pr_it) {
color = WERD::NextColor(color);
}
bln_word_window_handle()->Update();
return TRUE;
return true;
}
@ -754,7 +754,7 @@ BOOL8 Tesseract::word_bln_display(PAGE_RES_IT* pr_it) {
*
* Display a word according to its display modes
*/
BOOL8 Tesseract::word_display(PAGE_RES_IT* pr_it) {
bool Tesseract::word_display(PAGE_RES_IT* pr_it) {
WERD_RES* word_res = pr_it->word();
WERD* word = word_res->word;
TBOX word_bb; // word bounding box
@ -906,7 +906,7 @@ BOOL8 Tesseract::word_display(PAGE_RES_IT* pr_it) {
(ScrollView::Color)((int32_t) editor_image_word_bb_color),
(ScrollView::Color)((int32_t)
editor_image_word_bb_color));
return TRUE;
return true;
}
#endif // GRAPHICS_DISABLED
@ -915,10 +915,10 @@ BOOL8 Tesseract::word_display(PAGE_RES_IT* pr_it) {
*
* Dump members to the debug window
*/
BOOL8 Tesseract::word_dumper(PAGE_RES_IT* pr_it) {
bool Tesseract::word_dumper(PAGE_RES_IT* pr_it) {
if (pr_it->block()->block != nullptr) {
tprintf("\nBlock data...\n");
pr_it->block()->block->print(nullptr, FALSE);
pr_it->block()->block->print(nullptr, false);
}
tprintf("\nRow data...\n");
pr_it->row()->row->print(nullptr);
@ -930,7 +930,7 @@ BOOL8 Tesseract::word_dumper(PAGE_RES_IT* pr_it) {
tprintf("Current blamer debug: %s\n",
word_res->blamer_bundle->debug().string());
}
return TRUE;
return true;
}
#ifndef GRAPHICS_DISABLED
@ -939,7 +939,7 @@ BOOL8 Tesseract::word_dumper(PAGE_RES_IT* pr_it) {
*
* Display word according to current display mode settings
*/
BOOL8 Tesseract::word_set_display(PAGE_RES_IT* pr_it) {
bool Tesseract::word_set_display(PAGE_RES_IT* pr_it) {
WERD* word = pr_it->word()->word;
word->set_display_flag(DF_BOX, word_display_mode.bit(DF_BOX));
word->set_display_flag(DF_TEXT, word_display_mode.bit(DF_TEXT));

8
src/ccmain/reject.cpp
View File

@ -501,17 +501,17 @@ int16_t Tesseract::alpha_count(const char *word,
}
BOOL8 Tesseract::word_contains_non_1_digit(const char *word,
const char *word_lengths) {
bool Tesseract::word_contains_non_1_digit(const char* word,
const char* word_lengths) {
int16_t i;
int16_t offset;
for (i = 0, offset = 0; word[offset] != '\0'; offset += word_lengths[i++]) {
if (unicharset.get_isdigit (word + offset, word_lengths[i]) &&
(word_lengths[i] != 1 || word[offset] != '1'))
return TRUE;
return true;
}
return FALSE;
return false;
}
/*************************************************************************

48
src/ccmain/tesseractclass.h
View File

@ -453,7 +453,7 @@ class Tesseract : public Wordrec {
bool TestNewNormalization(int original_misfits, float baseline_shift,
float new_x_ht, WERD_RES *word, BLOCK* block,
ROW *row);
BOOL8 recog_interactive(PAGE_RES_IT* pr_it);
bool recog_interactive(PAGE_RES_IT* pr_it);
// Set fonts of this word.
void set_word_fonts(WERD_RES *word);
@ -497,8 +497,8 @@ class Tesseract : public Wordrec {
);
void set_unlv_suspects(WERD_RES *word);
UNICHAR_ID get_rep_char(WERD_RES *word); // what char is repeated?
BOOL8 acceptable_number_string(const char *s,
const char *lengths);
bool acceptable_number_string(const char* s,
const char* lengths);
int16_t count_alphanums(const WERD_CHOICE &word);
int16_t count_alphas(const WERD_CHOICE &word);
//// tessedit.h ////////////////////////////////////////////////////////
@ -577,13 +577,13 @@ class Tesseract : public Wordrec {
);
void debug_word(PAGE_RES* page_res, const TBOX &selection_box);
void do_re_display(
BOOL8 (tesseract::Tesseract::*word_painter)(PAGE_RES_IT* pr_it));
BOOL8 word_display(PAGE_RES_IT* pr_it);
BOOL8 word_bln_display(PAGE_RES_IT* pr_it);
BOOL8 word_blank_and_set_display(PAGE_RES_IT* pr_its);
BOOL8 word_set_display(PAGE_RES_IT* pr_it);
bool (tesseract::Tesseract::* word_painter)(PAGE_RES_IT* pr_it));
bool word_display(PAGE_RES_IT* pr_it);
bool word_bln_display(PAGE_RES_IT* pr_it);
bool word_blank_and_set_display(PAGE_RES_IT* pr_its);
bool word_set_display(PAGE_RES_IT* pr_it);
// #ifndef GRAPHICS_DISABLED
BOOL8 word_dumper(PAGE_RES_IT* pr_it);
bool word_dumper(PAGE_RES_IT* pr_it);
// #endif // GRAPHICS_DISABLED
void blob_feature_display(PAGE_RES* page_res, const TBOX& selection_box);
//// reject.h //////////////////////////////////////////////////////////
@ -596,8 +596,8 @@ class Tesseract : public Wordrec {
const char *word_lengths);
int16_t alpha_count(const char *word,
const char *word_lengths);
BOOL8 word_contains_non_1_digit(const char *word,
const char *word_lengths);
bool word_contains_non_1_digit(const char* word,
const char* word_lengths);
void dont_allow_1Il(WERD_RES *word);
int16_t count_alphanums( //how many alphanums
WERD_RES *word);
@ -618,9 +618,9 @@ class Tesseract : public Wordrec {
void reject_edge_blobs(WERD_RES *word);
void reject_mostly_rejects(WERD_RES *word);
//// adaptions.h ///////////////////////////////////////////////////////
BOOL8 word_adaptable( //should we adapt?
WERD_RES *word,
uint16_t mode);
bool word_adaptable( //should we adapt?
WERD_RES* word,
uint16_t mode);
//// tfacepp.cpp ///////////////////////////////////////////////////////
void recog_word_recursive(WERD_RES* word);
@ -653,9 +653,9 @@ class Tesseract : public Wordrec {
void break_noisiest_blob_word(WERD_RES_LIST &words);
//// docqual.cpp ////////////////////////////////////////////////////////
GARBAGE_LEVEL garbage_word(WERD_RES *word, BOOL8 ok_dict_word);
BOOL8 potential_word_crunch(WERD_RES *word,
GARBAGE_LEVEL garbage_level,
BOOL8 ok_dict_word);
bool potential_word_crunch(WERD_RES* word,
GARBAGE_LEVEL garbage_level,
bool ok_dict_word);
void tilde_crunch(PAGE_RES_IT &page_res_it);
void unrej_good_quality_words( //unreject potential
PAGE_RES_IT &page_res_it);
@ -672,17 +672,17 @@ class Tesseract : public Wordrec {
void unrej_good_chs(WERD_RES *word, ROW *row);
int16_t count_outline_errs(char c, int16_t outline_count);
int16_t word_outline_errs(WERD_RES *word);
BOOL8 terrible_word_crunch(WERD_RES *word, GARBAGE_LEVEL garbage_level);
bool terrible_word_crunch(WERD_RES* word, GARBAGE_LEVEL garbage_level);
CRUNCH_MODE word_deletable(WERD_RES *word, int16_t &delete_mode);
int16_t failure_count(WERD_RES *word);
BOOL8 noise_outlines(TWERD *word);
bool noise_outlines(TWERD* word);
//// pagewalk.cpp ///////////////////////////////////////////////////////
void
process_selected_words (
PAGE_RES* page_res, // blocks to check
//function to call
TBOX & selection_box,
BOOL8 (tesseract::Tesseract::*word_processor)(PAGE_RES_IT* pr_it));
process_selected_words(
PAGE_RES* page_res, // blocks to check
//function to call
TBOX& selection_box,
bool (tesseract::Tesseract::* word_processor)(PAGE_RES_IT* pr_it));
//// tessbox.cpp ///////////////////////////////////////////////////////
void tess_add_doc_word( //test acceptability
WERD_CHOICE *word_choice //after context

4
src/ccstruct/blobbox.cpp
View File

@ -820,8 +820,8 @@ void TO_ROW::compute_vertical_projection() { //project whole row
* Zero out all scalar members.
**********************************************************************/
void TO_ROW::clear() {
all_caps = 0;
used_dm_model = 0;
all_caps = false;
used_dm_model = false;
projection_left = 0;
projection_right = 0;
pitch_decision = PITCH_DUNNO;

6
src/ccstruct/blobbox.h
View File

@ -639,9 +639,9 @@ class TO_ROW: public ELIST2_LINK
}
// true when dead
BOOL8 merged;
BOOL8 all_caps; // had no ascenders
BOOL8 used_dm_model; // in guessing pitch
bool merged;
bool all_caps; // had no ascenders
bool used_dm_model; // in guessing pitch
int16_t projection_left; // start of projection
int16_t projection_right; // start of projection
PITCH_TYPE pitch_decision; // how strong is decision

6
src/ccstruct/coutln.h
View File

@ -93,13 +93,13 @@ class DLLSYM C_OUTLINE:public ELIST_LINK {
delete [] offsets;
}
BOOL8 flag( //test flag
bool flag( //test flag
C_OUTLINE_FLAGS mask) const { //flag to test
return flags.bit(mask);
}
void set_flag( //set flag value
C_OUTLINE_FLAGS mask, //flag to test
BOOL8 value) { //value to set
C_OUTLINE_FLAGS mask, //flag to test
bool value) { //value to set
flags.set_bit(mask, value);
}

6
src/ccstruct/ocrblock.cpp
View File

@ -195,9 +195,9 @@ void BLOCK::compress( // squash it up
*/
void BLOCK::print( //print list of sides
FILE *, //< file to print on
BOOL8 dump //< print full detail
) {
FILE*, //< file to print on
bool dump //< print full detail
) {
ICOORDELT_IT it = &pdblk.leftside; //iterator
pdblk.box.print ();

2
src/ccstruct/ocrblock.h
View File

@ -187,7 +187,7 @@ class BLOCK:public ELIST_LINK
void compress(const ICOORD vec);
/// dump whole table
void print(FILE *fp, BOOL8 dump);
void print(FILE* fp, bool dump);
BLOCK& operator=(const BLOCK & source);
PDBLK pdblk; //< Page Description Block

24
src/ccstruct/pageres.cpp
View File

@ -89,9 +89,9 @@ BLOCK_RES::BLOCK_RES(bool merge_similar_words, BLOCK *the_block) {
rej_count = 0;
font_class = -1; //not assigned
x_height = -1.0;
font_assigned = FALSE;
bold = FALSE;
italic = FALSE;
font_assigned = false;
bold = false;
italic = false;
row_count = 0;
block = the_block;
@ -1084,10 +1084,10 @@ WERD_RES::~WERD_RES () {
}
void WERD_RES::InitNonPointers() {
tess_failed = FALSE;
tess_accepted = FALSE;
tess_would_adapt = FALSE;
done = FALSE;
tess_failed = false;
tess_accepted = false;
tess_would_adapt = false;
done = false;
unlv_crunch_mode = CR_NONE;
small_caps = false;
odd_size = false;
@ -1104,11 +1104,11 @@ void WERD_RES::InitNonPointers() {
caps_height = 0.0;
baseline_shift = 0.0f;
space_certainty = 0.0f;
guessed_x_ht = TRUE;
guessed_caps_ht = TRUE;
combination = FALSE;
part_of_combo = FALSE;
reject_spaces = FALSE;
guessed_x_ht = true;
guessed_caps_ht = true;
combination = false;
part_of_combo = false;
reject_spaces = false;
}
void WERD_RES::InitPointers() {

28
src/ccstruct/pageres.h
View File

@ -60,7 +60,7 @@ class PAGE_RES { // page result
int32_t char_count;
int32_t rej_count;
BLOCK_RES_LIST block_res_list;
BOOL8 rejected;
bool rejected;
// Updated every time PAGE_RES_IT iterating on this PAGE_RES moves to
// the next word. This pointer is not owned by PAGE_RES class.
WERD_CHOICE **prev_word_best_choice;
@ -75,7 +75,7 @@ class PAGE_RES { // page result
inline void Init() {
char_count = 0;
rej_count = 0;
rejected = FALSE;
rejected = false;
prev_word_best_choice = nullptr;
blame_reasons.init_to_size(IRR_NUM_REASONS, 0);
}
@ -102,10 +102,10 @@ class BLOCK_RES:public ELIST_LINK {
int16_t font_class; //
int16_t row_count;
float x_height;
BOOL8 font_assigned; // block already
bool font_assigned; // block already
// processed
BOOL8 bold; // all bold
BOOL8 italic; // all italic
bool bold; // all bold
bool italic; // all italic
ROW_RES_LIST row_res_list;
@ -269,7 +269,7 @@ class WERD_RES : public ELIST_LINK {
// TODO(rays) Add more documentation here.
WERD_CHOICE *ep_choice; // ep text TODO(rays) delete this.
REJMAP reject_map; // best_choice rejects
BOOL8 tess_failed;
bool tess_failed;
/*
If tess_failed is TRUE, one of the following tests failed when Tess
returned:
@ -277,9 +277,9 @@ class WERD_RES : public ELIST_LINK {
- The best_choice string contained ALL blanks;
- The best_choice string was zero length
*/
BOOL8 tess_accepted; // Tess thinks its ok?
BOOL8 tess_would_adapt; // Tess would adapt?
BOOL8 done; // ready for output?
bool tess_accepted; // Tess thinks its ok?
bool tess_would_adapt; // Tess would adapt?
bool done; // ready for output?
bool small_caps; // word appears to be small caps
bool odd_size; // word is bigger than line or leader dots.
int8_t italic;
@ -289,8 +289,8 @@ class WERD_RES : public ELIST_LINK {
const FontInfo* fontinfo2;
int8_t fontinfo_id_count; // number of votes
int8_t fontinfo_id2_count; // number of votes
BOOL8 guessed_x_ht;
BOOL8 guessed_caps_ht;
bool guessed_x_ht;
bool guessed_caps_ht;
CRUNCH_MODE unlv_crunch_mode;
float x_height; // post match estimate
float caps_height; // post match estimate
@ -315,9 +315,9 @@ class WERD_RES : public ELIST_LINK {
Combination words are FOLLOWED by the sequence of part_of_combo words
which they combine.
*/
BOOL8 combination; //of two fuzzy gap wds
BOOL8 part_of_combo; //part of a combo
BOOL8 reject_spaces; //Reject spacing?
bool combination; //of two fuzzy gap wds
bool part_of_combo; //part of a combo
bool reject_spaces; //Reject spacing?
WERD_RES() {
InitNonPointers();

20
src/ccstruct/rejctmap.cpp
View File

@ -290,25 +290,21 @@ int16_t REJMAP::accept_count() { //How many accepted?
}
BOOL8 REJMAP::recoverable_rejects() { //Any non perm rejs?
int i;
for (i = 0; i < len; i++) {
bool REJMAP::recoverable_rejects() { //Any non perm rejs?
for (int i = 0; i < len; i++) {
if (ptr[i].recoverable ())
return TRUE;
return true;
}
return FALSE;
return false;
}
BOOL8 REJMAP::quality_recoverable_rejects() { //Any potential rejs?
int i;
for (i = 0; i < len; i++) {
bool REJMAP::quality_recoverable_rejects() { //Any potential rejs?
for (int i = 0; i < len; i++) {
if (ptr[i].accept_if_good_quality ())
return TRUE;
return true;
}
return FALSE;
return false;
}

8
src/ccstruct/rejctmap.h
View File

@ -154,14 +154,14 @@ class REJ
bool rejected(); //Is char rejected?
BOOL8 accepted() { //Is char accepted?
bool accepted() { //Is char accepted?
return !rejected ();
}
//potential rej?
bool accept_if_good_quality();
BOOL8 recoverable() {
bool recoverable() {
return (rejected () && !perm_rejected ());
}
@ -240,9 +240,9 @@ class REJMAP
void full_print(FILE *fp);
BOOL8 recoverable_rejects(); //Any non perm rejs?
bool recoverable_rejects(); //Any non perm rejs?
BOOL8 quality_recoverable_rejects();
bool quality_recoverable_rejects();
//Any potential rejs?
void rej_word_small_xht(); //Reject whole word

6
src/ccstruct/statistc.cpp
View File

@ -320,7 +320,7 @@ int32_t STATS::cluster(float lower, // thresholds
float multiple, // distance threshold
int32_t max_clusters, // max no to make
STATS *clusters) { // array of clusters
BOOL8 new_cluster; // added one
bool new_cluster; // added one
float *centres; // cluster centres
int32_t entry; // bucket index
int32_t cluster; // cluster index
@ -369,7 +369,7 @@ int32_t STATS::cluster(float lower, // thresholds
clusters[0].set_range(rangemin_, rangemax_);
}
do {
new_cluster = FALSE;
new_cluster = false;
new_mode = 0;
for (entry = 0; entry < rangemax_ - rangemin_; entry++) {
count = buckets_[entry] - clusters[0].buckets_[entry];
@ -401,7 +401,7 @@ int32_t STATS::cluster(float lower, // thresholds
// need new and room
if (new_mode > 0 && cluster_count < max_clusters) {
cluster_count++;
new_cluster = TRUE;
new_cluster = true;
if (!clusters[cluster_count].set_range(rangemin_, rangemax_)) {
delete [] centres;
return 0;

6
src/ccstruct/werd.h
View File

@ -125,11 +125,11 @@ class WERD : public ELIST2_LINK {
const char *text() const { return correct.string(); }
void set_text(const char *new_text) { correct = new_text; }
BOOL8 flag(WERD_FLAGS mask) const { return flags.bit(mask); }
bool flag(WERD_FLAGS mask) const { return flags.bit(mask); }
void set_flag(WERD_FLAGS mask, bool value) { flags.set_bit(mask, value); }
BOOL8 display_flag(uint8_t flag) const { return disp_flags.bit(flag); }
void set_display_flag(uint8_t flag, BOOL8 value) {
bool display_flag(uint8_t flag) const { return disp_flags.bit(flag); }
void set_display_flag(uint8_t flag, bool value) {
disp_flags.set_bit(flag, value);
}

12
src/ccutil/clst.cpp
View File

@ -466,9 +466,9 @@ CLIST_LINK *CLIST_ITERATOR::extract_sublist( //from
nullptr);
#endif
ex_current_was_last = other_it->ex_current_was_last = FALSE;
ex_current_was_cycle_pt = FALSE;
other_it->ex_current_was_cycle_pt = FALSE;
ex_current_was_last = other_it->ex_current_was_last = false;
ex_current_was_cycle_pt = false;
other_it->ex_current_was_cycle_pt = false;
temp_it.mark_cycle_pt ();
do { //walk sublist
@ -477,14 +477,14 @@ CLIST_LINK *CLIST_ITERATOR::extract_sublist( //from
if (temp_it.at_last ()) {
list->last = prev;
ex_current_was_last = other_it->ex_current_was_last = TRUE;
ex_current_was_last = other_it->ex_current_was_last = true;
}
if (temp_it.current == cycle_pt)
ex_current_was_cycle_pt = TRUE;
ex_current_was_cycle_pt = true;
if (temp_it.current == other_it->cycle_pt)
other_it->ex_current_was_cycle_pt = TRUE;
other_it->ex_current_was_cycle_pt = true;
temp_it.forward ();
}

46
src/ccutil/clst.h
View File

@ -150,13 +150,13 @@ class DLLSYM CLIST_ITERATOR
CLIST_LINK *prev; //prev element
CLIST_LINK *current; //current element
CLIST_LINK *next; //next element
BOOL8 ex_current_was_last; //current extracted
bool ex_current_was_last; //current extracted
//was end of list
BOOL8 ex_current_was_cycle_pt; //current extracted
bool ex_current_was_cycle_pt; //current extracted
//was cycle point
CLIST_LINK *cycle_pt; //point we are cycling
//the list to.
BOOL8 started_cycling; //Have we moved off
bool started_cycling; //Have we moved off
//the start?
CLIST_LINK *extract_sublist( //from this current...
@ -214,7 +214,7 @@ class DLLSYM CLIST_ITERATOR
void mark_cycle_pt(); //remember current
BOOL8 empty() { //is list empty?
bool empty() { //is list empty?
#ifndef NDEBUG
if (!list)
NO_LIST.error ("CLIST_ITERATOR::empty", ABORT, nullptr);
@ -222,15 +222,15 @@ class DLLSYM CLIST_ITERATOR
return list->empty ();
}
BOOL8 current_extracted() { //current extracted?
bool current_extracted() { //current extracted?
return !current;
}
BOOL8 at_first(); //Current is first?
bool at_first(); //Current is first?
BOOL8 at_last(); //Current is last?
bool at_last(); //Current is last?
BOOL8 cycled_list(); //Completed a cycle?
bool cycled_list(); //Completed a cycle?
void add_to_end( // add at end &
void *new_data); // don't move
@ -266,9 +266,9 @@ inline void CLIST_ITERATOR::set_to_list( //change list
current = list->First ();
next = current != nullptr ? current->next : nullptr;
cycle_pt = nullptr; //await explicit set
started_cycling = FALSE;
ex_current_was_last = FALSE;
ex_current_was_cycle_pt = FALSE;
started_cycling = false;
ex_current_was_last = false;
ex_current_was_cycle_pt = false;
}
/***********************************************************************
@ -354,7 +354,7 @@ inline void CLIST_ITERATOR::add_after_stay_put( // element to add
new_element->next = new_element;
list->last = new_element;
prev = next = new_element;
ex_current_was_last = FALSE;
ex_current_was_last = false;
current = nullptr;
}
else {
@ -371,7 +371,7 @@ inline void CLIST_ITERATOR::add_after_stay_put( // element to add
prev->next = new_element;
if (ex_current_was_last) {
list->last = new_element;
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
}
next = new_element;
@ -448,7 +448,7 @@ inline void CLIST_ITERATOR::add_before_stay_put( // element to add
new_element->next = new_element;
list->last = new_element;
prev = next = new_element;
ex_current_was_last = TRUE;
ex_current_was_last = true;
current = nullptr;
}
else {
@ -489,7 +489,7 @@ inline void CLIST_ITERATOR::add_list_after(CLIST *list_to_add) {
list->last = list_to_add->last;
prev = list->last;
next = list->First ();
ex_current_was_last = TRUE;
ex_current_was_last = true;
current = nullptr;
}
else {
@ -504,7 +504,7 @@ inline void CLIST_ITERATOR::add_list_after(CLIST *list_to_add) {
prev->next = list_to_add->First ();
if (ex_current_was_last) {
list->last = list_to_add->last;
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
list_to_add->last->next = next;
next = prev->next;
@ -537,7 +537,7 @@ inline void CLIST_ITERATOR::add_list_before(CLIST *list_to_add) {
prev = list->last;
current = list->First ();
next = current->next;
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
else {
prev->next = list_to_add->First ();
@ -587,13 +587,13 @@ inline void *CLIST_ITERATOR::extract() {
if (current == list->last) {
list->last = prev;
ex_current_was_last = TRUE;
ex_current_was_last = true;
} else {
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
}
// Always set ex_current_was_cycle_pt so an add/forward will work in a loop.
ex_current_was_cycle_pt = (current == cycle_pt) ? TRUE : FALSE;
ex_current_was_cycle_pt = (current == cycle_pt);
extracted_data = current->data;
delete(current); //destroy CONS cell
current = nullptr;
@ -650,7 +650,7 @@ inline void CLIST_ITERATOR::mark_cycle_pt() {
*
**********************************************************************/
inline BOOL8 CLIST_ITERATOR::at_first() {
inline bool CLIST_ITERATOR::at_first() {
#ifndef NDEBUG
if (!list)
NO_LIST.error ("CLIST_ITERATOR::at_first", ABORT, nullptr);
@ -669,7 +669,7 @@ inline BOOL8 CLIST_ITERATOR::at_first() {
*
**********************************************************************/
inline BOOL8 CLIST_ITERATOR::at_last() {
inline bool CLIST_ITERATOR::at_last() {
#ifndef NDEBUG
if (!list)
NO_LIST.error ("CLIST_ITERATOR::at_last", ABORT, nullptr);
@ -688,7 +688,7 @@ inline BOOL8 CLIST_ITERATOR::at_last() {
*
**********************************************************************/
inline BOOL8 CLIST_ITERATOR::cycled_list() {
inline bool CLIST_ITERATOR::cycled_list() {
#ifndef NDEBUG
if (!list)
NO_LIST.error ("CLIST_ITERATOR::cycled_list", ABORT, nullptr);

12
src/ccutil/elst2.cpp
View File

@ -439,9 +439,9 @@ ELIST2_LINK *ELIST2_ITERATOR::extract_sublist( //fr
nullptr);
#endif
ex_current_was_last = other_it->ex_current_was_last = FALSE;
ex_current_was_cycle_pt = FALSE;
other_it->ex_current_was_cycle_pt = FALSE;
ex_current_was_last = other_it->ex_current_was_last = false;
ex_current_was_cycle_pt = false;
other_it->ex_current_was_cycle_pt = false;
temp_it.mark_cycle_pt ();
do { //walk sublist
@ -450,14 +450,14 @@ ELIST2_LINK *ELIST2_ITERATOR::extract_sublist( //fr
if (temp_it.at_last ()) {
list->last = prev;
ex_current_was_last = other_it->ex_current_was_last = TRUE;
ex_current_was_last = other_it->ex_current_was_last = true;
}
if (temp_it.current == cycle_pt)
ex_current_was_cycle_pt = TRUE;
ex_current_was_cycle_pt = true;
if (temp_it.current == other_it->cycle_pt)
other_it->ex_current_was_cycle_pt = TRUE;
other_it->ex_current_was_cycle_pt = true;
temp_it.forward ();
}

46
src/ccutil/elst2.h
View File

@ -156,13 +156,13 @@ class DLLSYM ELIST2_ITERATOR
ELIST2_LINK *prev; //prev element
ELIST2_LINK *current; //current element
ELIST2_LINK *next; //next element
BOOL8 ex_current_was_last; //current extracted
bool ex_current_was_last; //current extracted
//was end of list
BOOL8 ex_current_was_cycle_pt; //current extracted
bool ex_current_was_cycle_pt; //current extracted
//was cycle point
ELIST2_LINK *cycle_pt; //point we are cycling
//the list to.
BOOL8 started_cycling; //Have we moved off
bool started_cycling; //Have we moved off
//the start?
ELIST2_LINK *extract_sublist( //from this current...
@ -219,7 +219,7 @@ class DLLSYM ELIST2_ITERATOR
void mark_cycle_pt(); //remember current
BOOL8 empty() { //is list empty?
bool empty() { //is list empty?
#ifndef NDEBUG
if (!list)
NO_LIST.error ("ELIST2_ITERATOR::empty", ABORT, nullptr);
@ -227,15 +227,15 @@ class DLLSYM ELIST2_ITERATOR
return list->empty ();
}
BOOL8 current_extracted() { //current extracted?
bool current_extracted() { //current extracted?
return !current;
}
BOOL8 at_first(); //Current is first?
bool at_first(); //Current is first?
BOOL8 at_last(); //Current is last?
bool at_last(); //Current is last?
BOOL8 cycled_list(); //Completed a cycle?
bool cycled_list(); //Completed a cycle?
void add_to_end( // add at end &
ELIST2_LINK *new_link); // don't move
@ -274,9 +274,9 @@ inline void ELIST2_ITERATOR::set_to_list( //change list
current = list->First ();
next = current ? current->next : nullptr;
cycle_pt = nullptr; //await explicit set
started_cycling = FALSE;
ex_current_was_last = FALSE;
ex_current_was_cycle_pt = FALSE;
started_cycling = false;
ex_current_was_last = false;
ex_current_was_cycle_pt = false;
}
/***********************************************************************
@ -361,7 +361,7 @@ inline void ELIST2_ITERATOR::add_after_stay_put( // element to add
new_element->prev = new_element;
list->last = new_element;
prev = next = new_element;
ex_current_was_last = FALSE;
ex_current_was_last = false;
current = nullptr;
}
else {
@ -381,7 +381,7 @@ inline void ELIST2_ITERATOR::add_after_stay_put( // element to add
prev->next = new_element;
if (ex_current_was_last) {
list->last = new_element;
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
}
next = new_element;
@ -458,7 +458,7 @@ inline void ELIST2_ITERATOR::add_before_stay_put( // element to add
new_element->prev = new_element;
list->last = new_element;
prev = next = new_element;
ex_current_was_last = TRUE;
ex_current_was_last = true;
current = nullptr;
}
else {
@ -503,7 +503,7 @@ inline void ELIST2_ITERATOR::add_list_after(ELIST2 *list_to_add) {
list->last = list_to_add->last;
prev = list->last;
next = list->First ();
ex_current_was_last = TRUE;
ex_current_was_last = true;
current = nullptr;
}
else {
@ -521,7 +521,7 @@ inline void ELIST2_ITERATOR::add_list_after(ELIST2 *list_to_add) {
prev->next->prev = prev;
if (ex_current_was_last) {
list->last = list_to_add->last;
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
list_to_add->last->next = next;
next->prev = list_to_add->last;
@ -555,7 +555,7 @@ inline void ELIST2_ITERATOR::add_list_before(ELIST2 *list_to_add) {
prev = list->last;
current = list->First ();
next = current->next;
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
else {
prev->next = list_to_add->First ();
@ -610,13 +610,13 @@ inline ELIST2_LINK *ELIST2_ITERATOR::extract() {
if (current == list->last) {
list->last = prev;
ex_current_was_last = TRUE;
ex_current_was_last = true;
} else {
ex_current_was_last = FALSE;
ex_current_was_last = false;
}
}
// Always set ex_current_was_cycle_pt so an add/forward will work in a loop.
ex_current_was_cycle_pt = (current == cycle_pt) ? TRUE : FALSE;
ex_current_was_cycle_pt = (current == cycle_pt) ? true : false;
extracted_link = current;
extracted_link->next = nullptr; //for safety
extracted_link->prev = nullptr; //for safety
@ -693,7 +693,7 @@ inline void ELIST2_ITERATOR::mark_cycle_pt() {
*
**********************************************************************/
inline BOOL8 ELIST2_ITERATOR::at_first() {
inline bool ELIST2_ITERATOR::at_first() {
#ifndef NDEBUG
if (!list)
NO_LIST.error ("ELIST2_ITERATOR::at_first", ABORT, nullptr);
@ -712,7 +712,7 @@ inline BOOL8 ELIST2_ITERATOR::at_first() {
*
**********************************************************************/
inline BOOL8 ELIST2_ITERATOR::at_last() {
inline bool ELIST2_ITERATOR::at_last() {
#ifndef NDEBUG
if (!list)
NO_LIST.error ("ELIST2_ITERATOR::at_last", ABORT, nullptr);
@ -731,7 +731,7 @@ inline BOOL8 ELIST2_ITERATOR::at_last() {
*
**********************************************************************/
inline BOOL8 ELIST2_ITERATOR::cycled_list() {
inline bool ELIST2_ITERATOR::cycled_list() {
#ifndef NDEBUG
if (!list)
NO_LIST.error ("ELIST2_ITERATOR::cycled_list", ABORT, nullptr);

4
src/textord/gap_map.cpp
View File

@ -54,7 +54,7 @@ GAPMAP::GAPMAP( //Constructor
min_left = INT16_MAX;
max_right = -INT16_MAX;
total_rows = 0;
any_tabs = FALSE;
any_tabs = false;
// row iterator
TO_ROW_IT row_it(block->get_rows());
@ -143,7 +143,7 @@ GAPMAP::GAPMAP( //Constructor
map[i] = 0; //prevent isolated quantum
}
else
any_tabs = TRUE;
any_tabs = true;
}
}
if (gapmap_debug && any_tabs)

2
src/textord/gap_map.h
View File

@ -34,7 +34,7 @@ class GAPMAP
int16_t bucket_size; // half an x ht
int16_t *map; //empty counts
int16_t map_max; //map[0..max_map] defind
BOOL8 any_tabs;
bool any_tabs;
};
/*-----------------------------*/

6
src/textord/makerow.cpp
View File

@ -209,14 +209,14 @@ float make_rows(ICOORD page_tr, TO_BLOCK_LIST *port_blocks) {
for (block_it.mark_cycle_pt(); !block_it.cycled_list();
block_it.forward())
make_initial_textrows(page_tr, block_it.data(), FCOORD(1.0f, 0.0f),
!(BOOL8) textord_test_landscape);
!textord_test_landscape);
// compute globally
compute_page_skew(port_blocks, port_m, port_err);
block_it.set_to_list(port_blocks);
for (block_it.mark_cycle_pt(); !block_it.cycled_list(); block_it.forward()) {
cleanup_rows_making(page_tr, block_it.data(), port_m, FCOORD(1.0f, 0.0f),
block_it.data()->block->pdblk.bounding_box().left(),
!(BOOL8)textord_test_landscape);
!textord_test_landscape);
}
return port_m; // global skew
}
@ -1144,7 +1144,7 @@ void adjust_row_limits( //tidy limits
tesseract::CCStruct::kAscenderFraction);
ymin = -size * tesseract::CCStruct::kDescenderFraction;
row->set_limits (row->intercept () + ymin, row->intercept () + ymax);
row->merged = FALSE;
row->merged = false;
}
}

6
src/textord/oldbasel.cpp
View File

@ -280,7 +280,7 @@ int Textord::correlate_with_stats(TO_ROW **rows, // rows of block.
mindescheight = -lineheight * MIN_DESC_FRACTION;
for (rowindex = 0; rowindex < rowcount; rowindex++) {
row = rows[rowindex]; /*do each row */
row->all_caps = FALSE;
row->all_caps = false;
if (row->ascrise / row->xheight < MIN_ASC_FRACTION) {
/*no ascenders */
if (row->xheight >= lineheight * (1 - MAXHEIGHTVARIANCE)
@ -295,14 +295,14 @@ int Textord::correlate_with_stats(TO_ROW **rows, // rows of block.
row->ascrise = row->xheight - lineheight;
/*set to average */
row->xheight = lineheight;
row->all_caps = TRUE;
row->all_caps = true;
}
else {
row->ascrise = (fullheight - lineheight) * row->xheight
/ fullheight;
/*scale it */
row->xheight -= row->ascrise;
row->all_caps = TRUE;
row->all_caps = true;
}
if (row->ascrise < minascheight)
row->ascrise =

62
src/textord/pithsync.cpp
View File

@ -63,7 +63,7 @@ void FPCUTPT::setup( //constructor
sq_sum = offset * offset;
cost = sq_sum;
faked = FALSE;
terminal = FALSE;
terminal = false;
fake_count = 0;
xpos = x;
region_index = 0;
@ -96,18 +96,18 @@ void FPCUTPT::setup( //constructor
**********************************************************************/
void FPCUTPT::assign( //constructor
FPCUTPT *cutpts, //predecessors
int16_t array_origin, //start coord
int16_t x, //position
BOOL8 faking, //faking this one
BOOL8 mid_cut, //cheap cut.
int16_t offset, //dist to gap
STATS *projection, //vertical occupation
float projection_scale, //scaling
int16_t zero_count, //official zero
int16_t pitch, //proposed pitch
int16_t pitch_error //allowed tolerance
) {
FPCUTPT* cutpts, //predecessors
int16_t array_origin, //start coord
int16_t x, //position
bool faking, //faking this one
bool mid_cut, //cheap cut.
int16_t offset, //dist to gap
STATS* projection, //vertical occupation
float projection_scale, //scaling
int16_t zero_count, //official zero
int16_t pitch, //proposed pitch
int16_t pitch_error //allowed tolerance
) {
int index; //test index
int balance_index; //for balance factor
int16_t balance_count; //ding factor
@ -140,7 +140,7 @@ void FPCUTPT::assign( //constructor
cost = MAX_FLOAT32;
pred = nullptr;
faked = faking;
terminal = FALSE;
terminal = false;
region_index = 0;
fake_count = INT16_MAX;
for (index = x - pitch - pitch_error; index <= x - pitch + pitch_error;
@ -247,7 +247,7 @@ void FPCUTPT::assign_cheap( //constructor
cost = MAX_FLOAT32;
pred = nullptr;
faked = faking;
terminal = FALSE;
terminal = false;
region_index = 0;
fake_count = INT16_MAX;
index = x - pitch;
@ -309,8 +309,8 @@ double check_pitch_sync2( //find segmentation
int16_t start, //start of good range
int16_t end //end of good range
) {
BOOL8 faking; //illegal cut pt
BOOL8 mid_cut; //cheap cut pt.
bool faking; //illegal cut pt
bool mid_cut; //cheap cut pt.
int16_t x; //current coord
int16_t blob_index; //blob number
int16_t left_edge; //of word
@ -383,8 +383,8 @@ double check_pitch_sync2( //find segmentation
next_box = box_next (&this_it);
blob_index++;
}
faking = FALSE;
mid_cut = FALSE;
faking = false;
mid_cut = false;
if (x <= this_box.left ())
offset = 0;
else if (x <= this_box.left () + pitch_error)
@ -400,11 +400,11 @@ double check_pitch_sync2( //find segmentation
offset = this_box.right () - x;
else if (x - this_box.left () > pitch * pitsync_joined_edge
&& this_box.right () - x > pitch * pitsync_joined_edge) {
mid_cut = TRUE;
mid_cut = true;
offset = 0;
}
else {
faking = TRUE;
faking = true;
offset = projection->pile_count (x);
}
cutpts[x - array_origin].assign (cutpts, array_origin, x,
@ -420,10 +420,10 @@ double check_pitch_sync2( //find segmentation
while (x < right_edge + pitch) {
offset = x < right_edge ? right_edge - x : 0;
cutpts[x - array_origin].assign (cutpts, array_origin, x,
FALSE, FALSE, offset, projection,
false, false, offset, projection,
projection_scale, zero_count, pitch,
pitch_error);
cutpts[x - array_origin].terminal = TRUE;
cutpts[x - array_origin].terminal = true;
if (cutpts[x - array_origin].index () +
cutpts[x - array_origin].fake_count <= best_count + best_fake) {
if (cutpts[x - array_origin].fake_count < best_fake
@ -505,8 +505,8 @@ double check_pitch_sync3( //find segmentation
int16_t start, //start of good range
int16_t end //end of good range
) {
BOOL8 faking; //illegal cut pt
BOOL8 mid_cut; //cheap cut pt.
bool faking; //illegal cut pt
bool mid_cut; //cheap cut pt.
int16_t left_edge; //of word
int16_t right_edge; //of word
int16_t x; //current coord
@ -570,8 +570,8 @@ double check_pitch_sync3( //find segmentation
minindex++;
if (minindex > pitch_error * 2)
minindex = 0;
faking = FALSE;
mid_cut = FALSE;
faking = false;
mid_cut = false;
offset = 0;
if (projection->pile_count (x) <= zero_count) {
prev_zero = x;
@ -599,14 +599,14 @@ double check_pitch_sync3( //find segmentation
}
if (offset > pitch_error) {
offset = projection->pile_count (x);
faking = TRUE;
faking = true;
}
else {
projection_offset =
(int16_t) (projection->pile_count (x) / projection_scale);
if (projection_offset > offset)
offset = projection_offset;
mid_cut = TRUE;
mid_cut = true;
}
}
if ((start == 0 && end == 0)
@ -635,10 +635,10 @@ double check_pitch_sync3( //find segmentation
while (x < right_edge + pitch) {
offset = x < right_edge ? right_edge - x : 0;
cutpts[x - array_origin].assign (cutpts, array_origin, x,
FALSE, FALSE, offset, projection,
false, false, offset, projection,
projection_scale, zero_count, pitch,
pitch_error);
cutpts[x - array_origin].terminal = TRUE;
cutpts[x - array_origin].terminal = true;
if (cutpts[x - array_origin].index () +
cutpts[x - array_origin].fake_count <= best_count + best_fake) {
if (cutpts[x - array_origin].fake_count < best_fake

28
src/textord/pithsync.h
View File

@ -40,18 +40,18 @@ class FPCUTPT
int16_t x, //position
int16_t offset); //dist to gap
void assign ( //evaluate cut
FPCUTPT cutpts[], //predecessors
int16_t array_origin, //start coord
int16_t x, //position
BOOL8 faking, //faking this one
BOOL8 mid_cut, //doing free cut
int16_t offset, //extra cost dist
STATS * projection, //occupation
float projection_scale, //scaling
int16_t zero_count, //official zero
int16_t pitch, //proposed pitch
int16_t pitch_error); //allowed tolerance
void assign( //evaluate cut
FPCUTPT cutpts[], //predecessors
int16_t array_origin, //start coord
int16_t x, //position
bool faking, //faking this one
bool mid_cut, //doing free cut
int16_t offset, //extra cost dist
STATS* projection, //occupation
float projection_scale, //scaling
int16_t zero_count, //official zero
int16_t pitch, //proposed pitch
int16_t pitch_error); //allowed tolerance
void assign_cheap ( //evaluate cut
FPCUTPT cutpts[], //predecessors
@ -88,8 +88,8 @@ class FPCUTPT
return region_index;
}
BOOL8 faked; //faked split point
BOOL8 terminal; //successful end
bool faked; //faked split point
bool terminal; //successful end
int16_t fake_count; //total fakes to here
private: