mirror/tesseract
1
0
Fork 0
mirror of https://github.com/tesseract-ocr/tesseract.git synced 2025-06-07 18:02:40 +08:00
Code Issues Actions 10 Packages Projects Releases Wiki Activity

Result of clang tidy on recent merge

Browse Source
This commit is contained in:
Ray Smith 2016-11-07 10:46:33 -08:00
parent 8972c0e916
commit 2c837dffc3
139 changed files with 2488 additions and 2947 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
COPYING
View File

@ -17,5 +17,5 @@ in this distribution is now licensed under the Apache License:
Other Dependencies and Licenses:
================================
Tesseract uses Leptonica library (http://leptonica.com/) with a very weakly
restricted copyright license (http://leptonica.com/about-the-license.html)
Tesseract uses Leptonica library (http://leptonica.com/) which essentially
uses a BSD 2-clause license. (http://leptonica.com/about-the-license.html)

5
android/jni/Android.mk
View File

@ -4,7 +4,7 @@ include $(CLEAR_VARS)
LOCAL_MODULE := tesseract-$(APP_ABI)
LOCAL_STATIC_LIBRARIES := \
mobile_base \
base \
leptonica-$(APP_ABI)
LOCAL_C_INCLUDES := $(APP_C_INCLUDES)
@ -51,7 +51,6 @@ LOCAL_CFLAGS := -DANDROID_BUILD -DNO_CUBE_BUILD -DGRAPHICS_DISABLED
include $(BUILD_SHARED_LIBRARY)
$(call import-module,mobile/base)
$(call import-module,mobile/base)
$(call import-module,base/port)
$(call import-module,mobile/util/hash)
$(call import-module,third_party/leptonica/android/jni)

76
api/baseapi.cpp
View File

@ -809,9 +809,7 @@ int CubeAPITest(Boxa* boxa_blocks, Pixa* pixa_blocks,
* has not been subjected to a call of Init, SetImage, Recognize, Clear, End
* DetectOS, or anything else that changes the internal PAGE_RES.
*/
PageIterator* TessBaseAPI::AnalyseLayout() {
return AnalyseLayout(false);
}
PageIterator* TessBaseAPI::AnalyseLayout() { return AnalyseLayout(false); }
PageIterator* TessBaseAPI::AnalyseLayout(bool merge_similar_words) {
if (FindLines() == 0) {
@ -1379,8 +1377,9 @@ static void AddBaselineCoordsTohOCR(const PageIterator *it,
hocr_str->add_str_double(" ", round(p0 * 1000.0) / 1000.0);
}
static void AddIdTohOCR(STRING* hocr_str, const std::string base, int num1, int num2) {
const unsigned long BUFSIZE = 64;
static void AddIdTohOCR(STRING* hocr_str, const std::string base, int num1,
int num2) {
const size_t BUFSIZE = 64;
char id_buffer[BUFSIZE];
if (num2 >= 0) {
snprintf(id_buffer, BUFSIZE - 1, "%s_%d_%d", base.c_str(), num1, num2);
@ -1393,8 +1392,7 @@ static void AddIdTohOCR(STRING* hocr_str, const std::string base, int num1, int
*hocr_str += "'";
}
static void AddBoxTohOCR(const ResultIterator *it,
PageIteratorLevel level,
static void AddBoxTohOCR(const ResultIterator* it, PageIteratorLevel level,
STRING* hocr_str) {
int left, top, right, bottom;
it->BoundingBox(level, &left, &top, &right, &bottom);
@ -1410,7 +1408,7 @@ static void AddBoxTohOCR(const ResultIterator *it,
// add custom height measures
float row_height, descenders, ascenders; // row attributes
it->RowAttributes(&row_height, &descenders, &ascenders);
// TODO: Do we want to limit these to a single decimal place?
// TODO(rays): Do we want to limit these to a single decimal place?
hocr_str->add_str_double("; x_size ", row_height);
hocr_str->add_str_double("; x_descenders ", descenders * -1);
hocr_str->add_str_double("; x_ascenders ", ascenders);
@ -1418,8 +1416,7 @@ static void AddBoxTohOCR(const ResultIterator *it,
*hocr_str += "\">";
}
static void AddBoxToTSV(const PageIterator *it,
PageIteratorLevel level,
static void AddBoxToTSV(const PageIterator* it, PageIteratorLevel level,
STRING* hocr_str) {
int left, top, right, bottom;
it->BoundingBox(level, &left, &top, &right, &bottom);
@ -1429,8 +1426,6 @@ static void AddBoxToTSV(const PageIterator *it,
hocr_str->add_str_int("\t", bottom - top);
}
/**
* Make a HTML-formatted string with hOCR markup from the internal
* data structures.
@ -1440,7 +1435,7 @@ static void AddBoxToTSV(const PageIterator *it,
* STL removed from original patch submission and refactored by rays.
*/
char* TessBaseAPI::GetHOCRText(int page_number) {
return GetHOCRText(NULL,page_number);
return GetHOCRText(NULL, page_number);
}
/**
@ -1452,8 +1447,7 @@ char* TessBaseAPI::GetHOCRText(int page_number) {
* STL removed from original patch submission and refactored by rays.
*/
char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
if (tesseract_ == NULL ||
(page_res_ == NULL && Recognize(monitor) < 0))
if (tesseract_ == NULL || (page_res_ == NULL && Recognize(monitor) < 0))
return NULL;
int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
@ -1470,13 +1464,13 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
#ifdef _WIN32
// convert input name from ANSI encoding to utf-8
int str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1,
NULL, 0);
int str16_len =
MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1, NULL, 0);
wchar_t *uni16_str = new WCHAR[str16_len];
str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1,
uni16_str, str16_len);
int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, NULL,
0, NULL, NULL);
int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, NULL, 0,
NULL, NULL);
char *utf8_str = new char[utf8_len];
WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, utf8_str,
utf8_len, NULL, NULL);
@ -1567,8 +1561,12 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
}
switch (res_it->WordDirection()) {
// Only emit direction if different from current paragraph direction
case DIR_LEFT_TO_RIGHT: if (!para_is_ltr) hocr_str += " dir='ltr'"; break;
case DIR_RIGHT_TO_LEFT: if (para_is_ltr) hocr_str += " dir='rtl'"; break;
case DIR_LEFT_TO_RIGHT:
if (!para_is_ltr) hocr_str += " dir='ltr'";
break;
case DIR_RIGHT_TO_LEFT:
if (para_is_ltr) hocr_str += " dir='rtl'";
break;
case DIR_MIX:
case DIR_NEUTRAL:
default: // Do nothing.
@ -1620,8 +1618,7 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
* page_number is 0-based but will appear in the output as 1-based.
*/
char* TessBaseAPI::GetTSVText(int page_number) {
if (tesseract_ == NULL ||
(page_res_ == NULL && Recognize(NULL) < 0))
if (tesseract_ == NULL || (page_res_ == NULL && Recognize(NULL) < 0))
return NULL;
int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
@ -1629,7 +1626,8 @@ char* TessBaseAPI::GetTSVText(int page_number) {
STRING tsv_str("");
int page_num = page_id, block_num = 0, par_num = 0, line_num = 0, word_num = 0;
int page_num = page_id, block_num = 0, par_num = 0, line_num = 0,
word_num = 0;
tsv_str.add_str_int("1\t", page_num); // level 1 - page
tsv_str.add_str_int("\t", block_num);
@ -1642,7 +1640,7 @@ char* TessBaseAPI::GetTSVText(int page_number) {
tsv_str.add_str_int("\t", rect_height_);
tsv_str += "\t-1\t\n";
ResultIterator *res_it = GetIterator();
ResultIterator* res_it = GetIterator();
while (!res_it->Empty(RIL_BLOCK)) {
if (res_it->Empty(RIL_WORD)) {
res_it->Next(RIL_WORD);
@ -1685,11 +1683,11 @@ char* TessBaseAPI::GetTSVText(int page_number) {
int left, top, right, bottom;
bool bold, italic, underlined, monospace, serif, smallcaps;
int pointsize, font_id;
const char *font_name;
const char* font_name;
res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
font_name = res_it->WordFontAttributes(&bold, &italic, &underlined,
&monospace, &serif, &smallcaps,
&pointsize, &font_id);
font_name =
res_it->WordFontAttributes(&bold, &italic, &underlined, &monospace,
&serif, &smallcaps, &pointsize, &font_id);
word_num++;
tsv_str.add_str_int("5\t", page_num); // level 5 - word
tsv_str.add_str_int("\t", block_num);
@ -1716,7 +1714,7 @@ char* TessBaseAPI::GetTSVText(int page_number) {
wcnt++;
}
char *ret = new char[tsv_str.length() + 1];
char* ret = new char[tsv_str.length() + 1];
strcpy(ret, tsv_str.string());
delete res_it;
return ret;
@ -1760,7 +1758,7 @@ char* TessBaseAPI::GetBoxText(int page_number) {
int total_length = blob_count * kBytesPerBoxFileLine + utf8_length +
kMaxBytesPerLine;
char* result = new char[total_length];
strcpy(result, "\0");
result[0] = '\0';
int output_length = 0;
LTRResultIterator* it = GetLTRIterator();
do {
@ -1907,7 +1905,7 @@ char* TessBaseAPI::GetUNLVText() {
return result;
}
/**
/**
* The recognized text is returned as a char* which is coded
* as UTF8 and must be freed with the delete [] operator.
* page_number is a 0-based page index that will appear in the osd file.
@ -1933,17 +1931,17 @@ char* TessBaseAPI::GetOsdText(int page_number) {
// clockwise rotation needed to make the page upright
int rotate = OrientationIdToValue(orient_id);
char* osd_buf = new char[255];
snprintf(osd_buf, 255,
const int kOsdBufsize = 255;
char* osd_buf = new char[kOsdBufsize];
snprintf(osd_buf, kOsdBufsize,
"Page number: %d\n"
"Orientation in degrees: %d\n"
"Rotate: %d\n"
"Orientation confidence: %.2f\n"
"Script: %s\n"
"Script confidence: %.2f\n",
page_number,
orient_deg, rotate, orient_conf,
script_name, script_conf);
page_number, orient_deg, rotate, orient_conf, script_name,
script_conf);
return osd_buf;
}
@ -2063,7 +2061,7 @@ void TessBaseAPI::Clear() {
if (thresholder_ != NULL)
thresholder_->Clear();
ClearResults();
SetInputImage(NULL);
if (tesseract_ != NULL) SetInputImage(NULL);
}
/**
@ -2767,7 +2765,7 @@ void TessBaseAPI::GetFeaturesForBlob(TBLOB* blob,
INT_FX_RESULT_STRUCT fx_info;
tesseract_->ExtractFeatures(*blob, false, &bl_features,
&cn_features, &fx_info, &outline_counts);
if (cn_features.size() == 0 || cn_features.size() > MAX_NUM_INT_FEATURES) {
if (cn_features.empty() || cn_features.size() > MAX_NUM_INT_FEATURES) {
*num_features = 0;
return; // Feature extraction failed.
}

10
api/baseapi.h
View File

@ -750,13 +750,9 @@ class TESS_API TessBaseAPI {
*/
static void NormalizeTBLOB(TBLOB *tblob, ROW *row, bool numeric_mode);
Tesseract* tesseract() const {
return tesseract_;
}
Tesseract* tesseract() const { return tesseract_; }
OcrEngineMode oem() const {
return last_oem_requested_;
}
OcrEngineMode oem() const { return last_oem_requested_; }
void InitTruthCallback(TruthCallback *cb) { truth_cb_ = cb; }
@ -898,7 +894,7 @@ class TESS_API TessBaseAPI {
const char* retry_config, int timeout_millisec,
TessResultRenderer* renderer,
int tessedit_page_number);
// TIFF supports multipage so gets special consideration
// TIFF supports multipage so gets special consideration.
bool ProcessPagesMultipageTiff(const unsigned char *data,
size_t size,
const char* filename,

7
api/pdfrenderer.cpp
View File

@ -20,12 +20,12 @@
#include "config_auto.h"
#endif
#include "allheaders.h"
#include "baseapi.h"
#include "renderer.h"
#include "math.h"
#include "renderer.h"
#include "strngs.h"
#include "tprintf.h"
#include "allheaders.h"
#ifdef _MSC_VER
#include "mathfix.h"
@ -567,7 +567,8 @@ bool TessPDFRenderer::BeginDocumentHandler() {
"<<\n"
" /Length %lu /Filter /FlateDecode\n"
">>\n"
"stream\n", (unsigned long)len);
"stream\n",
(unsigned long)len);
if (n >= sizeof(buf)) {
lept_free(comp);
return false;

15
api/renderer.cpp
View File

@ -198,25 +198,25 @@ bool TessHOcrRenderer::AddImageHandler(TessBaseAPI* api) {
/**********************************************************************
* TSV Text Renderer interface implementation
**********************************************************************/
TessTsvRenderer::TessTsvRenderer(const char *outputbase)
TessTsvRenderer::TessTsvRenderer(const char* outputbase)
: TessResultRenderer(outputbase, "tsv") {
font_info_ = false;
}
TessTsvRenderer::TessTsvRenderer(const char *outputbase, bool font_info)
TessTsvRenderer::TessTsvRenderer(const char* outputbase, bool font_info)
: TessResultRenderer(outputbase, "tsv") {
font_info_ = font_info;
}
bool TessTsvRenderer::BeginDocumentHandler() {
// Output TSV column headings
AppendString("level\tpage_num\tblock_num\tpar_num\tline_num\tword_num\tleft\ttop\twidth\theight\tconf\ttext\n");
AppendString(
"level\tpage_num\tblock_num\tpar_num\tline_num\tword_"
"num\tleft\ttop\twidth\theight\tconf\ttext\n");
return true;
}
bool TessTsvRenderer::EndDocumentHandler() {
return true;
}
bool TessTsvRenderer::EndDocumentHandler() { return true; }
bool TessTsvRenderer::AddImageHandler(TessBaseAPI* api) {
char* tsv = api->GetTSVText(imagenum());
@ -266,8 +266,7 @@ bool TessBoxTextRenderer::AddImageHandler(TessBaseAPI* api) {
* Osd Text Renderer interface implementation
**********************************************************************/
TessOsdRenderer::TessOsdRenderer(const char* outputbase)
: TessResultRenderer(outputbase, "osd") {
}
: TessResultRenderer(outputbase, "osd") {}
bool TessOsdRenderer::AddImageHandler(TessBaseAPI* api) {
char* osd = api->GetOsdText(imagenum());

16
api/renderer.h
View File

@ -153,12 +153,12 @@ class TESS_API TessHOcrRenderer : public TessResultRenderer {
explicit TessHOcrRenderer(const char *outputbase, bool font_info);
explicit TessHOcrRenderer(const char *outputbase);
protected:
protected:
virtual bool BeginDocumentHandler();
virtual bool AddImageHandler(TessBaseAPI* api);
virtual bool EndDocumentHandler();
private:
private:
bool font_info_; // whether to print font information
};
@ -167,15 +167,15 @@ private:
*/
class TESS_API TessTsvRenderer : public TessResultRenderer {
public:
explicit TessTsvRenderer(const char *outputbase, bool font_info);
explicit TessTsvRenderer(const char *outputbase);
explicit TessTsvRenderer(const char* outputbase, bool font_info);
explicit TessTsvRenderer(const char* outputbase);
protected:
protected:
virtual bool BeginDocumentHandler();
virtual bool AddImageHandler(TessBaseAPI* api);
virtual bool EndDocumentHandler();
private:
private:
bool font_info_; // whether to print font information
};
@ -188,12 +188,12 @@ class TESS_API TessPDFRenderer : public TessResultRenderer {
// we load a custom PDF font from this location.
TessPDFRenderer(const char *outputbase, const char *datadir);
protected:
protected:
virtual bool BeginDocumentHandler();
virtual bool AddImageHandler(TessBaseAPI* api);
virtual bool EndDocumentHandler();
private:
private:
// We don't want to have every image in memory at once,
// so we store some metadata as we go along producing
// PDFs one page at a time. At the end that metadata is

72
api/tesseractmain.cpp
View File

@ -51,7 +51,7 @@ static void Win32WarningHandler(const char* module, const char* fmt,
#endif /* HAVE_TIFFIO_H && _WIN32 */
void PrintVersionInfo() {
char *versionStrP;
char* versionStrP;
printf("tesseract %s\n", tesseract::TessBaseAPI::Version());
@ -82,7 +82,7 @@ void PrintVersionInfo() {
printf(" Found %d devices.\n", num_devices);
for (i = 0; i < num_devices; ++i) {
clGetDeviceInfo(devices[i], CL_DEVICE_NAME, 256, info, 0);
printf(" Device %d name: %s.\n", i+1, info);
printf(" Device %d name: %s.\n", i + 1, info);
}
#endif
}
@ -111,16 +111,11 @@ void PrintHelpForPSM() {
" 8 Treat the image as a single word.\n"
" 9 Treat the image as a single word in a circle.\n"
" 10 Treat the image as a single character.\n"
//TODO: Consider publishing these modes.
#if 0
" 11 Sparse text. Find as much text as possible in no"
" particular order.\n"
" 12 Sparse text with OSD.\n"
" 13 Raw line. Treat the image as a single text line,\n"
"\t\t\tbypassing hacks that are Tesseract-specific.\n"
#endif
;
"\t\t\tbypassing hacks that are Tesseract-specific.\n";
printf("%s", msg);
}
@ -137,31 +132,30 @@ void PrintHelpMessage(const char* program) {
" -c VAR=VALUE Set value for config variables.\n"
" Multiple -c arguments are allowed.\n"
" -psm NUM Specify page segmentation mode.\n"
"NOTE: These options must occur before any configfile.\n"
;
"NOTE: These options must occur before any configfile.\n";
printf("\n%s\n", ocr_options);
PrintHelpForPSM();
const char *single_options =
const char* single_options =
"Single options:\n"
" -h, --help Show this help message.\n"
" --help-psm Show page segmentation modes.\n"
" -v, --version Show version information.\n"
" --list-langs List available languages for tesseract engine.\n"
" --print-parameters Print tesseract parameters to stdout.\n"
;
" --print-parameters Print tesseract parameters to stdout.\n";
printf("\n%s", single_options);
}
void SetVariablesFromCLArgs(tesseract::TessBaseAPI* api, int argc, char** argv) {
void SetVariablesFromCLArgs(tesseract::TessBaseAPI* api, int argc,
char** argv) {
char opt1[256], opt2[255];
for (int i = 0; i < argc; i++) {
if (strcmp(argv[i], "-c") == 0 && i + 1 < argc) {
strncpy(opt1, argv[i + 1], 255);
opt1[255] = '\0';
char *p = strchr(opt1, '=');
char* p = strchr(opt1, '=');
if (!p) {
fprintf(stderr, "Missing = in configvar assignment\n");
exit(1);
@ -215,16 +209,11 @@ void FixPageSegMode(tesseract::TessBaseAPI* api,
}
// NOTE: arg_i is used here to avoid ugly *i so many times in this function
void ParseArgs(const int argc, char** argv,
const char** lang,
const char** image,
const char** outputbase,
const char** datapath,
bool* list_langs,
bool* print_parameters,
void ParseArgs(const int argc, char** argv, const char** lang,
const char** image, const char** outputbase,
const char** datapath, bool* list_langs, bool* print_parameters,
GenericVector<STRING>* vars_vec,
GenericVector<STRING>* vars_values,
int* arg_i,
GenericVector<STRING>* vars_values, int* arg_i,
tesseract::PageSegMode* pagesegmode) {
if (argc == 1) {
PrintHelpMessage(argv[0]);
@ -232,8 +221,7 @@ void ParseArgs(const int argc, char** argv,
}
if (argc == 2) {
if ((strcmp(argv[1], "-h") == 0) ||
(strcmp(argv[1], "--help") == 0)) {
if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
PrintHelpMessage(argv[0]);
exit(0);
}
@ -241,8 +229,7 @@ void ParseArgs(const int argc, char** argv,
PrintHelpForPSM();
exit(0);
}
if ((strcmp(argv[1], "-v") == 0) ||
(strcmp(argv[1], "--version") == 0)) {
if ((strcmp(argv[1], "-v") == 0) || (strcmp(argv[1], "--version") == 0)) {
PrintVersionInfo();
exit(0);
}
@ -298,10 +285,10 @@ void ParseArgs(const int argc, char** argv,
}
}
void PreloadRenderers(tesseract::TessBaseAPI* api,
void PreloadRenderers(
tesseract::TessBaseAPI* api,
tesseract::PointerVector<tesseract::TessResultRenderer>* renderers,
tesseract::PageSegMode pagesegmode,
const char* outputbase) {
tesseract::PageSegMode pagesegmode, const char* outputbase) {
if (pagesegmode == tesseract::PSM_OSD_ONLY) {
renderers->push_back(new tesseract::TessOsdRenderer(outputbase));
} else {
@ -324,8 +311,8 @@ void PreloadRenderers(tesseract::TessBaseAPI* api,
api->GetBoolVariable("tessedit_create_pdf", &b);
if (b) {
renderers->push_back(new tesseract::TessPDFRenderer(outputbase,
api->GetDatapath()));
renderers->push_back(
new tesseract::TessPDFRenderer(outputbase, api->GetDatapath()));
}
api->GetBoolVariable("tessedit_write_unlv", &b);
@ -359,8 +346,7 @@ void PreloadRenderers(tesseract::TessBaseAPI* api,
*
**********************************************************************/
int main(int argc, char **argv) {
int main(int argc, char** argv) {
const char* lang = "eng";
const char* image = NULL;
const char* outputbase = NULL;
@ -380,10 +366,8 @@ int main(int argc, char **argv) {
TIFFSetWarningHandler(Win32WarningHandler);
#endif /* HAVE_TIFFIO_H && _WIN32 */
ParseArgs(argc, argv,
&lang, &image, &outputbase, &datapath,
&list_langs, &print_parameters,
&vars_vec, &vars_values, &arg_i, &pagesegmode);
ParseArgs(argc, argv, &lang, &image, &outputbase, &datapath, &list_langs,
&print_parameters, &vars_vec, &vars_values, &arg_i, &pagesegmode);
bool banner = false;
if (outputbase != NULL && strcmp(outputbase, "-") &&
@ -396,8 +380,9 @@ int main(int argc, char **argv) {
api.SetOutputName(outputbase);
int init_failed = api.Init(datapath, lang, tesseract::OEM_DEFAULT,
&(argv[arg_i]), argc - arg_i, &vars_vec, &vars_values, false);
int init_failed =
api.Init(datapath, lang, tesseract::OEM_DEFAULT, &(argv[arg_i]),
argc - arg_i, &vars_vec, &vars_values, false);
if (init_failed) {
fprintf(stderr, "Could not initialize tesseract.\n");
exit(1);
@ -439,7 +424,8 @@ int main(int argc, char **argv) {
tesseract::PageIterator* it = api.AnalyseLayout();
if (it) {
it->Orientation(&orientation, &direction, &order, &deskew_angle);
tprintf("Orientation: %d\nWritingDirection: %d\nTextlineOrder: %d\n" \
tprintf(
"Orientation: %d\nWritingDirection: %d\nTextlineOrder: %d\n"
"Deskew angle: %.4f\n",
orientation, direction, order, deskew_angle);
} else {
@ -462,8 +448,6 @@ int main(int argc, char **argv) {
tesseract::PointerVector<tesseract::TessResultRenderer> renderers;
if (in_training_mode) {
renderers.push_back(NULL);
} else {

3
ccmain/control.cpp
View File

@ -73,7 +73,6 @@ void Tesseract::recog_pseudo_word(PAGE_RES* page_res,
}
}
/**
* Recognize a single word in interactive mode.
*
@ -539,7 +538,7 @@ void Tesseract::bigram_correction_pass(PAGE_RES *page_res) {
}
}
}
if (overrides_word1.size() >= 1) {
if (!overrides_word1.empty()) {
// Excellent, we have some bigram matches.
if (EqualIgnoringCaseAndTerminalPunct(*w_prev->best_choice,
*overrides_word1[best_idx]) &&

8
ccmain/docqual.cpp
View File

@ -98,8 +98,8 @@ void Tesseract::word_char_quality(WERD_RES *word,
ROW *row,
inT16 *match_count,
inT16 *accepted_match_count) {
if (word->bln_boxes == NULL ||
word->rebuild_word == NULL || word->rebuild_word->blobs.empty()) {
if (word->bln_boxes == NULL || word->rebuild_word == NULL ||
word->rebuild_word->blobs.empty()) {
*match_count = 0;
*accepted_match_count = 0;
return;
@ -132,7 +132,7 @@ inT16 Tesseract::count_outline_errs(char c, inT16 outline_count) {
int expected_outline_count;
if (STRING (outlines_odd).contains (c))
return 0; //Don't use this char
return 0; // Don't use this char
else if (STRING (outlines_2).contains (c))
expected_outline_count = 2;
else
@ -151,7 +151,6 @@ void Tesseract::quality_based_rejection(PAGE_RES_IT &page_res_it,
}
}
/*************************************************************************
* unrej_good_quality_words()
* Accept potential rejects in words which pass the following checks:
@ -403,7 +402,6 @@ void Tesseract::doc_and_block_rejection( //reject big chunks
} // namespace tesseract
/*************************************************************************
* reject_whole_page()
* Don't believe any of it - set the reject map to 00..00 in all words

1
ccmain/fixspace.cpp
View File

@ -211,7 +211,6 @@ void Tesseract::match_current_words(WERD_RES_LIST &words, ROW *row,
}
}
/**
* @name eval_word_spacing()
* The basic measure is the number of characters in contextually confirmed

7
ccmain/ltrresultiterator.cpp
View File

@ -145,11 +145,10 @@ float LTRResultIterator::Confidence(PageIteratorLevel level) const {
return 0.0f;
}
void LTRResultIterator::RowAttributes(float* row_height,
float* descenders,
void LTRResultIterator::RowAttributes(float* row_height, float* descenders,
float* ascenders) const {
*row_height = it_->row()->row->x_height() + it_->row()-> row->ascenders()
- it_->row()->row->descenders();
*row_height = it_->row()->row->x_height() + it_->row()->row->ascenders() -
it_->row()->row->descenders();
*descenders = it_->row()->row->descenders();
*ascenders = it_->row()->row->ascenders();
}

3
ccmain/ltrresultiterator.h
View File

@ -92,8 +92,7 @@ class TESS_API LTRResultIterator : public PageIterator {
float Confidence(PageIteratorLevel level) const;
// Returns the attributes of the current row.
void RowAttributes(float* row_height,
float* descenders,
void RowAttributes(float* row_height, float* descenders,
float* ascenders) const;
// ============= Functions that refer to words only ============.

18
ccmain/output.cpp
View File

@ -78,17 +78,15 @@ void Tesseract::output_pass( //Tess output pass //send to api
while (page_res_it.word () != NULL) {
check_debug_pt (page_res_it.word (), 120);
if (target_word_box)
{
TBOX current_word_box=page_res_it.word ()->word->bounding_box();
FCOORD center_pt((current_word_box.right()+current_word_box.left())/2,(current_word_box.bottom()+current_word_box.top())/2);
if (!target_word_box->contains(center_pt))
{
page_res_it.forward ();
if (target_word_box) {
TBOX current_word_box = page_res_it.word()->word->bounding_box();
FCOORD center_pt(
(current_word_box.right() + current_word_box.left()) / 2,
(current_word_box.bottom() + current_word_box.top()) / 2);
if (!target_word_box->contains(center_pt)) {
page_res_it.forward();
continue;
}
}
if (tessedit_write_block_separators &&
block_of_last_word != page_res_it.block ()) {
@ -337,7 +335,7 @@ void Tesseract::set_unlv_suspects(WERD_RES *word_res) {
rating_per_ch = word.rating() / word_res->reject_map.length();
if (rating_per_ch >= suspect_rating_per_ch)
return; //Don't touch bad ratings
return; // Don't touch bad ratings
if ((word_res->tess_accepted) || (rating_per_ch < suspect_accept_rating)) {
/* Unreject any Tess Acceptable word - but NOT tess reject chs*/

3
ccmain/pagesegmain.cpp
View File

@ -412,7 +412,8 @@ ColumnFinder* Tesseract::SetupPageSegAndDetectOrientation(
"Don't rotate.\n", osd_margin);
osd_orientation = 0;
} else {
tprintf("OSD: Weak margin (%.2f) for %d blob text block, "
tprintf(
"OSD: Weak margin (%.2f) for %d blob text block, "
"but using orientation anyway: %d\n",
osd_margin, osd_blobs.length(), osd_orientation);
}

12
ccmain/paragraphs.cpp
View File

@ -2052,7 +2052,7 @@ void ConvertHypothesizedModelRunsToParagraphs(
bool single_line_paragraph = false;
SetOfModels models;
rows[start].NonNullHypotheses(&models);
if (models.size() > 0) {
if (!models.empty()) {
model = models[0];
if (rows[start].GetLineType(model) != LT_BODY)
single_line_paragraph = true;
@ -2190,17 +2190,17 @@ void LeftoverSegments(const GenericVector<RowScratchRegisters> &rows,
SetOfModels models_w_crowns;
rows[i].StrongHypotheses(&models);
rows[i].NonNullHypotheses(&models_w_crowns);
if (models.empty() && models_w_crowns.size() > 0) {
if (models.empty() && !models_w_crowns.empty()) {
// Crown paragraph. Is it followed by a modeled line?
for (int end = i + 1; end < rows.size(); end++) {
SetOfModels end_models;
SetOfModels strong_end_models;
rows[end].NonNullHypotheses(&end_models);
rows[end].StrongHypotheses(&strong_end_models);
if (end_models.size() == 0) {
if (end_models.empty()) {
needs_fixing = true;
break;
} else if (strong_end_models.size() > 0) {
} else if (!strong_end_models.empty()) {
needs_fixing = false;
break;
}
@ -2485,7 +2485,7 @@ void InitializeRowInfo(bool after_recognition,
info->ltr = ltr >= rtl;
info->has_leaders = num_leaders > 3;
info->num_words = werds.size();
if (werds.size() > 0) {
if (!werds.empty()) {
WERD_RES *lword = werds[0], *rword = werds[werds.size() - 1];
info->lword_text = lword->best_choice->unichar_string().string();
info->rword_text = rword->best_choice->unichar_string().string();
@ -2538,7 +2538,7 @@ void DetectParagraphs(int debug_level,
// If we're called before text recognition, we might not have
// tight block bounding boxes, so trim by the minimum on each side.
if (row_infos.size() > 0) {
if (!row_infos.empty()) {
int min_lmargin = row_infos[0].pix_ldistance;
int min_rmargin = row_infos[0].pix_rdistance;
for (int i = 1; i < row_infos.size(); i++) {

10
ccmain/paramsd.cpp
View File

@ -329,13 +329,19 @@ void ParamsEditor::WriteParams(char *filename,
fclose(fp);
sprintf (msg_str, "Overwrite file " "%s" "? (Y/N)", filename);
int a = sv_window_->ShowYesNoDialog(msg_str);
if (a == 'n') { return; } // don't write
if (a == 'n') {
return;
} // don't write
}
fp = fopen (filename, "wb"); // can we write to it?
if (fp == NULL) {
sv_window_->AddMessage("Can't write to file " "%s" "", filename);
sv_window_->AddMessage(
"Can't write to file "
"%s"
"",
filename);
return;
}

2
ccmain/tessedit.cpp
View File

@ -44,7 +44,7 @@
#include "params.h"
#define VARDIR "configs/" /*variables files */
//config under api
// config under api
#define API_CONFIG "configs/api_config"
ETEXT_DESC *global_monitor = NULL; // progress monitor

5
ccmain/tesseractclass.cpp
View File

@ -398,8 +398,8 @@ Tesseract::Tesseract()
"Don't suspect dict wds longer than this", this->params()),
BOOL_MEMBER(suspect_constrain_1Il, false, "UNLV keep 1Il chars rejected",
this->params()),
double_MEMBER(suspect_rating_per_ch, 999.9, "Don't touch bad rating limit",
this->params()),
double_MEMBER(suspect_rating_per_ch, 999.9,
"Don't touch bad rating limit", this->params()),
double_MEMBER(suspect_accept_rating, -999.9, "Accept good rating limit",
this->params()),
BOOL_MEMBER(tessedit_minimal_rejection, false,
@ -512,7 +512,6 @@ Tesseract::Tesseract()
"Page separator (default is form feed control character)",
this->params()),
// The following parameters were deprecated and removed from their
// original
// locations. The parameters are temporarily kept here to give Tesseract

5
ccmain/tesseractclass.h
View File

@ -38,7 +38,6 @@
class BLOB_CHOICE_LIST_CLIST;
class BLOCK_LIST;
class CharSamp;
struct OSResults;
class PAGE_RES;
class PAGE_RES_IT;
@ -98,6 +97,7 @@ namespace tesseract {
class ColumnFinder;
#ifndef NO_CUBE_BUILD
class CharSamp;
class CubeLineObject;
class CubeObject;
class CubeRecoContext;
@ -1010,8 +1010,7 @@ class Tesseract : public Wordrec {
INT_VAR_H(suspect_level, 99, "Suspect marker level");
INT_VAR_H(suspect_space_level, 100,
"Min suspect level for rejecting spaces");
INT_VAR_H(suspect_short_words, 2,
"Don't Suspect dict wds longer than this");
INT_VAR_H(suspect_short_words, 2, "Don't Suspect dict wds longer than this");
BOOL_VAR_H(suspect_constrain_1Il, false, "UNLV keep 1Il chars rejected");
double_VAR_H(suspect_rating_per_ch, 999.9, "Don't touch bad rating limit");
double_VAR_H(suspect_accept_rating, -999.9, "Accept good rating limit");

6
ccstruct/blobbox.cpp
View File

@ -31,7 +31,9 @@
#define PROJECTION_MARGIN 10 //arbitrary
#define EXTERN
ELISTIZE (BLOBNBOX) ELIST2IZE (TO_ROW) ELISTIZE (TO_BLOCK)
ELISTIZE(BLOBNBOX)
ELIST2IZE(TO_ROW)
ELISTIZE(TO_BLOCK)
// Up to 30 degrees is allowed for rotations of diacritic blobs.
const double kCosSmallAngle = 0.866;
@ -176,7 +178,7 @@ void BLOBNBOX::NeighbourGaps(int gaps[BND_COUNT]) const {
gaps[dir] = MAX_INT16;
BLOBNBOX* neighbour = neighbours_[dir];
if (neighbour != NULL) {
TBOX n_box = neighbour->bounding_box();
const TBOX& n_box = neighbour->bounding_box();
if (dir == BND_LEFT || dir == BND_RIGHT) {
gaps[dir] = box.x_gap(n_box);
} else {

3
ccstruct/boxread.cpp
View File

@ -34,8 +34,7 @@ FILE* OpenBoxFile(const STRING& fname) {
STRING filename = BoxFileName(fname);
FILE* box_file = NULL;
if (!(box_file = fopen(filename.string(), "rb"))) {
CANTOPENFILE.error("read_next_box", TESSEXIT,
"Can't open box file %s",
CANTOPENFILE.error("read_next_box", TESSEXIT, "Can't open box file %s",
filename.string());
}
return box_file;

4
ccstruct/boxword.h
View File

@ -82,9 +82,7 @@ class BoxWord {
const TBOX& bounding_box() const {
return bbox_;
}
int length() const {
return length_;
}
int length() const { return length_; }
const TBOX& BlobBox(int index) const {
return boxes_[index];
}

66
ccstruct/coutln.cpp
View File

@ -48,9 +48,9 @@ ICOORD C_OUTLINE::step_coords[4] = {
* @param length length of loop
*/
C_OUTLINE::C_OUTLINE (CRACKEDGE * startpt, ICOORD bot_left,
ICOORD top_right, inT16 length)
: box (bot_left, top_right), start (startpt->pos), offsets(NULL) {
C_OUTLINE::C_OUTLINE(CRACKEDGE* startpt, ICOORD bot_left, ICOORD top_right,
inT16 length)
: box(bot_left, top_right), start(startpt->pos), offsets(NULL) {
inT16 stepindex; //index to step
CRACKEDGE *edgept; //current point
@ -71,7 +71,6 @@ C_OUTLINE::C_OUTLINE (CRACKEDGE * startpt, ICOORD bot_left,
}
}
/**
* @name C_OUTLINE::C_OUTLINE
*
@ -139,7 +138,7 @@ inT16 length //length of loop
* @param rotation rotate to coord
*/
C_OUTLINE::C_OUTLINE(C_OUTLINE *srcline, FCOORD rotation) : offsets(NULL) {
C_OUTLINE::C_OUTLINE(C_OUTLINE* srcline, FCOORD rotation) : offsets(NULL) {
TBOX new_box; //easy bounding
inT16 stepindex; //index to step
inT16 dirdiff; //direction change
@ -300,7 +299,6 @@ inT32 C_OUTLINE::perimeter() const {
return total_steps;
}
/**
* @name C_OUTLINE::outer_area
*
@ -332,7 +330,6 @@ inT32 C_OUTLINE::outer_area() const {
return total;
}
/**
* @name C_OUTLINE::count_transitions
*
@ -459,7 +456,6 @@ inT32 C_OUTLINE::count_transitions(inT32 threshold) {
return total;
}
/**
* @name C_OUTLINE::operator<
*
@ -468,8 +464,7 @@ inT32 C_OUTLINE::count_transitions(inT32 threshold) {
*/
BOOL8
C_OUTLINE::operator< (const C_OUTLINE & other) const
{
C_OUTLINE::operator<(const C_OUTLINE& other) const {
inT16 count = 0; //winding count
ICOORD pos; //position of point
inT32 stepindex; //index to cstep
@ -495,7 +490,6 @@ C_OUTLINE::operator< (const C_OUTLINE & other) const
return count != 0;
}
/**
* @name C_OUTLINE::winding_number
*
@ -534,7 +528,6 @@ inT16 C_OUTLINE::winding_number(ICOORD point) const {
return count; //winding number
}
/**
* C_OUTLINE::turn_direction
*
@ -563,7 +556,6 @@ inT16 C_OUTLINE::turn_direction() const { //winding number
return count; //winding number
}
/**
* @name C_OUTLINE::reverse
*
@ -586,7 +578,6 @@ void C_OUTLINE::reverse() { //reverse drection
}
}
/**
* @name C_OUTLINE::move
*
@ -661,14 +652,27 @@ static void ComputeGradient(const l_uint32* data, int wpl,
int x, int y, int width, int height,
ICOORD* gradient) {
const l_uint32* line = data + y * wpl;
int pix_x_y = x < width && y < height ?
GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x) : 255;
int pix_x_prevy = x < width && y > 0 ?
GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line - wpl)), x) : 255;
int pix_prevx_prevy = x > 0 && y > 0 ?
GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<void const*>(line - wpl)), x - 1) : 255;
int pix_prevx_y = x > 0 && y < height ?
GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x - 1) : 255;
int pix_x_y =
x < width && y < height
? GET_DATA_BYTE(
const_cast<void*>(reinterpret_cast<const void*>(line)), x)
: 255;
int pix_x_prevy =
x < width && y > 0
? GET_DATA_BYTE(
const_cast<void*>(reinterpret_cast<const void*>(line - wpl)), x)
: 255;
int pix_prevx_prevy =
x > 0 && y > 0
? GET_DATA_BYTE(
const_cast<void*>(reinterpret_cast<void const*>(line - wpl)),
x - 1)
: 255;
int pix_prevx_y =
x > 0 && y < height
? GET_DATA_BYTE(
const_cast<void*>(reinterpret_cast<const void*>(line)), x - 1)
: 255;
gradient->set_x(pix_x_y + pix_x_prevy - (pix_prevx_y + pix_prevx_prevy));
gradient->set_y(pix_x_prevy + pix_prevx_prevy - (pix_x_y + pix_prevx_y));
}
@ -684,8 +688,10 @@ static bool EvaluateVerticalDiff(const l_uint32* data, int wpl, int diff_sign,
if (y <= 0 || y >= height)
return false;
const l_uint32* line = data + y * wpl;
int pixel1 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line - wpl)), x);
int pixel2 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x);
int pixel1 = GET_DATA_BYTE(
const_cast<void*>(reinterpret_cast<const void*>(line - wpl)), x);
int pixel2 =
GET_DATA_BYTE(const_cast<void*>(reinterpret_cast<const void*>(line)), x);
int diff = (pixel2 - pixel1) * diff_sign;
if (diff > *best_diff) {
*best_diff = diff;
@ -705,8 +711,10 @@ static bool EvaluateHorizontalDiff(const l_uint32* line, int diff_sign,
int* best_diff, int* best_sum, int* best_x) {
if (x <= 0 || x >= width)
return false;
int pixel1 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x - 1);
int pixel2 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x);
int pixel1 = GET_DATA_BYTE(
const_cast<void*>(reinterpret_cast<const void*>(line)), x - 1);
int pixel2 =
GET_DATA_BYTE(const_cast<void*>(reinterpret_cast<const void*>(line)), x);
int diff = (pixel2 - pixel1) * diff_sign;
if (diff > *best_diff) {
*best_diff = diff;
@ -954,8 +962,7 @@ void C_OUTLINE::render_outline(int left, int top, Pix* pix) const {
*/
#ifndef GRAPHICS_DISABLED
void C_OUTLINE::plot(ScrollView* window,
ScrollView::Color colour) const {
void C_OUTLINE::plot(ScrollView* window, ScrollView::Color colour) const {
inT16 stepindex; // index to cstep
ICOORD pos; // current position
DIR128 stepdir; // direction of step
@ -1016,7 +1023,6 @@ void C_OUTLINE::plot_normed(const DENORM& denorm, ScrollView::Color colour,
}
#endif
/**
* @name C_OUTLINE::operator=
*
@ -1024,7 +1030,7 @@ void C_OUTLINE::plot_normed(const DENORM& denorm, ScrollView::Color colour,
* @param source assign from this
*/
C_OUTLINE & C_OUTLINE::operator= (const C_OUTLINE & source) {
C_OUTLINE& C_OUTLINE::operator=(const C_OUTLINE& source) {
box = source.box;
start = source.start;
if (steps != NULL)

13
ccstruct/mod128.cpp
View File

@ -86,16 +86,3 @@ DIR128::DIR128( //from fcoord
while (high - low > 1);
dir = low;
}
/**********************************************************************
* dir_to_gradient
*
* Convert a direction to a vector.
**********************************************************************/
#if 0 // code is buggy for negative dir and unused
ICOORD DIR128::vector() const { //convert to vector
return dirtab[dir]; //easy really
}
#endif

1
ccstruct/mod128.h
View File

@ -77,7 +77,6 @@ class DLLSYM DIR128
inT8 get_dir() const { //access function
return dir;
}
ICOORD vector() const; //turn to vector
private:
inT8 dir; //a direction

20
ccstruct/otsuthr.cpp
View File

@ -52,22 +52,15 @@ int OtsuThreshold(Pix* src_pix, int left, int top, int width, int height,
// only use opencl if compiled w/ OpenCL and selected device is opencl
#ifdef USE_OPENCL
// all of channel 0 then all of channel 1...
int *histogramAllChannels = new int[kHistogramSize * num_channels];
int* histogramAllChannels = new int[kHistogramSize * num_channels];
// Calculate Histogram on GPU
OpenclDevice od;
if (od.selectedDeviceIsOpenCL() &&
(num_channels == 1 || num_channels == 4) && top == 0 && left == 0 ) {
od.HistogramRectOCL(
(const unsigned char*)pixGetData(src_pix),
num_channels,
pixGetWpl(src_pix) * 4,
left,
top,
width,
height,
kHistogramSize,
histogramAllChannels);
if (od.selectedDeviceIsOpenCL() && (num_channels == 1 || num_channels == 4) &&
top == 0 && left == 0) {
od.HistogramRectOCL((const unsigned char*)pixGetData(src_pix), num_channels,
pixGetWpl(src_pix) * 4, left, top, width, height,
kHistogramSize, histogramAllChannels);
// Calculate Threshold from Histogram on cpu
for (int ch = 0; ch < num_channels; ++ch) {
@ -143,7 +136,6 @@ int OtsuThreshold(Pix* src_pix, int left, int top, int width, int height,
delete[] histogramAllChannels;
#endif // USE_OPENCL
if (!any_good_hivalue) {
// Use the best of the ones that were not good enough.
(*hi_values)[best_hi_index] = best_hi_value;

4
ccstruct/pageres.h
View File

@ -327,7 +327,7 @@ class WERD_RES : public ELIST_LINK {
}
// Deep copies everything except the ratings MATRIX.
// To get that use deep_copy below.
WERD_RES(const WERD_RES &source) : ELIST_LINK(source) {
WERD_RES(const WERD_RES& source) : ELIST_LINK(source) {
InitPointers();
*this = source; // see operator=
}
@ -630,7 +630,7 @@ class WERD_RES : public ELIST_LINK {
static WERD_RES* deep_copy(const WERD_RES* src) {
WERD_RES* result = new WERD_RES(*src);
// That didn't copy the ratings, but we want a copy if there is one to
// begin width.
// begin with.
if (src->ratings != NULL)
result->ratings = src->ratings->DeepCopy();
return result;

66
ccstruct/pdblock.h
View File

@ -29,59 +29,47 @@ struct Pix;
CLISTIZEH (PDBLK)
///page block
class PDBLK
{
class PDBLK {
friend class BLOCK_RECT_IT; //< block iterator
public:
///empty constructor
/// empty constructor
PDBLK() {
hand_poly = NULL;
index_ = 0;
}
///simple constructor
/// simple constructor
PDBLK(inT16 xmin, //< bottom left
inT16 ymin,
inT16 xmax, //< top right
inT16 ymax);
///set vertex lists
/// set vertex lists
///@param left list of left vertices
///@param right list of right vertices
void set_sides(ICOORDELT_LIST *left,
ICOORDELT_LIST *right);
void set_sides(ICOORDELT_LIST *left, ICOORDELT_LIST *right);
///destructor
~PDBLK () {
/// destructor
~PDBLK() {
if (hand_poly) delete hand_poly;
}
POLY_BLOCK *poly_block() const {
return hand_poly;
}
///set the poly block
void set_poly_block(POLY_BLOCK *blk) {
hand_poly = blk;
}
///get box
void bounding_box(ICOORD &bottom_left, //bottom left
ICOORD &top_right) const { //topright
bottom_left = box.botleft ();
top_right = box.topright ();
}
///get real box
const TBOX &bounding_box() const {
return box;
POLY_BLOCK *poly_block() const { return hand_poly; }
/// set the poly block
void set_poly_block(POLY_BLOCK *blk) { hand_poly = blk; }
/// get box
void bounding_box(ICOORD &bottom_left, // bottom left
ICOORD &top_right) const { // topright
bottom_left = box.botleft();
top_right = box.topright();
}
/// get real box
const TBOX &bounding_box() const { return box; }
int index() const {
return index_;
}
void set_index(int value) {
index_ = value;
}
int index() const { return index_; }
void set_index(int value) { index_ = value; }
///is pt inside block
/// is pt inside block
BOOL8 contains(ICOORD pt);
/// reposition block
@ -93,19 +81,17 @@ class PDBLK
// mask image.
Pix *render_mask(const FCOORD &rerotation, TBOX *mask_box);
#ifndef GRAPHICS_DISABLED
///draw histogram
#ifndef GRAPHICS_DISABLED
/// draw histogram
///@param window window to draw in
///@param serial serial number
///@param colour colour to draw in
void plot(ScrollView* window,
inT32 serial,
ScrollView::Color colour);
#endif // GRAPHICS_DISABLED
void plot(ScrollView *window, inT32 serial, ScrollView::Color colour);
#endif // GRAPHICS_DISABLED
///assignment
/// assignment
///@param source from this
PDBLK & operator= (const PDBLK & source);
PDBLK &operator=(const PDBLK &source);
protected:
POLY_BLOCK *hand_poly; //< weird as well

3
ccstruct/ratngs.h
View File

@ -288,7 +288,8 @@ class WERD_CHOICE : public ELIST_LINK {
src_certainty, src_permuter);
}
WERD_CHOICE(const char *src_string, const UNICHARSET &unicharset);
WERD_CHOICE(const WERD_CHOICE &word) : ELIST_LINK(word), unicharset_(word.unicharset_) {
WERD_CHOICE(const WERD_CHOICE &word)
: ELIST_LINK(word), unicharset_(word.unicharset_) {
this->init(word.length());
this->operator=(word);
}

6
ccstruct/rect.cpp
View File

@ -29,9 +29,9 @@
*
**********************************************************************/
TBOX::TBOX( //constructor
const ICOORD pt1, //one corner
const ICOORD pt2 //the other corner
TBOX::TBOX( // constructor
const ICOORD pt1, // one corner
const ICOORD pt2 // the other corner
) {
if (pt1.x () <= pt2.x ()) {
if (pt1.y () <= pt2.y ()) {

13
ccstruct/rejctmap.h
View File

@ -48,8 +48,7 @@ OF THIS IMPLIED TEMPORAL ORDERING OF THE FLAGS!!!!
#include "bits16.h"
#include "params.h"
enum REJ_FLAGS
{
enum REJ_FLAGS {
/* Reject modes which are NEVER overridden */
R_TESS_FAILURE, // PERM Tess didn't classify
R_SMALL_XHT, // PERM Xht too small
@ -83,11 +82,11 @@ enum REJ_FLAGS
R_UNLV_REJ, // TEMP ~ turned to - or ^ turned to space
/* Accept modes which occur between the above rejection groups */
R_NN_ACCEPT, //NN acceptance
R_HYPHEN_ACCEPT, //Hyphen acceptance
R_MM_ACCEPT, //Matrix match acceptance
R_QUALITY_ACCEPT, //Accept word in good quality doc
R_MINIMAL_REJ_ACCEPT //Accept EVERYTHING except tess failures
R_NN_ACCEPT, // NN acceptance
R_HYPHEN_ACCEPT, // Hyphen acceptance
R_MM_ACCEPT, // Matrix match acceptance
R_QUALITY_ACCEPT, // Accept word in good quality doc
R_MINIMAL_REJ_ACCEPT // Accept EVERYTHING except tess failures
};
/* REJECT MAP VALUES */

1
ccstruct/statistc.cpp
View File

@ -215,7 +215,6 @@ inT32 STATS::min_bucket() const { // Find min
return rangemin_ + min;
}
/**********************************************************************
* STATS::max_bucket
*

9
ccutil/clst.cpp
View File

@ -56,7 +56,6 @@ void (*zapper) (void *)) { //ptr to zapper functn
}
}
/***********************************************************************
* CLIST::shallow_clear
*
@ -107,7 +106,6 @@ void CLIST::assign_to_sublist( //to this list
last = start_it->extract_sublist (end_it);
}
/***********************************************************************
* CLIST::length
*
@ -123,7 +121,6 @@ inT32 CLIST::length() const { //count elements
return count;
}
/***********************************************************************
* CLIST::sort
*
@ -276,7 +273,6 @@ void *CLIST_ITERATOR::forward() {
return current->data;
}
/***********************************************************************
* CLIST_ITERATOR::data_relative
*
@ -312,7 +308,6 @@ void *CLIST_ITERATOR::data_relative( //get data + or - ...
return ptr->data;
}
/***********************************************************************
* CLIST_ITERATOR::move_to_last()
*
@ -336,7 +331,6 @@ void *CLIST_ITERATOR::move_to_last() {
return current->data;
}
/***********************************************************************
* CLIST_ITERATOR::exchange()
*
@ -434,7 +428,6 @@ void CLIST_ITERATOR::exchange( //positions of 2 link
other_it->current = old_current;
}
/***********************************************************************
* CLIST_ITERATOR::extract_sublist()
*
@ -478,7 +471,7 @@ CLIST_LINK *CLIST_ITERATOR::extract_sublist( //from
temp_it.mark_cycle_pt ();
do { //walk sublist
if (temp_it.cycled_list ()) //can't find end pt
if (temp_it.cycled_list()) // can't find end pt
BAD_SUBLIST.error ("CLIST_ITERATOR.extract_sublist", ABORT, NULL);
if (temp_it.at_last ()) {

194
ccutil/clst.h
View File

@ -50,12 +50,12 @@ class DLLSYM CLIST_LINK
data = next = NULL;
}
CLIST_LINK( //copy constructor
const CLIST_LINK &) { //don't copy link
CLIST_LINK( // copy constructor
const CLIST_LINK &) { // don't copy link
data = next = NULL;
}
void operator= ( //don't copy links
void operator=( // don't copy links
const CLIST_LINK &) {
data = next = NULL;
}
@ -89,8 +89,8 @@ class DLLSYM CLIST
void internal_deep_clear ( //destroy all links
void (*zapper) (void *)); //ptr to zapper functn
void shallow_clear(); //clear list but don't
//delete data elements
void shallow_clear(); // clear list but don't
// delete data elements
bool empty() const { //is list empty?
return !last;
@ -138,7 +138,8 @@ class DLLSYM CLIST
/***********************************************************************
* CLASS - CLIST_ITERATOR
*
* Generic iterator class for singly linked lists with embedded links
* Generic iterator class for singly linked lists with embedded
*links
**********************************************************************/
class DLLSYM CLIST_ITERATOR
@ -231,8 +232,8 @@ class DLLSYM CLIST_ITERATOR
BOOL8 cycled_list(); //Completed a cycle?
void add_to_end( //add at end &
void *new_data); //don't move
void add_to_end( // add at end &
void *new_data); // don't move
void exchange( //positions of 2 links
CLIST_ITERATOR *other_it); //other iterator
@ -270,7 +271,6 @@ inline void CLIST_ITERATOR::set_to_list( //change list
ex_current_was_cycle_pt = FALSE;
}
/***********************************************************************
* CLIST_ITERATOR::CLIST_ITERATOR
*
@ -281,7 +281,6 @@ inline CLIST_ITERATOR::CLIST_ITERATOR(CLIST *list_to_iterate) {
set_to_list(list_to_iterate);
}
/***********************************************************************
* CLIST_ITERATOR::add_after_then_move
*
@ -329,7 +328,6 @@ inline void CLIST_ITERATOR::add_after_then_move( // element to add
current = new_element;
}
/***********************************************************************
* CLIST_ITERATOR::add_after_stay_put
*
@ -380,7 +378,6 @@ inline void CLIST_ITERATOR::add_after_stay_put( // element to add
}
}
/***********************************************************************
* CLIST_ITERATOR::add_before_then_move
*
@ -425,7 +422,6 @@ inline void CLIST_ITERATOR::add_before_then_move( // element to add
current = new_element;
}
/***********************************************************************
* CLIST_ITERATOR::add_before_stay_put
*
@ -471,11 +467,11 @@ inline void CLIST_ITERATOR::add_before_stay_put( // element to add
}
}
/***********************************************************************
* CLIST_ITERATOR::add_list_after
*
* Insert another list to this list after the current element but don't move the
* Insert another list to this list after the current element but don't move
*the
* iterator.
**********************************************************************/
@ -518,7 +514,6 @@ inline void CLIST_ITERATOR::add_list_after(CLIST *list_to_add) {
}
}
/***********************************************************************
* CLIST_ITERATOR::add_list_before
*
@ -563,7 +558,6 @@ inline void CLIST_ITERATOR::add_list_before(CLIST *list_to_add) {
}
}
/***********************************************************************
* CLIST_ITERATOR::extract
*
@ -606,7 +600,6 @@ inline void *CLIST_ITERATOR::extract() {
return extracted_data;
}
/***********************************************************************
* CLIST_ITERATOR::move_to_first()
*
@ -626,7 +619,6 @@ inline void *CLIST_ITERATOR::move_to_first() {
return current != NULL ? current->data : NULL;
}
/***********************************************************************
* CLIST_ITERATOR::mark_cycle_pt()
*
@ -651,7 +643,6 @@ inline void CLIST_ITERATOR::mark_cycle_pt() {
started_cycling = FALSE;
}
/***********************************************************************
* CLIST_ITERATOR::at_first()
*
@ -671,7 +662,6 @@ inline BOOL8 CLIST_ITERATOR::at_first() {
!ex_current_was_last)); //first and last
}
/***********************************************************************
* CLIST_ITERATOR::at_last()
*
@ -691,7 +681,6 @@ inline BOOL8 CLIST_ITERATOR::at_last() {
ex_current_was_last)); //first and last
}
/***********************************************************************
* CLIST_ITERATOR::cycled_list()
*
@ -709,7 +698,6 @@ inline BOOL8 CLIST_ITERATOR::cycled_list() {
}
/***********************************************************************
* CLIST_ITERATOR::length()
*
@ -726,7 +714,6 @@ inline inT32 CLIST_ITERATOR::length() {
return list->length ();
}
/***********************************************************************
* CLIST_ITERATOR::sort()
*
@ -747,7 +734,6 @@ const void *, const void *)) {
move_to_first();
}
/***********************************************************************
* CLIST_ITERATOR::add_to_end
*
@ -830,114 +816,116 @@ CLISTIZEH is a concatenation of 3 fragments CLISTIZEH_A, CLISTIZEH_B and
CLISTIZEH_C.
***********************************************************************/
#define CLISTIZEH_A( CLASSNAME ) \
#define CLISTIZEH_A(CLASSNAME) \
\
extern DLLSYM void CLASSNAME##_c1_zapper( /*delete a link*/ \
void* link); /*link to delete*/ \
extern DLLSYM void CLASSNAME##_c1_zapper( /*delete a link*/ \
void *link); /*link to delete*/ \
\
extern DLLSYM void* CLASSNAME##_c1_copier( /*deep copy a link*/ \
void* old_element); /*source link */
extern DLLSYM void \
*CLASSNAME##_c1_copier( /*deep copy a link*/ \
void *old_element); /*source link */
#define CLISTIZEH_B( CLASSNAME ) \
#define CLISTIZEH_B(CLASSNAME) \
\
/*********************************************************************** \
* CLASS - CLASSNAME##_CLIST \
* \
* List class for class CLASSNAME \
* \
**********************************************************************/ \
/*********************************************************************** \
* CLASS - \
*CLASSNAME##_CLIST \
* \
* List class for class \
*CLASSNAME \
* \
**********************************************************************/ \
\
class DLLSYM CLASSNAME##_CLIST : public CLIST \
{ \
public: \
CLASSNAME##_CLIST():CLIST() {} \
class DLLSYM CLASSNAME##_CLIST : public CLIST { \
public: \
CLASSNAME##_CLIST() : CLIST() {} \
/* constructor */ \
\
CLASSNAME##_CLIST( /* don't construct */ \
const CLASSNAME##_CLIST&) /*by initial assign*/ \
{ DONT_CONSTRUCT_LIST_BY_COPY.error( QUOTE_IT( CLASSNAME##_CLIST ), \
ABORT, NULL ); } \
const CLASSNAME##_CLIST &) /*by initial assign*/ \
{ \
DONT_CONSTRUCT_LIST_BY_COPY.error(QUOTE_IT(CLASSNAME##_CLIST), ABORT, \
NULL); \
} \
\
void deep_clear() /* delete elements */ \
{ CLIST::internal_deep_clear( &CLASSNAME##_c1_zapper ); } \
void deep_clear() /* delete elements */ \
{ \
CLIST::internal_deep_clear(&CLASSNAME##_c1_zapper); \
} \
\
void operator=( /* prevent assign */ \
const CLASSNAME##_CLIST&) \
{ DONT_ASSIGN_LISTS.error( QUOTE_IT( CLASSNAME##_CLIST ), \
ABORT, NULL ); }
void operator=(/* prevent assign */ \
const CLASSNAME##_CLIST &) { \
DONT_ASSIGN_LISTS.error(QUOTE_IT(CLASSNAME##_CLIST), ABORT, NULL); \
}
#define CLISTIZEH_C( CLASSNAME ) \
#define CLISTIZEH_C(CLASSNAME) \
} \
; \
\
}; \
/*********************************************************************** \
* CLASS - CLASSNAME##_C_IT \
* \
* Iterator class for class CLASSNAME##_CLIST \
* \
* Note: We don't need to coerce pointers to member functions input \
* parameters as these are automatically converted to the type of the base \
* type. ("A ptr to a class may be converted to a pointer to a public base \
* class of that class") \
**********************************************************************/ \
\
class DLLSYM CLASSNAME##_C_IT : public CLIST_ITERATOR { \
public: \
CLASSNAME##_C_IT() : CLIST_ITERATOR() {} \
\
CLASSNAME##_C_IT(CLASSNAME##_CLIST *list) : CLIST_ITERATOR(list) {} \
\
/*********************************************************************** \
* CLASS - CLASSNAME##_C_IT \
* \
* Iterator class for class CLASSNAME##_CLIST \
* \
* Note: We don't need to coerce pointers to member functions input \
* parameters as these are automatically converted to the type of the base \
* type. ("A ptr to a class may be converted to a pointer to a public base \
* class of that class") \
**********************************************************************/ \
CLASSNAME *data() { return (CLASSNAME *)CLIST_ITERATOR::data(); } \
\
class DLLSYM CLASSNAME##_C_IT : public CLIST_ITERATOR \
{ \
public: \
CLASSNAME##_C_IT():CLIST_ITERATOR(){} \
CLASSNAME *data_relative(inT8 offset) { \
return (CLASSNAME *)CLIST_ITERATOR::data_relative(offset); \
} \
\
CLASSNAME##_C_IT( \
CLASSNAME##_CLIST* list):CLIST_ITERATOR(list){} \
CLASSNAME *forward() { return (CLASSNAME *)CLIST_ITERATOR::forward(); } \
\
CLASSNAME* data() \
{ return (CLASSNAME*) CLIST_ITERATOR::data(); } \
CLASSNAME *extract() { return (CLASSNAME *)CLIST_ITERATOR::extract(); } \
\
CLASSNAME* data_relative( \
inT8 offset) \
{ return (CLASSNAME*) CLIST_ITERATOR::data_relative( offset ); } \
CLASSNAME *move_to_first() { \
return (CLASSNAME *)CLIST_ITERATOR::move_to_first(); \
} \
\
CLASSNAME* forward() \
{ return (CLASSNAME*) CLIST_ITERATOR::forward(); } \
\
CLASSNAME* extract() \
{ return (CLASSNAME*) CLIST_ITERATOR::extract(); } \
\
CLASSNAME* move_to_first() \
{ return (CLASSNAME*) CLIST_ITERATOR::move_to_first(); } \
\
CLASSNAME* move_to_last() \
{ return (CLASSNAME*) CLIST_ITERATOR::move_to_last(); } \
};
CLASSNAME *move_to_last() { \
return (CLASSNAME *)CLIST_ITERATOR::move_to_last(); \
} \
};
#define CLISTIZEH( CLASSNAME ) \
#define CLISTIZEH(CLASSNAME) \
\
CLISTIZEH_A( CLASSNAME ) \
CLISTIZEH_A(CLASSNAME) \
\
CLISTIZEH_B( CLASSNAME ) \
CLISTIZEH_B(CLASSNAME) \
\
CLISTIZEH_C( CLASSNAME )
CLISTIZEH_C(CLASSNAME)
/***********************************************************************
CLISTIZE( CLASSNAME ) MACRO
***********************************************************************/
#define CLISTIZE( CLASSNAME ) \
#define CLISTIZE(CLASSNAME) \
\
/*********************************************************************** \
* CLASSNAME##_c1_zapper \
* \
* A function which can delete a CLASSNAME element. This is passed to the \
* generic deep_clear list member function so that when a list is cleared the \
* elements on the list are properly destroyed from the base class, even \
* though we don't use a virtual destructor function. \
**********************************************************************/ \
/*********************************************************************** \
* CLASSNAME##_c1_zapper \
* \
* A function which can delete a CLASSNAME element. This is passed to the \
* generic deep_clear list member function so that when a list is cleared \
*the \
* elements on the list are properly destroyed from the base class, even \
* though we don't use a virtual destructor function. \
**********************************************************************/ \
\
DLLSYM void CLASSNAME##_c1_zapper( /*delete a link*/ \
void* link) /*link to delete*/ \
{ \
delete (CLASSNAME *) link; \
} \
DLLSYM void CLASSNAME##_c1_zapper( /*delete a link*/ \
void *link) /*link to delete*/ \
{ \
delete (CLASSNAME *)link; \
}
#endif

8
ccutil/elst.cpp
View File

@ -81,7 +81,6 @@ void ELIST::assign_to_sublist( //to this list
last = start_it->extract_sublist (end_it);
}
/***********************************************************************
* ELIST::length
*
@ -97,7 +96,6 @@ inT32 ELIST::length() const { // count elements
return count;
}
/***********************************************************************
* ELIST::sort
*
@ -224,7 +222,6 @@ ELIST_LINK *ELIST_ITERATOR::forward() {
return current;
}
/***********************************************************************
* ELIST_ITERATOR::data_relative
*
@ -260,7 +257,6 @@ ELIST_LINK *ELIST_ITERATOR::data_relative( //get data + or - ...
return ptr;
}
/***********************************************************************
* ELIST_ITERATOR::move_to_last()
*
@ -281,7 +277,6 @@ ELIST_LINK *ELIST_ITERATOR::move_to_last() {
return current;
}
/***********************************************************************
* ELIST_ITERATOR::exchange()
*
@ -379,7 +374,6 @@ void ELIST_ITERATOR::exchange( //positions of 2 link
other_it->current = old_current;
}
/***********************************************************************
* ELIST_ITERATOR::extract_sublist()
*
@ -425,7 +419,7 @@ ELIST_LINK *ELIST_ITERATOR::extract_sublist( //from
temp_it.mark_cycle_pt ();
do { //walk sublist
if (temp_it.cycled_list ()) //can't find end pt
if (temp_it.cycled_list()) // can't find end pt
BAD_SUBLIST.error ("ELIST_ITERATOR.extract_sublist", ABORT, NULL);
if (temp_it.at_last ()) {

44
ccutil/elst.h
View File

@ -98,7 +98,7 @@ class DLLSYM ELIST_LINK
next = NULL;
}
void operator= ( //don't copy links
void operator=( // don't copy links
const ELIST_LINK &) {
next = NULL;
}
@ -273,8 +273,8 @@ class DLLSYM ELIST_ITERATOR
bool cycled_list(); //Completed a cycle?
void add_to_end( //add at end &
ELIST_LINK *new_link); //don't move
void add_to_end( // add at end &
ELIST_LINK *new_link); // don't move
void exchange( //positions of 2 links
ELIST_ITERATOR *other_it); //other iterator
@ -458,7 +458,6 @@ inline void ELIST_ITERATOR::add_before_then_move( // element to add
current = new_element;
}
/***********************************************************************
* ELIST_ITERATOR::add_before_stay_put
*
@ -501,11 +500,11 @@ inline void ELIST_ITERATOR::add_before_stay_put( // element to add
}
}
/***********************************************************************
* ELIST_ITERATOR::add_list_after
*
* Insert another list to this list after the current element but don't move the
* Insert another list to this list after the current element but don't move
*the
* iterator.
**********************************************************************/
@ -961,28 +960,27 @@ ELISTIZEH_C( CLASSNAME )
#define ELISTIZE(CLASSNAME) \
\
/*********************************************************************** \
* CLASSNAME##_zapper \
* \
* A function which can delete a CLASSNAME element. This is passed to the \
* generic clear list member function so that when a list is cleared the \
* elements on the list are properly destroyed from the base class, even \
* though we don't use a virtual destructor function. \
**********************************************************************/ \
/*********************************************************************** \
* CLASSNAME##_zapper \
* \
* A function which can delete a CLASSNAME element. This is passed to the \
* generic clear list member function so that when a list is cleared the \
* elements on the list are properly destroyed from the base class, even \
* though we don't use a virtual destructor function. \
**********************************************************************/ \
\
DLLSYM void CLASSNAME##_zapper(ELIST_LINK* link) { \
delete reinterpret_cast<CLASSNAME*>(link); \
} \
DLLSYM void CLASSNAME##_zapper(ELIST_LINK *link) { \
delete reinterpret_cast<CLASSNAME *>(link); \
} \
\
/* Become a deep copy of src_list*/ \
void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST* src_list, \
CLASSNAME* (*copier)(const CLASSNAME*)) { \
\
CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST*>(src_list)); \
/* Become a deep copy of src_list*/ \
void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST *src_list, \
CLASSNAME *(*copier)(const CLASSNAME *)) { \
CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST *>(src_list)); \
CLASSNAME##_IT to_it(this); \
\
for (from_it.mark_cycle_pt(); !from_it.cycled_list(); from_it.forward()) \
to_it.add_after_then_move((*copier)(from_it.data())); \
}
}
#endif

8
ccutil/elst2.cpp
View File

@ -82,7 +82,6 @@ void ELIST2::assign_to_sublist( //to this list
last = start_it->extract_sublist (end_it);
}
/***********************************************************************
* ELIST2::length
*
@ -98,7 +97,6 @@ inT32 ELIST2::length() const { // count elements
return count;
}
/***********************************************************************
* ELIST2::sort
*
@ -218,7 +216,6 @@ ELIST2_LINK *ELIST2_ITERATOR::forward() {
return current;
}
/***********************************************************************
* ELIST2_ITERATOR::backward
*
@ -257,7 +254,6 @@ ELIST2_LINK *ELIST2_ITERATOR::backward() {
return current;
}
/***********************************************************************
* ELIST2_ITERATOR::data_relative
*
@ -289,7 +285,6 @@ ELIST2_LINK *ELIST2_ITERATOR::data_relative( //get data + or - ..
return ptr;
}
/***********************************************************************
* ELIST2_ITERATOR::exchange()
*
@ -399,7 +394,6 @@ void ELIST2_ITERATOR::exchange( //positions of 2 li
other_it->current = old_current;
}
/***********************************************************************
* ELIST2_ITERATOR::extract_sublist()
*
@ -445,7 +439,7 @@ ELIST2_LINK *ELIST2_ITERATOR::extract_sublist( //fr
temp_it.mark_cycle_pt ();
do { //walk sublist
if (temp_it.cycled_list ()) //can't find end pt
if (temp_it.cycled_list()) // can't find end pt
BAD_SUBLIST.error ("ELIST2_ITERATOR.extract_sublist", ABORT, NULL);
if (temp_it.at_last ()) {

217
ccutil/elst2.h
View File

@ -68,12 +68,12 @@ class DLLSYM ELIST2_LINK
prev = next = NULL;
}
ELIST2_LINK( //copy constructor
const ELIST2_LINK &) { //don't copy link
ELIST2_LINK( // copy constructor
const ELIST2_LINK &) { // don't copy link
prev = next = NULL;
}
void operator= ( //don't copy links
void operator=( // don't copy links
const ELIST2_LINK &) {
prev = next = NULL;
}
@ -144,7 +144,8 @@ class DLLSYM ELIST2
/***********************************************************************
* CLASS - ELIST2_ITERATOR
*
* Generic iterator class for doubly linked lists with embedded links
* Generic iterator class for doubly linked lists with embedded
*links
**********************************************************************/
class DLLSYM ELIST2_ITERATOR
@ -240,8 +241,8 @@ class DLLSYM ELIST2_ITERATOR
BOOL8 cycled_list(); //Completed a cycle?
void add_to_end( //add at end &
ELIST2_LINK *new_link); //don't move
void add_to_end( // add at end &
ELIST2_LINK *new_link); // don't move
void exchange( //positions of 2 links
ELIST2_ITERATOR *other_it); //other iterator
@ -279,7 +280,6 @@ inline void ELIST2_ITERATOR::set_to_list( //change list
ex_current_was_cycle_pt = FALSE;
}
/***********************************************************************
* ELIST2_ITERATOR::ELIST2_ITERATOR
*
@ -290,7 +290,6 @@ inline ELIST2_ITERATOR::ELIST2_ITERATOR(ELIST2 *list_to_iterate) {
set_to_list(list_to_iterate);
}
/***********************************************************************
* ELIST2_ITERATOR::add_after_then_move
*
@ -339,7 +338,6 @@ inline void ELIST2_ITERATOR::add_after_then_move( // element to add
current = new_element;
}
/***********************************************************************
* ELIST2_ITERATOR::add_after_stay_put
*
@ -391,7 +389,6 @@ inline void ELIST2_ITERATOR::add_after_stay_put( // element to add
}
}
/***********************************************************************
* ELIST2_ITERATOR::add_before_then_move
*
@ -438,7 +435,6 @@ inline void ELIST2_ITERATOR::add_before_then_move( // element to add
current = new_element;
}
/***********************************************************************
* ELIST2_ITERATOR::add_before_stay_put
*
@ -486,11 +482,11 @@ inline void ELIST2_ITERATOR::add_before_stay_put( // element to add
}
}
/***********************************************************************
* ELIST2_ITERATOR::add_list_after
*
* Insert another list to this list after the current element but don't move the
* Insert another list to this list after the current element but don't move
*the
* iterator.
**********************************************************************/
@ -537,7 +533,6 @@ inline void ELIST2_ITERATOR::add_list_after(ELIST2 *list_to_add) {
}
}
/***********************************************************************
* ELIST2_ITERATOR::add_list_before
*
@ -586,7 +581,6 @@ inline void ELIST2_ITERATOR::add_list_before(ELIST2 *list_to_add) {
}
}
/***********************************************************************
* ELIST2_ITERATOR::extract
*
@ -631,7 +625,6 @@ inline ELIST2_LINK *ELIST2_ITERATOR::extract() {
return extracted_link;
}
/***********************************************************************
* ELIST2_ITERATOR::move_to_first()
*
@ -651,7 +644,6 @@ inline ELIST2_LINK *ELIST2_ITERATOR::move_to_first() {
return current;
}
/***********************************************************************
* ELIST2_ITERATOR::move_to_last()
*
@ -671,7 +663,6 @@ inline ELIST2_LINK *ELIST2_ITERATOR::move_to_last() {
return current;
}
/***********************************************************************
* ELIST2_ITERATOR::mark_cycle_pt()
*
@ -696,7 +687,6 @@ inline void ELIST2_ITERATOR::mark_cycle_pt() {
started_cycling = FALSE;
}
/***********************************************************************
* ELIST2_ITERATOR::at_first()
*
@ -716,7 +706,6 @@ inline BOOL8 ELIST2_ITERATOR::at_first() {
!ex_current_was_last)); //first and last
}
/***********************************************************************
* ELIST2_ITERATOR::at_last()
*
@ -736,7 +725,6 @@ inline BOOL8 ELIST2_ITERATOR::at_last() {
ex_current_was_last)); //first and last
}
/***********************************************************************
* ELIST2_ITERATOR::cycled_list()
*
@ -754,7 +742,6 @@ inline BOOL8 ELIST2_ITERATOR::cycled_list() {
}
/***********************************************************************
* ELIST2_ITERATOR::length()
*
@ -771,7 +758,6 @@ inline inT32 ELIST2_ITERATOR::length() {
return list->length ();
}
/***********************************************************************
* ELIST2_ITERATOR::sort()
*
@ -792,7 +778,6 @@ const void *, const void *)) {
move_to_first();
}
/***********************************************************************
* ELIST2_ITERATOR::add_to_end
*
@ -873,132 +858,132 @@ ELIST2IZEH is a concatenation of 3 fragments ELIST2IZEH_A, ELIST2IZEH_B and
ELIST2IZEH_C.
***********************************************************************/
#define ELIST2IZEH_A( CLASSNAME ) \
#define ELIST2IZEH_A(CLASSNAME) \
\
extern DLLSYM void CLASSNAME##_zapper( /*delete a link*/ \
ELIST2_LINK* link); /*link to delete*/
extern DLLSYM void CLASSNAME##_zapper( /*delete a link*/ \
ELIST2_LINK *link); /*link to delete*/
#define ELIST2IZEH_B( CLASSNAME ) \
#define ELIST2IZEH_B(CLASSNAME) \
\
/*********************************************************************** \
* CLASS - CLASSNAME##_LIST \
* \
* List class for class CLASSNAME \
* \
**********************************************************************/ \
/*********************************************************************** \
* CLASS - \
*CLASSNAME##_LIST \
* \
* List class for class \
*CLASSNAME \
* \
**********************************************************************/ \
\
class DLLSYM CLASSNAME##_LIST : public ELIST2 \
{ \
public: \
CLASSNAME##_LIST():ELIST2() {} \
class DLLSYM CLASSNAME##_LIST : public ELIST2 { \
public: \
CLASSNAME##_LIST() : ELIST2() {} \
/* constructor */ \
\
CLASSNAME##_LIST( /* don't construct */ \
const CLASSNAME##_LIST&) /*by initial assign*/\
{ DONT_CONSTRUCT_LIST_BY_COPY.error( QUOTE_IT( CLASSNAME##_LIST ), \
ABORT, NULL ); } \
const CLASSNAME##_LIST &) /*by initial assign*/ \
{ \
DONT_CONSTRUCT_LIST_BY_COPY.error(QUOTE_IT(CLASSNAME##_LIST), ABORT, \
NULL); \
} \
\
void clear() /* delete elements */\
{ ELIST2::internal_clear( &CLASSNAME##_zapper ); } \
void clear() /* delete elements */ \
{ \
ELIST2::internal_clear(&CLASSNAME##_zapper); \
} \
\
~CLASSNAME##_LIST() /* destructor */ \
{ clear(); } \
\
/* Become a deep copy of src_list*/ \
void deep_copy(const CLASSNAME##_LIST* src_list, \
CLASSNAME* (*copier)(const CLASSNAME*)); \
\
void operator=( /* prevent assign */ \
const CLASSNAME##_LIST&) \
{ DONT_ASSIGN_LISTS.error( QUOTE_IT( CLASSNAME##_LIST ), \
ABORT, NULL ); }
{ \
clear(); \
} \
\
/* Become a deep copy of src_list*/ \
void deep_copy(const CLASSNAME##_LIST *src_list, \
CLASSNAME *(*copier)(const CLASSNAME *)); \
\
void operator=(/* prevent assign */ \
const CLASSNAME##_LIST &) { \
DONT_ASSIGN_LISTS.error(QUOTE_IT(CLASSNAME##_LIST), ABORT, NULL); \
}
#define ELIST2IZEH_C( CLASSNAME ) \
}; \
#define ELIST2IZEH_C(CLASSNAME) \
} \
; \
\
/*********************************************************************** \
* CLASS - CLASSNAME##_IT \
* \
* Iterator class for class CLASSNAME##_LIST \
* \
* Note: We don't need to coerce pointers to member functions input \
* parameters as these are automatically converted to the type of the base \
* type. ("A ptr to a class may be converted to a pointer to a public base \
* class of that class") \
**********************************************************************/ \
\
class DLLSYM CLASSNAME##_IT : public ELIST2_ITERATOR { \
public: \
CLASSNAME##_IT() : ELIST2_ITERATOR() {} \
\
/*********************************************************************** \
* CLASS - CLASSNAME##_IT \
* \
* Iterator class for class CLASSNAME##_LIST \
* \
* Note: We don't need to coerce pointers to member functions input \
* parameters as these are automatically converted to the type of the base \
* type. ("A ptr to a class may be converted to a pointer to a public base \
* class of that class") \
**********************************************************************/ \
CLASSNAME##_IT(CLASSNAME##_LIST *list) : ELIST2_ITERATOR(list) {} \
\
class DLLSYM CLASSNAME##_IT : public ELIST2_ITERATOR \
{ \
public: \
CLASSNAME##_IT():ELIST2_ITERATOR(){} \
CLASSNAME *data() { return (CLASSNAME *)ELIST2_ITERATOR::data(); } \
\
CLASSNAME##_IT( \
CLASSNAME##_LIST* list):ELIST2_ITERATOR(list){} \
CLASSNAME *data_relative(inT8 offset) { \
return (CLASSNAME *)ELIST2_ITERATOR::data_relative(offset); \
} \
\
CLASSNAME* data() \
{ return (CLASSNAME*) ELIST2_ITERATOR::data(); } \
CLASSNAME *forward() { return (CLASSNAME *)ELIST2_ITERATOR::forward(); } \
\
CLASSNAME* data_relative( \
inT8 offset) \
{ return (CLASSNAME*) ELIST2_ITERATOR::data_relative( offset ); } \
CLASSNAME *backward() { return (CLASSNAME *)ELIST2_ITERATOR::backward(); } \
\
CLASSNAME* forward() \
{ return (CLASSNAME*) ELIST2_ITERATOR::forward(); } \
CLASSNAME *extract() { return (CLASSNAME *)ELIST2_ITERATOR::extract(); } \
\
CLASSNAME* backward() \
{ return (CLASSNAME*) ELIST2_ITERATOR::backward(); } \
CLASSNAME *move_to_first() { \
return (CLASSNAME *)ELIST2_ITERATOR::move_to_first(); \
} \
\
CLASSNAME* extract() \
{ return (CLASSNAME*) ELIST2_ITERATOR::extract(); } \
\
CLASSNAME* move_to_first() \
{ return (CLASSNAME*) ELIST2_ITERATOR::move_to_first(); } \
\
CLASSNAME* move_to_last() \
{ return (CLASSNAME*) ELIST2_ITERATOR::move_to_last(); } \
};
CLASSNAME *move_to_last() { \
return (CLASSNAME *)ELIST2_ITERATOR::move_to_last(); \
} \
};
#define ELIST2IZEH( CLASSNAME ) \
#define ELIST2IZEH(CLASSNAME) \
\
ELIST2IZEH_A( CLASSNAME ) \
ELIST2IZEH_A(CLASSNAME) \
\
ELIST2IZEH_B( CLASSNAME ) \
ELIST2IZEH_B(CLASSNAME) \
\
ELIST2IZEH_C( CLASSNAME )
ELIST2IZEH_C(CLASSNAME)
/***********************************************************************
ELIST2IZE( CLASSNAME ) MACRO
***********************************************************************/
#define ELIST2IZE( CLASSNAME ) \
#define ELIST2IZE(CLASSNAME) \
\
/*********************************************************************** \
* CLASSNAME##_zapper \
* \
* A function which can delete a CLASSNAME element. This is passed to the \
* generic clear list member function so that when a list is cleared the \
* elements on the list are properly destroyed from the base class, even \
* though we don't use a virtual destructor function. \
**********************************************************************/ \
/*********************************************************************** \
* CLASSNAME##_zapper \
* \
* A function which can delete a CLASSNAME element. This is passed to the \
* generic clear list member function so that when a list is cleared the \
* elements on the list are properly destroyed from the base class, even \
* though we don't use a virtual destructor function. \
**********************************************************************/ \
\
DLLSYM void CLASSNAME##_zapper( /*delete a link*/ \
ELIST2_LINK* link) /*link to delete*/ \
{ \
delete (CLASSNAME *) link; \
} \
\
/* Become a deep copy of src_list*/ \
void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST* src_list, \
CLASSNAME* (*copier)(const CLASSNAME*)) { \
\
CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST*>(src_list)); \
DLLSYM void CLASSNAME##_zapper( /*delete a link*/ \
ELIST2_LINK *link) /*link to delete*/ \
{ \
delete (CLASSNAME *)link; \
} \
\
/* Become a deep copy of src_list*/ \
void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST *src_list, \
CLASSNAME *(*copier)(const CLASSNAME *)) { \
CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST *>(src_list)); \
CLASSNAME##_IT to_it(this); \
\
\
for (from_it.mark_cycle_pt(); !from_it.cycled_list(); from_it.forward()) \
to_it.add_after_then_move((*copier)(from_it.data())); \
}
}
#endif

7
ccutil/errcode.h
View File

@ -87,11 +87,10 @@ const ERRCODE ASSERT_FAILED = "Assert failed";
__FILE__, __LINE__); \
}
#define ASSERT_HOST_MSG(x, ...) if (!(x)) \
{ \
#define ASSERT_HOST_MSG(x, ...) \
if (!(x)) { \
tprintf(__VA_ARGS__); \
ASSERT_FAILED.error(#x, ABORT, "in file %s, line %d", \
__FILE__, __LINE__); \
ASSERT_FAILED.error(#x, ABORT, "in file %s, line %d", __FILE__, __LINE__); \
}
void signal_exit(int signal_code);

2
ccutil/helpers.h
View File

@ -73,7 +73,7 @@ class TRand {
// Remove newline (if any) at the end of the string.
inline void chomp_string(char *str) {
int last_index = (int)strlen(str) - 1;
int last_index = static_cast<int>(strlen(str)) - 1;
while (last_index >= 0 &&
(str[last_index] == '\n' || str[last_index] == '\r')) {
str[last_index--] = '\0';

12
ccutil/host.h
View File

@ -59,6 +59,7 @@
** of the computer and/or operating system.
******************************************************************************/
#include <limits>
#include "platform.h"
/* _WIN32 */
#ifdef _WIN32
@ -121,15 +122,16 @@ typedef unsigned char BOOL8;
#define MAX_UINT8 0xff
#define MAX_UINT16 0xffff
#define MAX_UINT32 0xffffffff
#define MAX_FLOAT32 ((float)3.40282347e+38)
#define MAX_FLOAT32 std::numeric_limits<float>::max()
#define MIN_INT8 0x80
#define MIN_INT16 0x8000
#define MIN_INT32 static_cast<int>(0x80000000)
#define MIN_INT8 static_cast<inT8>(0x80)
#define MIN_INT16 static_cast<inT16>(0x8000)
#define MIN_INT32 static_cast<inT32>(0x80000000)
#define MIN_UINT8 0x00
#define MIN_UINT16 0x0000
#define MIN_UINT32 0x00000000
#define MIN_FLOAT32 ((float)1.17549435e-38)
// Minimum positive value ie 1e-37ish.
#define MIN_FLOAT32 std::numeric_limits<float>::min()
// Defines
#ifndef TRUE

2
ccutil/lsterr.h
View File

@ -38,6 +38,6 @@ const ERRCODE NULL_PREV = "Previous element on the list is NULL";
const ERRCODE EMPTY_LIST = "List is empty";
const ERRCODE BAD_PARAMETER = "List parameter error";
const ERRCODE STILL_LINKED =
"Attempting to add an element with non NULL links, to a list";
"Attempting to add an element with non NULL links, to a list";
#endif
#endif

2
ccutil/mainblk.cpp
View File

@ -74,7 +74,7 @@ void CCUtil::main_setup(const char *argv0, const char *basename) {
#endif /* _WIN32 */
#if defined(TESSDATA_PREFIX)
} else {
/* Use tessdata prefix which was compiled in. */
/* Use tessdata prefix which was compiled in. */
#define _STR(a) #a
#define _XSTR(a) _STR(a)
datadir = _XSTR(TESSDATA_PREFIX);

19
ccutil/ocrclass.h
View File

@ -110,8 +110,8 @@ typedef struct { /*single character */
* user words found. If it returns true then operation is cancelled.
**********************************************************************/
typedef bool (*CANCEL_FUNC)(void* cancel_this, int words);
typedef bool (*PROGRESS_FUNC)(int progress,
int left, int right, int top, int bottom);
typedef bool (*PROGRESS_FUNC)(int progress, int left, int right, int top,
int bottom);
class ETEXT_DESC { // output header
public:
@ -126,12 +126,19 @@ class ETEXT_DESC { // output header
CANCEL_FUNC cancel; /// returns true to cancel
PROGRESS_FUNC progress_callback; /// called whenever progress increases
void* cancel_this; /// this or other data for cancel
struct timeval end_time; /** time to stop. expected to be set only by call
* to set_deadline_msecs() */
struct timeval end_time; /// Time to stop. Expected to be set only
/// by call to set_deadline_msecs().
EANYCODE_CHAR text[1]; /// character data
ETEXT_DESC() : count(0), progress(0), more_to_come(0), ocr_alive(0),
err_code(0), cancel(NULL), cancel_this(NULL) {
ETEXT_DESC()
: count(0),
progress(0),
more_to_come(0),
ocr_alive(0),
err_code(0),
cancel(NULL),
progress_callback(NULL),
cancel_this(NULL) {
end_time.tv_sec = 0;
end_time.tv_usec = 0;
}

3
ccutil/params.cpp
View File

@ -31,8 +31,7 @@
#define EQUAL '='
tesseract::ParamsVectors *GlobalParams() {
static tesseract::ParamsVectors global_params =
tesseract::ParamsVectors();
static tesseract::ParamsVectors global_params = tesseract::ParamsVectors();
return &global_params;
}

3
ccutil/unicharset.h
View File

@ -181,8 +181,7 @@ class UNICHARSET {
// Return the UNICHAR_ID of a given unichar representation within the
// UNICHARSET. Only the first length characters from unichar_repr are used.
UNICHAR_ID unichar_to_id(const char* const unichar_repr,
int length) const;
UNICHAR_ID unichar_to_id(const char* const unichar_repr, int length) const;
// Return the minimum number of bytes that matches a legal UNICHAR_ID,
// while leaving the rest of the string encodable. Returns 0 if the

5
classify/adaptmatch.cpp
View File

@ -908,8 +908,7 @@ void Classify::AdaptToChar(TBLOB* Blob, CLASS_ID ClassId, int FontinfoId,
NumFeatures = GetAdaptiveFeatures(Blob, IntFeatures, &FloatFeatures);
if (NumFeatures <= 0) {
FreeFeatureSet(FloatFeatures);
return;
return; // Features already freed by GetAdaptiveFeatures.
}
// Only match configs with the matching font.
@ -1008,8 +1007,6 @@ void Classify::DisplayAdaptedChar(TBLOB* blob, INT_CLASS_STRUCT* int_class) {
#endif
}
/**
* This routine adds the result of a classification into
* Results. If the new rating is much worse than the current

4
classify/classify.cpp
View File

@ -151,8 +151,8 @@ Classify::Classify()
INT_MEMBER(classify_integer_matcher_multiplier, 10,
"Integer Matcher Multiplier 0-255: ", this->params()),
EnableLearning(true),
INT_MEMBER(il1_adaption_test, 0, "Don't adapt to i/I at beginning of word",
this->params()),
INT_MEMBER(il1_adaption_test, 0,
"Don't adapt to i/I at beginning of word", this->params()),
BOOL_MEMBER(classify_bln_numeric_mode, 0,
"Assume the input is numbers [0-9].", this->params()),
double_MEMBER(speckle_large_max_size, 0.30, "Max large speckle size",

61
classify/cluster.cpp
View File

@ -437,7 +437,6 @@ MakeClusterer (inT16 SampleSize, const PARAM_DESC ParamDesc[]) {
return Clusterer;
} // MakeClusterer
/**
* This routine creates a new sample data structure to hold
* the specified feature. This sample is added to the clusterer
@ -490,7 +489,6 @@ SAMPLE* MakeSample(CLUSTERER * Clusterer, const FLOAT32* Feature,
return (Sample);
} // MakeSample
/**
* This routine first checks to see if the samples in this
* clusterer have already been clustered before; if so, it does
@ -523,10 +521,16 @@ LIST ClusterSamples(CLUSTERER *Clusterer, CLUSTERCONFIG *Config) {
//compute prototypes starting at the root node in the tree
ComputePrototypes(Clusterer, Config);
return (Clusterer->ProtoList);
// We don't need the cluster pointers in the protos any more, so null them
// out, which makes it safe to delete the clusterer.
LIST proto_list = Clusterer->ProtoList;
iterate(proto_list) {
PROTOTYPE *proto = reinterpret_cast<PROTOTYPE *>(first_node(proto_list));
proto->Cluster = NULL;
}
return Clusterer->ProtoList;
} // ClusterSamples
/**
* This routine frees all of the memory allocated to the
* specified data structure. It will not, however, free
@ -558,7 +562,6 @@ void FreeClusterer(CLUSTERER *Clusterer) {
}
} // FreeClusterer
/**
* This routine frees all of the memory allocated to the
* specified list of prototypes. The clusters which are
@ -572,7 +575,6 @@ void FreeProtoList(LIST *ProtoList) {
destroy_nodes(*ProtoList, FreePrototype);
} // FreeProtoList
/**
* This routine deallocates the memory consumed by the specified
* prototype and modifies the corresponding cluster so that it
@ -606,7 +608,6 @@ void FreePrototype(void *arg) { //PROTOTYPE *Prototype)
memfree(Prototype);
} // FreePrototype
/**
* This routine is used to find all of the samples which
* belong to a cluster. It starts by removing the top
@ -637,7 +638,6 @@ CLUSTER *NextSample(LIST *SearchState) {
}
} // NextSample
/**
* This routine returns the mean of the specified
* prototype in the indicated dimension.
@ -651,7 +651,6 @@ FLOAT32 Mean(PROTOTYPE *Proto, uinT16 Dimension) {
return (Proto->Mean[Dimension]);
} // Mean
/**
* This routine returns the standard deviation of the
* prototype in the indicated dimension.
@ -760,7 +759,6 @@ void CreateClusterTree(CLUSTERER *Clusterer) {
memfree(context.candidates);
} // CreateClusterTree
/**
* This routine is designed to be used in concert with the
* KDWalk routine. It will create a potential cluster for
@ -786,7 +784,6 @@ void MakePotentialClusters(ClusteringContext *context,
}
} // MakePotentialClusters
/**
* This routine searches the specified kd-tree for the nearest
* neighbor of the specified cluster. It actually uses the
@ -830,7 +827,6 @@ FindNearestNeighbor(KDTREE * Tree, CLUSTER * Cluster, FLOAT32 * Distance)
return BestNeighbor;
} // FindNearestNeighbor
/**
* This routine creates a new permanent cluster from the
* clusters specified in TempCluster. The 2 clusters in
@ -872,7 +868,6 @@ CLUSTER *MakeNewCluster(CLUSTERER *Clusterer, TEMPCLUSTER *TempCluster) {
return Cluster;
} // MakeNewCluster
/**
* This routine merges two clusters into one larger cluster.
* To do this it computes the number of samples in the new
@ -921,7 +916,6 @@ inT32 MergeClusters(inT16 N,
return n;
} // MergeClusters
/**
* This routine decides which clusters in the cluster tree
* should be represented by prototypes, forms a list of these
@ -961,7 +955,6 @@ void ComputePrototypes(CLUSTERER *Clusterer, CLUSTERCONFIG *Config) {
}
} // ComputePrototypes
/**
* This routine attempts to create a prototype from the
* specified cluster that conforms to the distribution
@ -1050,7 +1043,6 @@ PROTOTYPE *MakePrototype(CLUSTERER *Clusterer,
return Proto;
} // MakePrototype
/**
* This routine checks for clusters which are degenerate and
* therefore cannot be analyzed in a statistically valid way.
@ -1247,7 +1239,6 @@ PROTOTYPE *MakeSphericalProto(CLUSTERER *Clusterer,
return (Proto);
} // MakeSphericalProto
/**
* This routine tests the specified cluster to see if it can
* be approximated by an elliptical normal distribution. If it
@ -1286,7 +1277,6 @@ PROTOTYPE *MakeEllipticalProto(CLUSTERER *Clusterer,
return (Proto);
} // MakeEllipticalProto
/**
* This routine tests each dimension of the specified cluster to
* see what distribution would best approximate that dimension.
@ -1355,7 +1345,6 @@ PROTOTYPE *MakeMixedProto(CLUSTERER *Clusterer,
return (Proto);
} // MakeMixedProto
/**
* This routine alters the ith dimension of the specified
* mixed prototype to be D_random.
@ -1380,7 +1369,6 @@ void MakeDimRandom(uinT16 i, PROTOTYPE *Proto, PARAM_DESC *ParamDesc) {
// note that the proto Weight is irrelevant for D_random protos
} // MakeDimRandom
/**
* This routine alters the ith dimension of the specified
* mixed prototype to be uniform.
@ -1410,7 +1398,6 @@ void MakeDimUniform(uinT16 i, PROTOTYPE *Proto, STATISTICS *Statistics) {
// note that the proto Weight is irrelevant for uniform protos
} // MakeDimUniform
/**
* This routine searches the cluster tree for all leaf nodes
* which are samples in the specified cluster. It computes
@ -1502,7 +1489,6 @@ ComputeStatistics (inT16 N, PARAM_DESC ParamDesc[], CLUSTER * Cluster) {
return (Statistics);
} // ComputeStatistics
/**
* This routine creates a spherical prototype data structure to
* approximate the samples in the specified cluster.
@ -1537,7 +1523,6 @@ PROTOTYPE *NewSphericalProto(uinT16 N,
return (Proto);
} // NewSphericalProto
/**
* This routine creates an elliptical prototype data structure to
* approximate the samples in the specified cluster.
@ -1579,7 +1564,6 @@ PROTOTYPE *NewEllipticalProto(inT16 N,
return (Proto);
} // NewEllipticalProto
/**
* This routine creates a mixed prototype data structure to
* approximate the samples in the specified cluster.
@ -1609,7 +1593,6 @@ PROTOTYPE *NewMixedProto(inT16 N, CLUSTER *Cluster, STATISTICS *Statistics) {
return (Proto);
} // NewMixedProto
/**
* This routine allocates memory to hold a simple prototype
* data structure, i.e. one without independent distributions
@ -1640,7 +1623,6 @@ PROTOTYPE *NewSimpleProto(inT16 N, CLUSTER *Cluster) {
return (Proto);
} // NewSimpleProto
/**
* This routine returns TRUE if the specified covariance
* matrix indicates that all N dimensions are independent of
@ -1692,7 +1674,6 @@ inT16 N, FLOAT32 * CoVariance, FLOAT32 Independence) {
return (TRUE);
} // Independent
/**
* This routine returns a histogram data structure which can
* be used by other routines to place samples into histogram
@ -1739,7 +1720,6 @@ BUCKETS *GetBuckets(CLUSTERER* clusterer,
return Buckets;
} // GetBuckets
/**
* This routine creates a histogram data structure which can
* be used by other routines to place samples into histogram
@ -1840,7 +1820,6 @@ BUCKETS *MakeBuckets(DISTRIBUTION Distribution,
return Buckets;
} // MakeBuckets
/**
* This routine computes the optimum number of histogram
* buckets that should be used in a chi-squared goodness of
@ -1874,7 +1853,6 @@ uinT16 OptimumNumberOfBuckets(uinT32 SampleCount) {
return kBucketsTable[Last];
} // OptimumNumberOfBuckets
/**
* This routine computes the chi-squared value which will
* leave a cumulative probability of Alpha in the right tail
@ -1932,7 +1910,6 @@ ComputeChiSquared (uinT16 DegreesOfFreedom, FLOAT64 Alpha)
} // ComputeChiSquared
/**
* This routine computes the probability density function
* of a discrete normal distribution defined by the global
@ -1943,7 +1920,8 @@ ComputeChiSquared (uinT16 DegreesOfFreedom, FLOAT64 Alpha)
* @note Globals:
* kNormalMean mean of a discrete normal distribution
* kNormalVariance variance of a discrete normal distribution
* kNormalMagnitude magnitude of a discrete normal distribution
* kNormalMagnitude magnitude of a discrete normal
*distribution
* @return The value of the normal distribution at x.
* @note Exceptions: None
* @note History: 6/4/89, DSJ, Created.
@ -1955,7 +1933,6 @@ FLOAT64 NormalDensity(inT32 x) {
return kNormalMagnitude * exp(-0.5 * Distance * Distance / kNormalVariance);
} // NormalDensity
/**
* This routine computes the probability density function
* of a uniform distribution at the specified point. The
@ -1974,7 +1951,6 @@ FLOAT64 UniformDensity(inT32 x) {
return (FLOAT64) 0.0;
} // UniformDensity
/**
* This routine computes a trapezoidal approximation to the
* integral of a function over a small delta in x.
@ -1989,7 +1965,6 @@ FLOAT64 Integral(FLOAT64 f1, FLOAT64 f2, FLOAT64 Dx) {
return (f1 + f2) * Dx / 2.0;
} // Integral
/**
* This routine counts the number of cluster samples which
* fall within the various histogram buckets in Buckets. Only
@ -2071,7 +2046,6 @@ void FillBuckets(BUCKETS *Buckets,
}
} // FillBuckets
/**
* This routine determines which bucket x falls into in the
* discrete normal distribution defined by kNormalMean
@ -2107,7 +2081,6 @@ uinT16 NormalBucket(PARAM_DESC *ParamDesc,
return (uinT16) floor((FLOAT64) X);
} // NormalBucket
/**
* This routine determines which bucket x falls into in the
* discrete uniform distribution defined by
@ -2143,7 +2116,6 @@ uinT16 UniformBucket(PARAM_DESC *ParamDesc,
return (uinT16) floor((FLOAT64) X);
} // UniformBucket
/**
* This routine performs a chi-square goodness of fit test
* on the histogram data in the Buckets data structure. TRUE
@ -2176,7 +2148,6 @@ BOOL8 DistributionOK(BUCKETS *Buckets) {
return TRUE;
} // DistributionOK
/**
* This routine frees the memory used by the statistics
* data structure.
@ -2192,7 +2163,6 @@ void FreeStatistics(STATISTICS *Statistics) {
memfree(Statistics);
} // FreeStatistics
/**
* This routine properly frees the memory used by a BUCKETS.
*
@ -2204,7 +2174,6 @@ void FreeBuckets(BUCKETS *buckets) {
Efree(buckets);
} // FreeBuckets
/**
* This routine frees the memory consumed by the specified
* cluster and all of its subclusters. This is done by
@ -2225,7 +2194,6 @@ void FreeCluster(CLUSTER *Cluster) {
}
} // FreeCluster
/**
* This routine computes the degrees of freedom that should
* be used in a chi-squared test with the specified number of
@ -2252,7 +2220,6 @@ uinT16 DegreesOfFreedom(DISTRIBUTION Distribution, uinT16 HistogramBuckets) {
} // DegreesOfFreedom
/**
* This routine is used to search a list of histogram data
* structures to find one with the specified number of
@ -2272,7 +2239,6 @@ int NumBucketsMatch(void *arg1, // BUCKETS *Histogram,
} // NumBucketsMatch
/**
* This routine is used to search a list for a list node
* whose contents match Key. It is called by the list
@ -2287,7 +2253,6 @@ int ListEntryMatch(void *arg1, //ListNode
} // ListEntryMatch
/**
* This routine multiplies each ExpectedCount histogram entry
* by NewSampleCount/OldSampleCount so that the histogram
@ -2313,7 +2278,6 @@ void AdjustBuckets(BUCKETS *Buckets, uinT32 NewSampleCount) {
} // AdjustBuckets
/**
* This routine sets the bucket counts in the specified histogram
* to zero.
@ -2331,7 +2295,6 @@ void InitBuckets(BUCKETS *Buckets) {
} // InitBuckets
/**
* This routine is used to search a list of structures which
* hold pre-computed chi-squared values for a chi-squared
@ -2355,7 +2318,6 @@ int AlphaMatch(void *arg1, //CHISTRUCT *ChiStruct
} // AlphaMatch
/**
* This routine allocates a new data structure which is used
* to hold a chi-squared value along with its associated
@ -2377,7 +2339,6 @@ CHISTRUCT *NewChiStruct(uinT16 DegreesOfFreedom, FLOAT64 Alpha) {
} // NewChiStruct
/**
* This routine attempts to find an x value at which Function
* goes to zero (i.e. a root of the function ). It will only
@ -2440,7 +2401,6 @@ void *FunctionParams, FLOAT64 InitialGuess, FLOAT64 Accuracy)
} // Solve
/**
* This routine computes the area under a chi density curve
* from 0 to x, minus the desired area under the curve. The
@ -2480,7 +2440,6 @@ FLOAT64 ChiArea(CHISTRUCT *ChiParams, FLOAT64 x) {
} // ChiArea
/**
* This routine looks at all samples in the specified cluster.
* It computes a running estimate of the percentage of the

23
classify/clusttool.cpp
View File

@ -28,7 +28,8 @@
//---------------Global Data Definitions and Declarations--------------------
#define TOKENSIZE 80 //< max size of tokens read from an input file
#define MAXSAMPLESIZE 65535 //< max num of dimensions in feature space
//#define MAXBLOCKSIZE 65535 //< max num of samples in a character (block size)
//#define MAXBLOCKSIZE 65535 //< max num of samples in a character (block
// size)
/**
* This routine reads a single integer from the specified
@ -315,8 +316,7 @@ FLOAT32* ReadNFloats(FILE * File, uinT16 N, FLOAT32 Buffer[]) {
* @note Exceptions: None
* @note History: 6/6/89, DSJ, Created.
*/
void
WriteParamDesc (FILE * File, uinT16 N, PARAM_DESC ParamDesc[]) {
void WriteParamDesc(FILE *File, uinT16 N, const PARAM_DESC ParamDesc[]) {
int i;
for (i = 0; i < N; i++) {
@ -446,14 +446,9 @@ void WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle) {
* @note History: 6/12/89, DSJ, Created.
*/
void WriteProtoList(
FILE *File,
uinT16 N,
PARAM_DESC ParamDesc[],
LIST ProtoList,
BOOL8 WriteSigProtos,
BOOL8 WriteInsigProtos)
{
void WriteProtoList(FILE *File, uinT16 N, PARAM_DESC ParamDesc[],
LIST ProtoList, BOOL8 WriteSigProtos,
BOOL8 WriteInsigProtos) {
PROTOTYPE *Proto;
/* write file header */
@ -464,8 +459,8 @@ void WriteProtoList(
iterate(ProtoList)
{
Proto = (PROTOTYPE *) first_node ( ProtoList );
if (( Proto->Significant && WriteSigProtos ) ||
( ! Proto->Significant && WriteInsigProtos ) )
WritePrototype( File, N, Proto );
if ((Proto->Significant && WriteSigProtos) ||
(!Proto->Significant && WriteInsigProtos))
WritePrototype(File, N, Proto);
}
}

10
classify/clusttool.h
View File

@ -36,7 +36,7 @@ PROTOSTYLE ReadProtoStyle(FILE *File);
FLOAT32 *ReadNFloats (FILE * File, uinT16 N, FLOAT32 Buffer[]);
void WriteParamDesc (FILE * File, uinT16 N, PARAM_DESC ParamDesc[]);
void WriteParamDesc(FILE *File, uinT16 N, const PARAM_DESC ParamDesc[]);
void WritePrototype(FILE *File, uinT16 N, PROTOTYPE *Proto);
@ -44,12 +44,8 @@ void WriteNFloats (FILE * File, uinT16 N, FLOAT32 Array[]);
void WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle);
void WriteProtoList(
FILE *File,
uinT16 N,
PARAM_DESC ParamDesc[],
LIST ProtoList,
BOOL8 WriteSigProtos,
void WriteProtoList(FILE *File, uinT16 N, PARAM_DESC ParamDesc[],
LIST ProtoList, BOOL8 WriteSigProtos,
BOOL8 WriteInsigProtos);
//--------------Global Data Definitions and Declarations---------------------

1
classify/fpoint.cpp
View File

@ -58,5 +58,4 @@ FLOAT32 NormalizedAngleFrom(FPOINT *Point1,
if (Angle < 0.0 || Angle >= FullScale)
Angle = 0.0;
return (Angle);
}

2
classify/intfx.cpp
View File

@ -520,7 +520,7 @@ bool ExtractIntFeat(const TBLOB& blob,
tesseract::Classify::ExtractFeatures(blob, nonlinear_norm,
&bl_features, &cn_features, results,
NULL);
if (bl_features.size() == 0 || cn_features.size() == 0 ||
if (bl_features.empty() || cn_features.empty() ||
bl_features.size() > MAX_NUM_INT_FEATURES ||
cn_features.size() > MAX_NUM_INT_FEATURES) {
return false; // Feature extraction failed.

26
classify/intmatcher.cpp
View File

@ -295,7 +295,8 @@ class ClassPruner {
HeapSort(num_classes_, sort_key_, sort_index_);
}
/** Prints debug info on the class pruner matches for the pruned classes only. */
/** Prints debug info on the class pruner matches for the pruned classes only.
*/
void DebugMatch(const Classify& classify,
const INT_TEMPLATES_STRUCT* int_templates,
const INT_FEATURE_STRUCT* features) const {
@ -370,8 +371,9 @@ class ClassPruner {
private:
/** Array[rounded_classes_] of initial counts for each class. */
int *class_count_;
/// Array[rounded_classes_] of modified counts for each class after normalizing
/// for expected number of features, disabled classes, fragments, and xheights.
/// Array[rounded_classes_] of modified counts for each class after
/// normalizing for expected number of features, disabled classes, fragments,
/// and xheights.
int *norm_count_;
/** Array[rounded_classes_ +1] of pruned counts that gets sorted */
int *sort_key_;
@ -402,8 +404,9 @@ class ClassPruner {
* normalization process (by CLASS_INDEX)
* @param expected_num_features Array of expected number of features
* for each class (by CLASS_INDEX)
* @param results Sorted Array of pruned classes. Must be an array
* of size at least int_templates->NumClasses.
* @param results Sorted Array of pruned classes. Must be an
* array of size at least
* int_templates->NumClasses.
* @param keep_this
*/
int Classify::PruneClasses(const INT_TEMPLATES_STRUCT* int_templates,
@ -606,7 +609,6 @@ int IntegerMatcher::FindGoodProtos(
return NumGoodProtos;
}
/**
* FindBadFeatures finds all features with maximum feature-evidence <
* AdaptFeatureThresh. The list is ordered by increasing feature number.
@ -701,7 +703,6 @@ void IntegerMatcher::Init(tesseract::IntParam *classify_debug_level) {
evidence_mult_mask_ = ((1 << kIntEvidenceTruncBits) - 1);
}
/*----------------------------------------------------------------------------
Private Code
----------------------------------------------------------------------------*/
@ -717,8 +718,6 @@ void ScratchEvidence::ClearFeatureEvidence(const INT_CLASS class_template) {
class_template->NumConfigs * sizeof(feature_evidence_[0]));
}
/**
* Print debugging information for Configuations
* @return none
@ -742,7 +741,6 @@ void IMDebugConfiguration(int FeatureNum,
cprintf ("\n");
}
/**
* Print debugging information for Configuations
* @return none
@ -795,10 +793,10 @@ int IntegerMatcher::UpdateTablesForFeature(
uinT32 XFeatureAddress;
uinT32 YFeatureAddress;
uinT32 ThetaFeatureAddress;
uinT8 *UINT8Pointer;
uinT8* UINT8Pointer;
int ProtoIndex;
uinT8 Temp;
int *IntPointer;
int* IntPointer;
int ConfigNum;
inT32 M3;
inT32 A3;
@ -916,7 +914,6 @@ int IntegerMatcher::UpdateTablesForFeature(
return SumOverConfigs;
}
/**
* Print debugging information for Configuations
* @return none
@ -1165,8 +1162,6 @@ void ScratchEvidence::UpdateSumOfProtoEvidences(
}
}
/**
* Normalize Sum of Proto and Feature Evidence by dividing by the sum of
* the Feature Lengths and the Proto Lengths for each configuration.
@ -1180,7 +1175,6 @@ void ScratchEvidence::NormalizeSums(
}
}
/**
* Find the best match for the current class and update the Result
* with the configuration and match rating.

26
classify/intproto.cpp
View File

@ -46,9 +46,7 @@
#include "config_auto.h"
#endif
using tesseract::FontInfo;
using tesseract::FontSet;
using tesseract::FontSpacingInfo;
/* match debug display constants*/
#define PROTO_PRUNER_SCALE (4.0)
@ -326,10 +324,8 @@ int AddIntProto(INT_CLASS Class) {
Word < Proto->Configs + WERDS_PER_CONFIG_VEC; *Word++ = 0);
return (Index);
}
/**
* This routine adds Proto to the class pruning tables
* for the specified class in Templates.
@ -372,7 +368,6 @@ void AddProtoToClassPruner (PROTO Proto, CLASS_ID ClassId,
}
} /* AddProtoToClassPruner */
/**
* This routine updates the proto pruner lookup tables
* for Class to include a new proto identified by ProtoId
@ -432,7 +427,6 @@ void AddProtoToProtoPruner(PROTO Proto, int ProtoId,
FillPPLinearBits(ProtoSet->ProtoPruner[PRUNER_Y], Index, Y, Pad, debug);
} /* AddProtoToProtoPruner */
/**
* Returns a quantized bucket for the given param shifted by offset,
* notionally (param + offset) * num_buckets, but clipped and casted to the
@ -550,7 +544,6 @@ void Classify::ConvertProto(PROTO Proto, int ProtoId, INT_CLASS Class) {
P->A, P->B, P->C, Class->ProtoLengths[ProtoId]);
} /* ConvertProto */
/**
* This routine converts from the old floating point format
* to the new integer format.
@ -627,7 +620,7 @@ INT_TEMPLATES Classify::CreateIntTemplates(CLASSES FloatProtos,
* @note Exceptions: none
* @note History: Thu Mar 21 14:45:04 1991, DSJ, Created.
*/
void DisplayIntFeature(const INT_FEATURE_STRUCT* Feature, FLOAT32 Evidence) {
void DisplayIntFeature(const INT_FEATURE_STRUCT *Feature, FLOAT32 Evidence) {
ScrollView::Color color = GetMatchColorFor(Evidence);
RenderIntFeature(IntMatchWindow, Feature, color);
if (FeatureDisplayWindow) {
@ -635,7 +628,6 @@ void DisplayIntFeature(const INT_FEATURE_STRUCT* Feature, FLOAT32 Evidence) {
}
} /* DisplayIntFeature */
/**
* This routine renders the specified proto into a
* global display list.
@ -720,7 +712,6 @@ void free_int_class(INT_CLASS int_class) {
Efree(int_class);
}
/**
* This routine allocates a new set of integer templates
* initialized to hold 0 classes.
@ -1218,7 +1209,6 @@ FLOAT32 BucketStart(int Bucket, FLOAT32 Offset, int NumBuckets) {
} /* BucketStart */
/**
* This routine returns the parameter value which
* corresponds to the end of the specified bucket.
@ -1236,7 +1226,6 @@ FLOAT32 BucketEnd(int Bucket, FLOAT32 Offset, int NumBuckets) {
return (((FLOAT32) (Bucket + 1) / NumBuckets) - Offset);
} /* BucketEnd */
/**
* This routine fills in the section of a class pruner
* corresponding to a single x value for a single proto of
@ -1284,7 +1273,6 @@ void DoFill(FILL_SPEC *FillSpec,
}
} /* DoFill */
/**
* Return TRUE if the specified table filler is done, i.e.
* if it has no more lines to fill.
@ -1306,7 +1294,6 @@ BOOL8 FillerDone(TABLE_FILLER *Filler) {
} /* FillerDone */
/**
* This routine sets Bit in each bit vector whose
* bucket lies within the range Center +- Spread. The fill
@ -1349,7 +1336,6 @@ void FillPPCircularBits(uinT32 ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR],
} /* FillPPCircularBits */
/**
* This routine sets Bit in each bit vector whose
* bucket lies within the range Center +- Spread. The fill
@ -1516,7 +1502,6 @@ void GetCPPadsForLevel(int Level,
} /* GetCPPadsForLevel */
/**
* @param Evidence evidence value to return color for
* @return Color which corresponds to specified Evidence value.
@ -1538,7 +1523,6 @@ ScrollView::Color GetMatchColorFor(FLOAT32 Evidence) {
return ScrollView::BLUE;
} /* GetMatchColorFor */
/**
* This routine returns (in Fill) the specification of
* the next line to be filled from Filler. FillerDone() should
@ -1589,7 +1573,6 @@ void GetNextFill(TABLE_FILLER *Filler, FILL_SPEC *Fill) {
} /* GetNextFill */
/**
* This routine computes a data structure (Filler)
* which can be used to fill in a rectangle surrounding
@ -1723,8 +1706,10 @@ void InitTableFiller (FLOAT32 EndPad, FLOAT32 SidePad,
/* translate into bucket positions and deltas */
Filler->X = Bucket8For(Start.x, XS, NB);
Filler->StartDelta = -(inT16) ((Sin / Cos) * 256);
Filler->EndDelta = (inT16) ((Cos / Sin) * 256);
Filler->StartDelta = static_cast<inT16>(ClipToRange<int>(
-IntCastRounded((Sin / Cos) * 256), MIN_INT16, MAX_INT16));
Filler->EndDelta = static_cast<inT16>(ClipToRange<int>(
IntCastRounded((Cos / Sin) * 256), MIN_INT16, MAX_INT16));
XAdjust = BucketEnd(Filler->X, XS, NB) - Start.x;
YAdjust = XAdjust * Sin / Cos;
@ -1787,7 +1772,6 @@ void RenderIntFeature(ScrollView *window, const INT_FEATURE_STRUCT* Feature,
window->DrawTo(X + Dx, Y + Dy);
} /* RenderIntFeature */
/**
* This routine extracts the parameters of the specified
* proto from the class description and adds a rendering of

2
classify/intproto.h
View File

@ -52,7 +52,7 @@ class FCOORD;
#define NUM_CP_BUCKETS 24
#define CLASSES_PER_CP 32
#define NUM_BITS_PER_CLASS 2
#define CLASS_PRUNER_CLASS_MASK (~(~0 << NUM_BITS_PER_CLASS))
#define CLASS_PRUNER_CLASS_MASK (~(~0u << NUM_BITS_PER_CLASS))
#define CLASSES_PER_CP_WERD (CLASSES_PER_CP / NUM_BITS_PER_CLASS)
#define PROTOS_PER_PP_WERD BITS_PER_WERD
#define BITS_PER_CP_VECTOR (CLASSES_PER_CP * NUM_BITS_PER_CLASS)

8
classify/kdtree.cpp
View File

@ -71,7 +71,7 @@ class MinK {
private:
const Key max_key_; //< the maximum possible Key
Element* elements_; //< unsorted array of elements
Element *elements_; //< unsorted array of elements
int elements_count_; //< the number of results collected so far
int k_; //< the number of results we want from the search
int max_index_; //< the index of the result with the largest key
@ -117,7 +117,8 @@ bool MinK<Key, Value>::insert(Key key, Value value) {
//-----------------------------------------------------------------------------
/** Helper class for searching for the k closest points to query_point in tree. */
/** Helper class for searching for the k closest points to query_point in tree.
*/
class KDTreeSearch {
public:
KDTreeSearch(KDTREE* tree, FLOAT32 *query_point, int k_closest);
@ -241,7 +242,6 @@ void KDStore(KDTREE *Tree, FLOAT32 *Key, void *Data) {
*PtrToNode = MakeKDNode(Tree, Key, (void *) Data, Level);
} /* KDStore */
/**
* This routine deletes a node from Tree. The node to be
* deleted is specified by the Key for the node and the Data
@ -298,7 +298,6 @@ KDDelete (KDTREE * Tree, FLOAT32 Key[], void *Data) {
}
} /* KDDelete */
/**
* This routine searches the K-D tree specified by Tree and
* finds the QuerySize nearest neighbors of Query. All neighbors
@ -541,7 +540,6 @@ void Walk(KDTREE *tree, void_proc action, void *context,
Walk(tree, action, context, sub_tree->Right, NextLevel(tree, level));
}
/** Given a subtree nodes, insert all of its elements into tree. */
void InsertNodes(KDTREE *tree, KDNODE *nodes) {
if (nodes == NULL)

8
classify/mastertrainer.cpp
View File

@ -362,9 +362,11 @@ bool MasterTrainer::LoadFontInfo(const char* filename) {
fontinfo.name = font_name;
fontinfo.properties = 0;
fontinfo.universal_id = 0;
if (tfscanf(fp, "%1024s %i %i %i %i %i\n", font_name,
&italic, &bold, &fixed, &serif, &fraktur) != 6)
if (tfscanf(fp, "%1024s %i %i %i %i %i\n", font_name, &italic, &bold,
&fixed, &serif, &fraktur) != 6) {
delete[] font_name;
continue;
}
fontinfo.properties =
(italic << 0) +
(bold << 1) +
@ -373,6 +375,8 @@ bool MasterTrainer::LoadFontInfo(const char* filename) {
(fraktur << 4);
if (!fontinfo_table_.contains(fontinfo)) {
fontinfo_table_.push_back(fontinfo);
} else {
delete[] font_name;
}
}
fclose(fp);

5
classify/mfoutline.cpp
View File

@ -35,7 +35,8 @@
----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/** Convert a blob into a list of MFOUTLINEs (float-based microfeature format). */
/** Convert a blob into a list of MFOUTLINEs (float-based microfeature format).
*/
LIST ConvertBlob(TBLOB *blob) {
LIST outlines = NIL_LIST;
return (blob == NULL)
@ -344,7 +345,6 @@ void ChangeDirection(MFOUTLINE Start, MFOUTLINE End, DIRECTION Direction) {
} /* ChangeDirection */
/**
* This routine normalizes each point in Outline by
* translating it to the specified center and scaling it
@ -378,7 +378,6 @@ void CharNormalizeOutline(MFOUTLINE Outline, const DENORM& cn_denorm) {
} /* CharNormalizeOutline */
/**
* This routine computes the slope from Start to Finish and
* and then computes the approximate direction of the line

2
classify/mfx.cpp
View File

@ -128,7 +128,6 @@ FLOAT32 ComputeOrientation(MFEDGEPT *Start, MFEDGEPT *End) {
return (Orientation);
} /* ComputeOrientation */
/**
* Convert Outline to MicroFeatures
* @param Outline outline to extract micro-features from
@ -164,7 +163,6 @@ MICROFEATURES ConvertToMicroFeatures(MFOUTLINE Outline,
return (MicroFeatures);
} /* ConvertToMicroFeatures */
/**
* This routine computes the feature parameters which describe
* the micro-feature that starts and Start and ends at End.

1
classify/normfeat.cpp
View File

@ -33,7 +33,6 @@ FLOAT32 ActualOutlineLength(FEATURE Feature) {
return (Feature->Params[CharNormLength] * LENGTH_COMPRESSION);
}
/**
* Return the character normalization feature for a blob.
*

17
classify/ocrfeatures.cpp
View File

@ -66,7 +66,6 @@ void FreeFeature(FEATURE Feature) {
} /* FreeFeature */
/**
* Release the memory consumed by the specified feature
* set. This routine also frees the memory consumed by the
@ -85,7 +84,6 @@ void FreeFeatureSet(FEATURE_SET FeatureSet) {
}
} /* FreeFeatureSet */
/**
* Allocate and return a new feature of the specified
* type.
@ -105,7 +103,6 @@ FEATURE NewFeature(const FEATURE_DESC_STRUCT* FeatureDesc) {
} /* NewFeature */
/**
* Allocate and return a new feature set large enough to
* hold the specified number of features.
@ -124,7 +121,6 @@ FEATURE_SET NewFeatureSet(int NumFeatures) {
} /* NewFeatureSet */
/**
* Create a new feature of the specified type and read in
* the value of its parameters from File. The extra penalty
@ -135,10 +131,11 @@ FEATURE_SET NewFeatureSet(int NumFeatures) {
* @param File open text file to read feature from
* @param FeatureDesc specifies type of feature to read from File
* @return New #FEATURE read from File.
* @note Exceptions: #ILLEGAL_FEATURE_PARAM if text file doesn't match expected format
* @note Exceptions: #ILLEGAL_FEATURE_PARAM if text file doesn't match expected
* format
* @note History: Wed May 23 08:53:16 1990, DSJ, Created.
*/
FEATURE ReadFeature(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
FEATURE ReadFeature(FILE* File, const FEATURE_DESC_STRUCT* FeatureDesc) {
FEATURE Feature;
int i;
@ -153,7 +150,6 @@ FEATURE ReadFeature(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
return (Feature);
} /* ReadFeature */
/**
* Create a new feature set of the specified type and read in
* the features from File. The correct text representation
@ -165,7 +161,7 @@ FEATURE ReadFeature(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
* @return New feature set read from File.
* @note History: Wed May 23 09:17:31 1990, DSJ, Created.
*/
FEATURE_SET ReadFeatureSet(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
FEATURE_SET ReadFeatureSet(FILE* File, const FEATURE_DESC_STRUCT* FeatureDesc) {
FEATURE_SET FeatureSet;
int NumFeatures;
int i;
@ -180,7 +176,6 @@ FEATURE_SET ReadFeatureSet(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
return (FeatureSet);
} /* ReadFeatureSet */
/**
* Appends a textual representation of Feature to str.
* This representation is simply a list of the N parameters
@ -203,7 +198,6 @@ void WriteFeature(FEATURE Feature, STRING* str) {
*str += "\n";
} /* WriteFeature */
/**
* Write a textual representation of FeatureSet to File.
* This representation is an integer specifying the number of
@ -224,7 +218,6 @@ void WriteFeatureSet(FEATURE_SET FeatureSet, STRING* str) {
}
} /* WriteFeatureSet */
/**
* Write a textual representation of FeatureDesc to File
* in the old format (i.e. the format used by the clusterer).
@ -240,7 +233,7 @@ void WriteFeatureSet(FEATURE_SET FeatureSet, STRING* str) {
* @return none
* @note History: Fri May 25 15:27:18 1990, DSJ, Created.
*/
void WriteOldParamDesc(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
void WriteOldParamDesc(FILE* File, const FEATURE_DESC_STRUCT* FeatureDesc) {
int i;
fprintf (File, "%d\n", FeatureDesc->NumParams);

2
classify/shapeclassifier.cpp
View File

@ -176,7 +176,7 @@ void ShapeClassifier::UnicharPrintResults(
for (int i = 0; i < results.size(); ++i) {
tprintf("%g: c_id=%d=%s", results[i].rating, results[i].unichar_id,
GetUnicharset().id_to_unichar(results[i].unichar_id));
if (results[i].fonts.size() != 0) {
if (!results[i].fonts.empty()) {
tprintf(" Font Vector:");
for (int f = 0; f < results[i].fonts.size(); ++f) {
tprintf(" %d", results[i].fonts[f].fontinfo_id);

2
cube/cube_search_object.cpp
View File

@ -400,7 +400,7 @@ bool CubeSearchObject::ComputeSpaceCosts() {
float prob = 0.0;
// gap is too small => no space
if (gap < min_spc_gap_) {
if (gap < min_spc_gap_ || max_spc_gap_ == min_spc_gap_) {
prob = 0.0;
} else if (gap > max_spc_gap_) {
// gap is too big => definite space

2
cube/hybrid_neural_net_classifier.cpp
View File

@ -330,7 +330,7 @@ bool HybridNeuralNetCharClassifier::LoadNets(const string &data_file_path,
// split into lines
vector<string> str_vec;
CubeUtils::SplitStringUsing(str, "\r\n", &str_vec);
if (str_vec.size() <= 0) {
if (str_vec.empty()) {
return false;
}

2
cube/word_unigrams.cpp
View File

@ -163,7 +163,7 @@ int WordUnigrams::Cost(const char_32 *key_str32,
CubeUtils::SplitStringUsing(key_str, " \t", &words);
// no words => no cost
if (words.size() <= 0) {
if (words.empty()) {
return 0;
}

42
cutil/bitvec.h
View File

@ -30,29 +30,29 @@ typedef uinT32 *BIT_VECTOR;
/*-----------------------------------------------------------------------------
Public Function Prototypes
-----------------------------------------------------------------------------*/
#define zero_all_bits(array,length) \
{\
int index; /*temporary index*/\
\
for (index=0;index<length;index++)\
array[index]=0; /*zero all bits*/\
}
#define zero_all_bits(array, length) \
{ \
int index; /*temporary index*/ \
\
for (index = 0; index < length; index++) \
array[index] = 0; /*zero all bits*/ \
}
#define set_all_bits(array,length) \
{\
int index; /*temporary index*/\
\
for (index=0;index<length;index++)\
array[index]= ~0; /*set all bits*/\
}
#define set_all_bits(array, length) \
{ \
int index; /*temporary index*/ \
\
for (index = 0; index < length; index++) \
array[index] = ~0; /*set all bits*/ \
}
#define copy_all_bits(source,dest,length) \
{\
int index; /*temporary index*/\
\
for (index=0;index<length;index++)\
dest[index]=source[index]; /*copy all bits*/\
}
#define copy_all_bits(source, dest, length) \
{ \
int index; /*temporary index*/ \
\
for (index = 0; index < length; index++) \
dest[index] = source[index]; /*copy all bits*/ \
}
#define SET_BIT(array,bit) (array[bit/BITSINLONG]|=1<<(bit&(BITSINLONG-1)))

4
cutil/oldlist.cpp
View File

@ -206,8 +206,8 @@ void destroy_nodes(LIST list, void_dest destructor) {
destructor = memfree;
while (list != NIL_LIST) {
(*destructor) (first_node (list));
list = pop (list);
if (first_node(list) != NULL) (*destructor)(first_node(list));
list = pop(list);
}
}

34
dict/context.cpp
View File

@ -32,28 +32,22 @@ namespace tesseract {
static const int kMinAbsoluteGarbageWordLength = 10;
static const float kMinAbsoluteGarbageAlphanumFrac = 0.5f;
const int case_state_table[6][4] = { {
/* 0. Beginning of word */
const int case_state_table[6][4] = {
{/* 0. Beginning of word */
/* P U L D */
/* -1. Error on case */
0, 1, 5, 4
},
{ /* 1. After initial capital */
0, 3, 2, 4
},
{ /* 2. After lower case */
0, -1, 2, -1
},
{ /* 3. After upper case */
0, 3, -1, 4
},
{ /* 4. After a digit */
0, -1, -1, 4
},
{ /* 5. After initial lower case */
5, -1, 2, -1
},
};
0, 1, 5, 4},
{/* 1. After initial capital */
0, 3, 2, 4},
{/* 2. After lower case */
0, -1, 2, -1},
{/* 3. After upper case */
0, 3, -1, 4},
{/* 4. After a digit */
0, -1, -1, 4},
{/* 5. After initial lower case */
5, -1, 2, -1},
};
int Dict::case_ok(const WERD_CHOICE &word, const UNICHARSET &unicharset) {
int state = 0;

54
dict/dict.cpp
View File

@ -30,13 +30,12 @@ namespace tesseract {
class Image;
Dict::Dict(CCUtil* ccutil)
Dict::Dict(CCUtil *ccutil)
: letter_is_okay_(&tesseract::Dict::def_letter_is_okay),
probability_in_context_(&tesseract::Dict::def_probability_in_context),
params_model_classify_(NULL),
ccutil_(ccutil),
STRING_MEMBER(user_words_file, "",
"A filename of user-provided words.",
STRING_MEMBER(user_words_file, "", "A filename of user-provided words.",
getCCUtil()->params()),
STRING_INIT_MEMBER(user_words_suffix, "",
"A suffix of user-provided words located in tessdata.",
@ -54,26 +53,34 @@ Dict::Dict(CCUtil* ccutil)
getCCUtil()->params()),
BOOL_INIT_MEMBER(load_unambig_dawg, true, "Load unambiguous word dawg.",
getCCUtil()->params()),
BOOL_INIT_MEMBER(load_punc_dawg, true, "Load dawg with punctuation"
" patterns.", getCCUtil()->params()),
BOOL_INIT_MEMBER(load_number_dawg, true, "Load dawg with number"
" patterns.", getCCUtil()->params()),
BOOL_INIT_MEMBER(load_bigram_dawg, true, "Load dawg with special word "
"bigrams.", getCCUtil()->params()),
BOOL_INIT_MEMBER(load_punc_dawg, true,
"Load dawg with punctuation"
" patterns.",
getCCUtil()->params()),
BOOL_INIT_MEMBER(load_number_dawg, true,
"Load dawg with number"
" patterns.",
getCCUtil()->params()),
BOOL_INIT_MEMBER(load_bigram_dawg, true,
"Load dawg with special word "
"bigrams.",
getCCUtil()->params()),
double_MEMBER(xheight_penalty_subscripts, 0.125,
"Score penalty (0.1 = 10%) added if there are subscripts "
"or superscripts in a word, but it is otherwise OK.",
getCCUtil()->params()),
double_MEMBER(xheight_penalty_inconsistent, 0.25,
"Score penalty (0.1 = 10%) added if an xheight is "
"inconsistent.", getCCUtil()->params()),
"inconsistent.",
getCCUtil()->params()),
double_MEMBER(segment_penalty_dict_frequent_word, 1.0,
"Score multiplier for word matches which have good case and"
"are frequent in the given language (lower is better).",
getCCUtil()->params()),
double_MEMBER(segment_penalty_dict_case_ok, 1.1,
"Score multiplier for word matches that have good case "
"(lower is better).", getCCUtil()->params()),
"(lower is better).",
getCCUtil()->params()),
double_MEMBER(segment_penalty_dict_case_bad, 1.3125,
"Default score multiplier for word matches, which may have "
"case issues (lower is better).",
@ -88,11 +95,13 @@ Dict::Dict(CCUtil* ccutil)
double_MEMBER(segment_penalty_garbage, 1.50,
"Score multiplier for poorly cased strings that are not in"
" the dictionary and generally look like garbage (lower is"
" better).", getCCUtil()->params()),
" better).",
getCCUtil()->params()),
STRING_MEMBER(output_ambig_words_file, "",
"Output file for ambiguities found in the dictionary",
getCCUtil()->params()),
INT_MEMBER(dawg_debug_level, 0, "Set to 1 for general debug info"
INT_MEMBER(dawg_debug_level, 0,
"Set to 1 for general debug info"
", to 2 for more details, to 3 to see all the debug messages",
getCCUtil()->params()),
INT_MEMBER(hyphen_debug_level, 0, "Debug level for hyphenated words.",
@ -109,12 +118,12 @@ Dict::Dict(CCUtil* ccutil)
"Certainty threshold for non-dict words",
getCCUtil()->params()),
double_MEMBER(stopper_phase2_certainty_rejection_offset, 1.0,
"Reject certainty offset",
getCCUtil()->params()),
"Reject certainty offset", getCCUtil()->params()),
INT_MEMBER(stopper_smallword_size, 2,
"Size of dict word to be treated as non-dict word",
getCCUtil()->params()),
double_MEMBER(stopper_certainty_per_char, -0.50, "Certainty to add"
double_MEMBER(stopper_certainty_per_char, -0.50,
"Certainty to add"
" for each dict char above small word size.",
getCCUtil()->params()),
double_MEMBER(stopper_allowable_character_badness, 3.0,
@ -130,9 +139,9 @@ Dict::Dict(CCUtil* ccutil)
"Deprecated- backward compatibility only",
getCCUtil()->params()),
INT_MEMBER(tessedit_truncate_wordchoice_log, 10,
"Max words to keep in list",
getCCUtil()->params()),
STRING_MEMBER(word_to_debug, "", "Word for which stopper debug"
"Max words to keep in list", getCCUtil()->params()),
STRING_MEMBER(word_to_debug, "",
"Word for which stopper debug"
" information should be printed to stdout",
getCCUtil()->params()),
STRING_MEMBER(word_to_debug_lengths, "",
@ -152,8 +161,10 @@ Dict::Dict(CCUtil* ccutil)
getCCUtil()->params()),
double_MEMBER(doc_dict_certainty_threshold, -2.25,
"Worst certainty for words that can be inserted into the"
"document dictionary", getCCUtil()->params()),
INT_MEMBER(max_permuter_attempts, 10000, "Maximum number of different"
"document dictionary",
getCCUtil()->params()),
INT_MEMBER(max_permuter_attempts, 10000,
"Maximum number of different"
" character choices to consider during permutation."
" This limit is especially useful when user patterns"
" are specified, since overly generic patterns can result in"
@ -179,6 +190,7 @@ Dict::Dict(CCUtil* ccutil)
}
Dict::~Dict() {
End();
if (hyphen_word_ != NULL) delete hyphen_word_;
if (output_ambig_words_file_ != NULL) fclose(output_ambig_words_file_);
}

1
dict/stopper.cpp
View File

@ -41,7 +41,6 @@
#pragma warning(disable:4800) // int/bool warnings
#endif
using tesseract::ScriptPos;
/*----------------------------------------------------------------------------
Private Code
----------------------------------------------------------------------------*/

6
opencl/oclkernels.h
View File

@ -1092,7 +1092,8 @@ void kernel_ThresholdRectToPix(
for ( int c = 0; c < NUM_CHANNELS; c++) {
unsigned char pixChan = pixels.s[p*NUM_CHANNELS + c];
if (pHi_Values[c] >= 0 && (pixChan > pThresholds[c]) == (pHi_Values[c] == 0)) {
word |= (((uint)0x80000000) >> ((b*PIXELS_PER_BURST+p)&31));
const uint kTopBit = 0x80000000;
word |= (kTopBit >> ((b*PIXELS_PER_BURST+p)&31));
}
}
}
@ -1157,7 +1158,8 @@ void kernel_ThresholdRectToPix_OneChan(
\n#endif\n
unsigned char pixChan = pixels.s[idx];
if (pHi_Values[0] >= 0 && (pixChan > pThresholds[0]) == (pHi_Values[0] == 0)) {
word |= (0x80000000 >> ((b*PIXELS_PER_BURST+p)&31));
const uint kTopBit = 0x80000000;
word |= (kTopBit >> ((b*PIXELS_PER_BURST+p)&31));
}
}
}

6
opencl/opencl_device_selection.h
View File

@ -63,8 +63,10 @@ static ds_status releaseDSProfile(ds_profile* profile, ds_score_release sr) {
if (profile->devices!=NULL && sr!=NULL) {
unsigned int i;
for (i = 0; i < profile->numDevices; i++) {
if (profile->devices[i].oclDeviceName) free(profile->devices[i].oclDeviceName);
if (profile->devices[i].oclDriverVersion) free(profile->devices[i].oclDriverVersion);
if (profile->devices[i].oclDeviceName)
free(profile->devices[i].oclDeviceName);
if (profile->devices[i].oclDriverVersion)
free(profile->devices[i].oclDriverVersion);
status = sr(profile->devices[i].score);
if (status != DS_SUCCESS)
break;

1112
opencl/openclwrapper.cpp
View File

File diff suppressed because it is too large Load Diff

69
opencl/openclwrapper.h
View File

@ -10,7 +10,8 @@
// including CL/cl.h doesn't occur until USE_OPENCL defined below
// platform preprocessor commands
#if defined( WIN32 ) || defined( __WIN32__ ) || defined( _WIN32 ) || defined( __CYGWIN__ ) || defined( __MINGW32__ )
#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || \
defined(__CYGWIN__) || defined(__MINGW32__)
#define ON_WINDOWS 1
#define ON_LINUX 0
#define ON_APPLE 0
@ -82,7 +83,8 @@
#define PERF_COUNT_END \
QueryPerformanceCounter(&time_funct_end); \
elapsed_time_sec = (time_funct_end.QuadPart-time_funct_start.QuadPart)/(double)(freq.QuadPart); \
elapsed_time_sec = (time_funct_end.QuadPart - time_funct_start.QuadPart) / \
(double)(freq.QuadPart); \
printf(PERF_COUNT_REPORT_STR, funct_name, "total", elapsed_time_sec);
#else
#define PERF_COUNT_START(FUNCT_NAME)
@ -92,7 +94,8 @@
#if PERF_COUNT_VERBOSE >= 3
#define PERF_COUNT_SUB(SUB) \
QueryPerformanceCounter(&time_sub_end); \
elapsed_time_sec = (time_sub_end.QuadPart-time_sub_start.QuadPart)/(double)(freq.QuadPart); \
elapsed_time_sec = (time_sub_end.QuadPart - time_sub_start.QuadPart) / \
(double)(freq.QuadPart); \
printf(PERF_COUNT_REPORT_STR, funct_name, SUB, elapsed_time_sec); \
time_sub_start = time_sub_end;
#else
@ -113,8 +116,10 @@
time_sub_end = time_funct_start;
#define PERF_COUNT_END \
clock_gettime( CLOCK_MONOTONIC, &time_funct_end ); \
elapsed_time_sec = (time_funct_end.tv_sec - time_funct_start.tv_sec)*1.0 + (time_funct_end.tv_nsec - time_funct_start.tv_nsec)/1000000000.0; \
clock_gettime(CLOCK_MONOTONIC, &time_funct_end); \
elapsed_time_sec = \
(time_funct_end.tv_sec - time_funct_start.tv_sec) * 1.0 + \
(time_funct_end.tv_nsec - time_funct_start.tv_nsec) / 1000000000.0; \
printf(PERF_COUNT_REPORT_STR, funct_name, "total", elapsed_time_sec);
#else
#define PERF_COUNT_START(FUNCT_NAME)
@ -123,8 +128,10 @@
#if PERF_COUNT_VERBOSE >= 3
#define PERF_COUNT_SUB(SUB) \
clock_gettime( CLOCK_MONOTONIC, &time_sub_end ); \
elapsed_time_sec = (time_sub_end.tv_sec - time_sub_start.tv_sec)*1.0 + (time_sub_end.tv_nsec - time_sub_start.tv_nsec)/1000000000.0; \
clock_gettime(CLOCK_MONOTONIC, &time_sub_end); \
elapsed_time_sec = \
(time_sub_end.tv_sec - time_sub_start.tv_sec) * 1.0 + \
(time_sub_end.tv_nsec - time_sub_start.tv_nsec) / 1000000000.0; \
printf(PERF_COUNT_REPORT_STR, funct_name, SUB, elapsed_time_sec); \
time_sub_start = time_sub_end;
#else
@ -253,12 +260,12 @@ public:
// OpenCL implementation of Morphology (Hollow = Closed - Open)
static PIX* pixHollowCL(PIX *pixd, PIX *pixs, l_int32 close_hsize, l_int32 close_vsize, l_int32 open_hsize, l_int32 open_vsize, bool reqDataCopy);
static void pixGetLinesCL(PIX *pixd, PIX *pixs,
PIX** pix_vline, PIX** pix_hline,
PIX** pixClosed, bool getpixClosed,
l_int32 close_hsize, l_int32 close_vsize,
l_int32 open_hsize, l_int32 open_vsize,
l_int32 line_hsize, l_int32 line_vsize);
static void pixGetLinesCL(PIX *pixd, PIX *pixs, PIX **pix_vline,
PIX **pix_hline, PIX **pixClosed,
bool getpixClosed, l_int32 close_hsize,
l_int32 close_vsize, l_int32 open_hsize,
l_int32 open_vsize, l_int32 line_hsize,
l_int32 line_vsize);
//int InitOpenclAttr( OpenCLEnv * env );
//int ReleaseKernel( KernelEnv * env );
@ -279,34 +286,24 @@ public:
static void FreeOpenclDll();
#endif
inline static int AddKernelConfig( int kCount, const char *kName );
/* for binarization */
static int HistogramRectOCL(
const unsigned char *imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left,
int top,
int width,
int height,
int kHistogramSize,
int *histogramAllChannels);
static int HistogramRectOCL(const unsigned char *imagedata,
int bytes_per_pixel, int bytes_per_line,
int left, int top, int width, int height,
int kHistogramSize, int *histogramAllChannels);
static int ThresholdRectToPixOCL(
const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
const int* thresholds,
const int* hi_values,
Pix** pix,
int rect_height,
int rect_width,
int rect_top,
int rect_left);
static int ThresholdRectToPixOCL(const unsigned char *imagedata,
int bytes_per_pixel, int bytes_per_line,
const int *thresholds,
const int *hi_values, Pix **pix,
int rect_height, int rect_width,
int rect_top, int rect_left);
static Pix * pixConvertRGBToGrayOCL( Pix *pix, float weightRed = 0.3, float weightGreen = 0.5, float weightBlue = 0.2 );
static Pix *pixConvertRGBToGrayOCL(Pix *pix, float weightRed = 0.3,
float weightGreen = 0.5,
float weightBlue = 0.2);
static ds_device getDeviceSelection();
static ds_device selectedDevice;

2
textord/alignedblob.cpp
View File

@ -188,7 +188,7 @@ ScrollView* AlignedBlob::DisplayTabs(const char* window_name,
gsearch.StartFullSearch();
BLOBNBOX* bbox;
while ((bbox = gsearch.NextFullSearch()) != NULL) {
TBOX box = bbox->bounding_box();
const TBOX& box = bbox->bounding_box();
int left_x = box.left();
int right_x = box.right();
int top_y = box.top();

4
textord/bbgrid.cpp
View File

@ -231,7 +231,7 @@ Pix* GridReducedPix(const TBOX& box, int gridsize,
// Note that the Pix is used upside-down, with (0, 0) being the bottom-left.
Pix* TraceOutlineOnReducedPix(C_OUTLINE* outline, int gridsize,
ICOORD bleft, int* left, int* bottom) {
TBOX box = outline->bounding_box();
const TBOX& box = outline->bounding_box();
Pix* pix = GridReducedPix(box, gridsize, bleft, left, bottom);
int wpl = pixGetWpl(pix);
l_uint32* data = pixGetData(pix);
@ -257,7 +257,7 @@ Pix* TraceOutlineOnReducedPix(C_OUTLINE* outline, int gridsize,
// As TraceOutlineOnReducedPix above, but on a BLOCK instead of a C_OUTLINE.
Pix* TraceBlockOnReducedPix(BLOCK* block, int gridsize,
ICOORD bleft, int* left, int* bottom) {
TBOX box = block->bounding_box();
const TBOX& box = block->bounding_box();
Pix* pix = GridReducedPix(box, gridsize, bleft, left, bottom);
int wpl = pixGetWpl(pix);
l_uint32* data = pixGetData(pix);

2
textord/bbgrid.h
View File

@ -623,7 +623,7 @@ void BBGrid<BBC, BBC_CLIST, BBC_C_IT>::DisplayBoxes(ScrollView* tab_win) {
gsearch.StartFullSearch();
BBC* bbox;
while ((bbox = gsearch.NextFullSearch()) != NULL) {
TBOX box = bbox->bounding_box();
const TBOX& box = bbox->bounding_box();
int left_x = box.left();
int right_x = box.right();
int top_y = box.top();

2
textord/ccnontextdetect.cpp
View File

@ -305,7 +305,7 @@ bool CCNonTextDetect::BlobOverlapsTooMuch(BLOBNBOX* blob, int max_overlaps) {
// Search the grid to see what intersects it.
// Setup a Rectangle search for overlapping this blob.
BlobGridSearch rsearch(this);
TBOX box = blob->bounding_box();
const TBOX& box = blob->bounding_box();
rsearch.StartRectSearch(box);
rsearch.SetUniqueMode(true);
BLOBNBOX* neighbour;

8
textord/colpartition.cpp
View File

@ -918,7 +918,7 @@ void ColPartition::ComputeLimits() {
for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
bbox = it.data();
if (non_leader_count == 0 || bbox->flow() != BTFT_LEADER) {
TBOX box = bbox->bounding_box();
const TBOX& box = bbox->bounding_box();
int area = box.area();
top_stats.add(box.top(), area);
bottom_stats.add(box.bottom(), area);
@ -1181,8 +1181,8 @@ bool ColPartition::MarkAsLeaderIfMonospaced() {
if (best_end == NULL) {
tprintf("No path\n");
} else {
tprintf("Total cost = %d vs allowed %d\n",
best_end->total_cost(), blob_count);
tprintf("Total cost = %d vs allowed %d\n", best_end->total_cost(),
blob_count);
}
}
delete [] projection;
@ -2121,7 +2121,7 @@ void ColPartition::RefinePartnersByOverlap(bool upper,
// Return true if bbox belongs better in this than other.
bool ColPartition::ThisPartitionBetter(BLOBNBOX* bbox,
const ColPartition& other) {
TBOX box = bbox->bounding_box();
const TBOX& box = bbox->bounding_box();
// Margins take priority.
int left = box.left();
int right = box.right();

10
textord/colpartitiongrid.cpp
View File

@ -86,7 +86,7 @@ void ColPartitionGrid::HandleClick(int x, int y) {
ColPartition* neighbour;
FCOORD click(x, y);
while ((neighbour = radsearch.NextRadSearch()) != NULL) {
TBOX nbox = neighbour->bounding_box();
const TBOX& nbox = neighbour->bounding_box();
if (nbox.contains(click)) {
tprintf("Block box:");
neighbour->bounding_box().print();
@ -1037,7 +1037,7 @@ void ColPartitionGrid::ListFindMargins(ColPartitionSet** best_columns,
ColPartition* part = part_it.data();
ColPartitionSet* columns = NULL;
if (best_columns != NULL) {
TBOX part_box = part->bounding_box();
const TBOX& part_box = part->bounding_box();
// Get the columns from the y grid coord.
int grid_x, grid_y;
GridCoords(part_box.left(), part_box.bottom(), &grid_x, &grid_y);
@ -1569,7 +1569,7 @@ BlobRegionType ColPartitionGrid::SmoothInOneDirection(
const TBOX& im_box, const FCOORD& rerotation,
bool debug, const ColPartition& part, int* best_distance) {
// Set up a rectangle search bounded by the part.
TBOX part_box = part.bounding_box();
const TBOX& part_box = part.bounding_box();
TBOX search_box;
ICOORD dist_scaling;
ComputeSearchBoxAndScaling(direction, part_box, gridsize(),
@ -1619,10 +1619,10 @@ BlobRegionType ColPartitionGrid::SmoothInOneDirection(
image_bias - htext_score >= kSmoothDecisionMargin &&
image_bias - vtext_score >= kSmoothDecisionMargin) {
*best_distance = dists[NPT_IMAGE][0];
if (dists[NPT_WEAK_VTEXT].size() > 0 &&
if (!dists[NPT_WEAK_VTEXT].empty() &&
*best_distance > dists[NPT_WEAK_VTEXT][0])
*best_distance = dists[NPT_WEAK_VTEXT][0];
if (dists[NPT_WEAK_HTEXT].size() > 0 &&
if (!dists[NPT_WEAK_HTEXT].empty() &&
*best_distance > dists[NPT_WEAK_HTEXT][0])
*best_distance = dists[NPT_WEAK_HTEXT][0];
return BRT_POLYIMAGE;

4
textord/devanagari_processing.h
View File

@ -41,9 +41,7 @@ class PixelHistogram {
length_ = 0;
}
int* hist() const {
return hist_;
}
int* hist() const { return hist_; }
int length() const {
return length_;

3
textord/drawedg.h
View File

@ -1,6 +1,7 @@
/**********************************************************************
* File: drawedg.h (Formerly drawedge.h)
* Description: Collection of functions to draw things to do with edge detection.
* Description: Collection of functions to draw things to do with edge
*detection.
* Author: Ray Smith
* Created: Thu Jun 06 13:29:20 BST 1991
*

1
textord/fpchop.cpp
View File

@ -730,7 +730,6 @@ C_OUTLINE *join_chopped_fragments( //join pieces
return NULL;
}
/**********************************************************************
* join_segments
*

4
textord/imagefind.cpp
View File

@ -1115,7 +1115,7 @@ static bool TestWeakIntersectedPart(const TBOX& im_box,
ColPartition* part) {
if (part->flow() < BTFT_STRONG_CHAIN) {
// A weak partition intersects the box.
TBOX part_box = part->bounding_box();
const TBOX& part_box = part->bounding_box();
if (im_box.contains(part_box)) {
int area = part_box.area();
int intersect_area = IntersectArea(part_box, part_list);
@ -1180,7 +1180,7 @@ static bool ScanForOverlappingText(ColPartitionGrid* part_grid, TBOX* box) {
part->flow() == BTFT_STRONG_CHAIN) {
// Text intersects the box.
any_text_in_padded_rect = true;
TBOX part_box = part->bounding_box();
const TBOX& part_box = part->bounding_box();
if (box->overlap(part_box)) {
return true;
}

4
textord/makerow.cpp
View File

@ -671,7 +671,7 @@ BOOL8 find_best_dropout_row( //find neighbours
TO_ROW_IT *row_it, //current position
BOOL8 testing_on //correct orientation
) {
inT32 next_index; //of neighbouring row
inT32 next_index; // of neighbouring row
inT32 row_offset; //from current row
inT32 abs_dist; //absolute distance
inT8 row_inc; //increment to row_index
@ -1786,7 +1786,7 @@ static int CountOverlaps(const TBOX& box, int min_height,
BLOBNBOX_IT blob_it(blobs);
for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
BLOBNBOX* blob = blob_it.data();
TBOX blob_box = blob->bounding_box();
const TBOX &blob_box = blob->bounding_box();
if (blob_box.height() >= min_height && box.major_overlap(blob_box)) {
++overlaps;
}

65
textord/oldbasel.cpp
View File

@ -122,7 +122,7 @@ void Textord::correlate_lines(TO_BLOCK *block, float gradient) {
TO_ROW **rows; //array of ptrs
int rowcount; /*no of rows to do */
int rowindex; /*no of row */
//iterator
// iterator
TO_ROW_IT row_it = block->get_rows ();
rowcount = row_it.length ();
@ -1018,61 +1018,6 @@ int *partcount /*no of partitions */
return bestpart;
}
///*merge_partitions(partids,partcount,blobcount,bestpart) discards funny looking
//partitions and gives all the rest partid 0*/
//
//merge_partitions(partids,partcount,blobcount,bestpart)
//register char *partids; /*partition numbers*/
//int partcount; /*no of partitions*/
//int blobcount; /*no of blobs*/
//int bestpart; /*best partition*/
//{
// int blobindex; /*no along text line*/
// int runlength; /*run of same partition*/
// int bestrun; /*biggest runlength*/
//
// bestrun=0; /*no runs yet*/
// runlength=1;
// for (blobindex=1;blobindex<blobcount;blobindex++)
// { if (partids[blobindex]!=partids[blobindex-1])
// { if (runlength>bestrun)
// bestrun=runlength; /*find biggest run*/
// runlength=1; /*new run*/
// }
// else
// { runlength++;
// }
// }
// if (runlength>bestrun)
// bestrun=runlength;
//
// for (blobindex=0;blobindex<blobcount;blobindex++)
// { if (blobindex<1
// || partids[blobindex]!=partids[blobindex-1])
// { if ((blobindex+1>=blobcount
// || partids[blobindex]!=partids[blobindex+1])
// /*loner*/
// && (bestrun>2 || partids[blobindex]!=bestpart))
// { partids[blobindex]=partcount; /*discard loner*/
// }
// else if (blobindex+1<blobcount
// && partids[blobindex]==partids[blobindex+1]
// /*pair*/
// && (blobindex+2>=blobcount
// || partids[blobindex]!=partids[blobindex+2])
// && (bestrun>3 || partids[blobindex]!=bestpart))
// { partids[blobindex]=partcount; /*discard both*/
// partids[blobindex+1]=partcount;
// }
// }
// }
// for (blobindex=0;blobindex<blobcount;blobindex++)
// { if (partids[blobindex]<partcount)
// partids[blobindex]=0; /*all others together*/
// }
//}
/**********************************************************************
* partition_coords
*
@ -1414,15 +1359,13 @@ int bestpart /*biggest partition */
bestneg = 0.0; /*no step yet */
for (partition = 0; partition < partcount; partition++) {
if (partition != bestpart) {
//by jetsoft divide by zero possible
if (partsizes[partition]==0)
partsteps[partition]=0;
// by jetsoft divide by zero possible
if (partsizes[partition] == 0)
partsteps[partition] = 0;
else
partsteps[partition] /= partsizes[partition];
//
if (partsteps[partition] >= MINASCRISE
&& partsizes[partition] > poscount) {
poscount = partsizes[partition];

2
textord/pithsync.h
View File

@ -66,7 +66,7 @@ class FPCUTPT
inT16 pitch, //proposed pitch
inT16 pitch_error); //allowed tolerance
inT32 position() { //access func
inT32 position() { // access func
return xpos;
}
double cost_function() {

2
textord/pitsync1.h
View File

@ -46,7 +46,7 @@ class FPSEGPT:public ELIST_LINK
FPSEGPT_LIST *prev_list); //previous segment
FPSEGPT(FPCUTPT *cutpt); //build from new type
inT32 position() { //access func
inT32 position() { // access func
return xpos;
}
double cost_function() {

4
textord/strokewidth.cpp
View File

@ -393,7 +393,7 @@ void StrokeWidth::GradeBlobsIntoPartitions(
}
static void PrintBoxWidths(BLOBNBOX* neighbour) {
TBOX nbox = neighbour->bounding_box();
const TBOX& nbox = neighbour->bounding_box();
tprintf("Box (%d,%d)->(%d,%d): h-width=%.1f, v-width=%.1f p-width=%1.f\n",
nbox.left(), nbox.bottom(), nbox.right(), nbox.top(),
neighbour->horz_stroke_width(), neighbour->vert_stroke_width(),
@ -1939,7 +1939,7 @@ ScrollView* StrokeWidth::DisplayGoodBlobs(const char* window_name,
gsearch.StartFullSearch();
BLOBNBOX* bbox;
while ((bbox = gsearch.NextFullSearch()) != NULL) {
TBOX box = bbox->bounding_box();
const TBOX& box = bbox->bounding_box();
int left_x = box.left();
int right_x = box.right();
int top_y = box.top();

4
textord/tabfind.cpp
View File

@ -229,7 +229,7 @@ void TabFind::GutterWidthAndNeighbourGap(int tab_x, int mean_height,
bbox->flow() == BTFT_TEXT_ON_IMAGE, 0.0,
*gutter_width, box.top(), box.bottom());
if (gutter_bbox != NULL) {
TBOX gutter_box = gutter_bbox->bounding_box();
const TBOX& gutter_box = gutter_bbox->bounding_box();
*gutter_width = left ? tab_x - gutter_box.right()
: gutter_box.left() - tab_x;
}
@ -261,7 +261,7 @@ void TabFind::GutterWidthAndNeighbourGap(int tab_x, int mean_height,
int neighbour_edge = left ? RightEdgeForBox(box, true, false)
: LeftEdgeForBox(box, true, false);
if (neighbour != NULL) {
TBOX n_box = neighbour->bounding_box();
const TBOX& n_box = neighbour->bounding_box();
if (debug) {
tprintf("Found neighbour:");
n_box.print();

10
textord/tablefind.cpp
View File

@ -550,7 +550,7 @@ void TableFinder::GroupColumnBlocks(ColSegment_LIST* new_blocks,
// iterate through the source list
for (src_it.mark_cycle_pt(); !src_it.cycled_list(); src_it.forward()) {
ColSegment* src_seg = src_it.data();
TBOX src_box = src_seg->bounding_box();
const TBOX& src_box = src_seg->bounding_box();
bool match_found = false;
// iterate through the destination list to find a matching column block
for (dest_it.mark_cycle_pt(); !dest_it.cycled_list(); dest_it.forward()) {
@ -1342,7 +1342,7 @@ void TableFinder::GetTableRegions(ColSegment_LIST* table_columns,
// create a bool array to hold projection on y-axis
bool* table_region = new bool[page_height];
while ((part = gsearch.NextFullSearch()) != NULL) {
TBOX part_box = part->bounding_box();
const TBOX& part_box = part->bounding_box();
// reset the projection array
for (int i = 0; i < page_height; i++) {
table_region[i] = false;
@ -1974,7 +1974,7 @@ void TableFinder::DisplayColPartitionConnections(
ColPartition* upper_part = part->nearest_neighbor_above();
if (upper_part) {
TBOX upper_box = upper_part->bounding_box();
const TBOX& upper_box = upper_part->bounding_box();
int mid_x = (left_x + right_x) / 2;
int mid_y = (top_y + bottom_y) / 2;
int other_x = (upper_box.left() + upper_box.right()) / 2;
@ -1985,7 +1985,7 @@ void TableFinder::DisplayColPartitionConnections(
}
ColPartition* lower_part = part->nearest_neighbor_below();
if (lower_part) {
TBOX lower_box = lower_part->bounding_box();
const TBOX& lower_box = lower_part->bounding_box();
int mid_x = (left_x + right_x) / 2;
int mid_y = (top_y + bottom_y) / 2;
int other_x = (lower_box.left() + lower_box.right()) / 2;
@ -2098,7 +2098,7 @@ void TableFinder::MakeTableBlocks(ColPartitionGrid* grid,
table_search.StartFullSearch();
ColSegment* table;
while ((table = table_search.NextFullSearch()) != NULL) {
TBOX table_box = table->bounding_box();
const TBOX& table_box = table->bounding_box();
// Start a rect search on table_box
GridSearch<ColPartition, ColPartition_CLIST, ColPartition_C_IT>
rectsearch(grid);

14
textord/tabvector.cpp
View File

@ -435,7 +435,7 @@ bool TabVector::SimilarTo(const ICOORD& vertical,
vsearch.StartVerticalSearch(left, right, top_y);
BLOBNBOX* blob;
while ((blob = vsearch.NextVerticalSearch(true)) != NULL) {
TBOX box = blob->bounding_box();
const TBOX& box = blob->bounding_box();
if (box.top() > bottom_y)
return true; // Nothing found.
if (box.bottom() < top_y)
@ -523,11 +523,11 @@ const char* kAlignmentNames[] = {
// Print basic information about this tab vector.
void TabVector::Print(const char* prefix) {
tprintf("%s %s (%d,%d)->(%d,%d) w=%d s=%d, sort key=%d, boxes=%d,"
tprintf(
"%s %s (%d,%d)->(%d,%d) w=%d s=%d, sort key=%d, boxes=%d,"
" partners=%d\n",
prefix, kAlignmentNames[alignment_],
startpt_.x(), startpt_.y(), endpt_.x(), endpt_.y(),
mean_width_, percent_score_, sort_key_,
prefix, kAlignmentNames[alignment_], startpt_.x(), startpt_.y(),
endpt_.x(), endpt_.y(), mean_width_, percent_score_, sort_key_,
boxes_.length(), partners_.length());
}
@ -806,7 +806,7 @@ bool TabVector::Fit(ICOORD vertical, bool force_parallel) {
// Fit a line to all the boxes in the list.
for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
BLOBNBOX* bbox = it.data();
TBOX box = bbox->bounding_box();
const TBOX& box = bbox->bounding_box();
int x1 = IsRightTab() ? box.right() : box.left();
ICOORD boxpt(x1, box.bottom());
linepoints.Add(boxpt);
@ -831,7 +831,7 @@ bool TabVector::Fit(ICOORD vertical, bool force_parallel) {
int width_count = 0;
for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
BLOBNBOX* bbox = it.data();
TBOX box = bbox->bounding_box();
const TBOX& box = bbox->bounding_box();
mean_width_ += box.width();
++width_count;
int x1 = IsRightTab() ? box.right() : box.left();

2
textord/textlineprojection.cpp
View File

@ -760,7 +760,7 @@ void TextlineProjection::TruncateToImageBounds(TPOINT* pt) const {
pt->y = ClipToRange<int>(pt->y, 0, pixGetHeight(pix_) - 1);
}
#ifdef _MSC_VER
#pragma optimize( "", on )
#pragma optimize("", on)
#endif // _MSC_VER
// Transform tesseract image coordinates to coordinates used in the projection.

118
textord/textord.cpp
View File

@ -33,7 +33,8 @@
namespace tesseract {
Textord::Textord(CCStruct* ccstruct)
: ccstruct_(ccstruct), use_cjk_fp_model_(false),
: ccstruct_(ccstruct),
use_cjk_fp_model_(false),
// makerow.cpp ///////////////////////////////////////////
BOOL_MEMBER(textord_single_height_mode, false,
"Script has no xheight, so use a single mode",
@ -46,24 +47,20 @@ Textord::Textord(CCStruct* ccstruct)
"old_to_method.",
ccstruct_->params()),
BOOL_MEMBER(tosp_only_use_prop_rows, true,
"Block stats to use fixed pitch rows?",
ccstruct_->params()),
"Block stats to use fixed pitch rows?", ccstruct_->params()),
BOOL_MEMBER(tosp_force_wordbreak_on_punct, false,
"Force word breaks on punct to break long lines in non-space "
"delimited langs",
ccstruct_->params()),
BOOL_MEMBER(tosp_use_pre_chopping, false,
"Space stats use prechopping?",
BOOL_MEMBER(tosp_use_pre_chopping, false, "Space stats use prechopping?",
ccstruct_->params()),
BOOL_MEMBER(tosp_old_to_bug_fix, false, "Fix suspected bug in old code",
ccstruct_->params()),
BOOL_MEMBER(tosp_block_use_cert_spaces, true,
"Only stat OBVIOUS spaces",
BOOL_MEMBER(tosp_block_use_cert_spaces, true, "Only stat OBVIOUS spaces",
ccstruct_->params()),
BOOL_MEMBER(tosp_row_use_cert_spaces, true, "Only stat OBVIOUS spaces",
ccstruct_->params()),
BOOL_MEMBER(tosp_narrow_blobs_not_cert, true,
"Only stat OBVIOUS spaces",
BOOL_MEMBER(tosp_narrow_blobs_not_cert, true, "Only stat OBVIOUS spaces",
ccstruct_->params()),
BOOL_MEMBER(tosp_row_use_cert_spaces1, true, "Only stat OBVIOUS spaces",
ccstruct_->params()),
@ -78,30 +75,24 @@ Textord::Textord(CCStruct* ccstruct)
"Don't restrict kn->sp fuzzy limit to tables",
ccstruct_->params()),
BOOL_MEMBER(tosp_stats_use_xht_gaps, true,
"Use within xht gap for wd breaks",
ccstruct_->params()),
"Use within xht gap for wd breaks", ccstruct_->params()),
BOOL_MEMBER(tosp_use_xht_gaps, true, "Use within xht gap for wd breaks",
ccstruct_->params()),
BOOL_MEMBER(tosp_only_use_xht_gaps, false,
"Only use within xht gap for wd breaks",
ccstruct_->params()),
"Only use within xht gap for wd breaks", ccstruct_->params()),
BOOL_MEMBER(tosp_rule_9_test_punct, false,
"Don't chng kn to space next to punct",
ccstruct_->params()),
"Don't chng kn to space next to punct", ccstruct_->params()),
BOOL_MEMBER(tosp_flip_fuzz_kn_to_sp, true, "Default flip",
ccstruct_->params()),
BOOL_MEMBER(tosp_flip_fuzz_sp_to_kn, true, "Default flip",
ccstruct_->params()),
BOOL_MEMBER(tosp_improve_thresh, false, "Enable improvement heuristic",
ccstruct_->params()),
INT_MEMBER(tosp_debug_level, 0, "Debug data",
ccstruct_->params()),
INT_MEMBER(tosp_debug_level, 0, "Debug data", ccstruct_->params()),
INT_MEMBER(tosp_enough_space_samples_for_median, 3,
"or should we use mean",
ccstruct_->params()),
"or should we use mean", ccstruct_->params()),
INT_MEMBER(tosp_redo_kern_limit, 10,
"No.samples reqd to reestimate for row",
ccstruct_->params()),
"No.samples reqd to reestimate for row", ccstruct_->params()),
INT_MEMBER(tosp_few_samples, 40,
"No.gaps reqd with 1 large gap to treat as a table",
ccstruct_->params()),
@ -114,30 +105,24 @@ Textord::Textord(CCStruct* ccstruct)
"Factor for defining space threshold in terms of space and "
"kern sizes",
ccstruct_->params()),
double_MEMBER(tosp_threshold_bias1, 0,
"how far between kern and space?",
double_MEMBER(tosp_threshold_bias1, 0, "how far between kern and space?",
ccstruct_->params()),
double_MEMBER(tosp_threshold_bias2, 0,
"how far between kern and space?",
double_MEMBER(tosp_threshold_bias2, 0, "how far between kern and space?",
ccstruct_->params()),
double_MEMBER(tosp_narrow_fraction, 0.3, "Fract of xheight for narrow",
ccstruct_->params()),
double_MEMBER(tosp_narrow_aspect_ratio, 0.48,
"narrow if w/h less than this",
ccstruct_->params()),
"narrow if w/h less than this", ccstruct_->params()),
double_MEMBER(tosp_wide_fraction, 0.52, "Fract of xheight for wide",
ccstruct_->params()),
double_MEMBER(tosp_wide_aspect_ratio, 0.0, "wide if w/h less than this",
ccstruct_->params()),
double_MEMBER(tosp_fuzzy_space_factor, 0.6,
"Fract of xheight for fuzz sp",
ccstruct_->params()),
"Fract of xheight for fuzz sp", ccstruct_->params()),
double_MEMBER(tosp_fuzzy_space_factor1, 0.5,
"Fract of xheight for fuzz sp",
ccstruct_->params()),
"Fract of xheight for fuzz sp", ccstruct_->params()),
double_MEMBER(tosp_fuzzy_space_factor2, 0.72,
"Fract of xheight for fuzz sp",
ccstruct_->params()),
"Fract of xheight for fuzz sp", ccstruct_->params()),
double_MEMBER(tosp_gap_factor, 0.83, "gap ratio to flip sp->kern",
ccstruct_->params()),
double_MEMBER(tosp_kern_gap_factor1, 2.0, "gap ratio to flip kern->sp",
@ -156,14 +141,11 @@ Textord::Textord(CCStruct* ccstruct)
"Fract of kerns reqd for isolated row stats",
ccstruct_->params()),
double_MEMBER(tosp_table_kn_sp_ratio, 2.25,
"Min difference of kn & sp in table",
ccstruct_->params()),
"Min difference of kn & sp in table", ccstruct_->params()),
double_MEMBER(tosp_table_xht_sp_ratio, 0.33,
"Expect spaces bigger than this",
ccstruct_->params()),
"Expect spaces bigger than this", ccstruct_->params()),
double_MEMBER(tosp_table_fuzzy_kn_sp_ratio, 3.0,
"Fuzzy if less than this",
ccstruct_->params()),
"Fuzzy if less than this", ccstruct_->params()),
double_MEMBER(tosp_fuzzy_kn_fraction, 0.5, "New fuzzy kn alg",
ccstruct_->params()),
double_MEMBER(tosp_fuzzy_sp_fraction, 0.5, "New fuzzy sp alg",
@ -172,20 +154,16 @@ Textord::Textord(CCStruct* ccstruct)
"Don't trust spaces less than this time kn",
ccstruct_->params()),
double_MEMBER(tosp_init_guess_kn_mult, 2.2,
"Thresh guess - mult kn by this",
ccstruct_->params()),
"Thresh guess - mult kn by this", ccstruct_->params()),
double_MEMBER(tosp_init_guess_xht_mult, 0.28,
"Thresh guess - mult xht by this",
ccstruct_->params()),
"Thresh guess - mult xht by this", ccstruct_->params()),
double_MEMBER(tosp_max_sane_kn_thresh, 5.0,
"Multiplier on kn to limit thresh",
ccstruct_->params()),
"Multiplier on kn to limit thresh", ccstruct_->params()),
double_MEMBER(tosp_flip_caution, 0.0,
"Don't autoflip kn to sp when large separation",
ccstruct_->params()),
double_MEMBER(tosp_large_kerning, 0.19,
"Limit use of xht gap with large kns",
ccstruct_->params()),
"Limit use of xht gap with large kns", ccstruct_->params()),
double_MEMBER(tosp_dont_fool_with_small_kerns, -1,
"Limit use of xht gap with odd small kns",
ccstruct_->params()),
@ -193,11 +171,9 @@ Textord::Textord(CCStruct* ccstruct)
"Don't reduce box if the top left is non blank",
ccstruct_->params()),
double_MEMBER(tosp_silly_kn_sp_gap, 0.2,
"Don't let sp minus kn get too small",
ccstruct_->params()),
"Don't let sp minus kn get too small", ccstruct_->params()),
double_MEMBER(tosp_pass_wide_fuzz_sp_to_context, 0.75,
"How wide fuzzies need context",
ccstruct_->params()),
"How wide fuzzies need context", ccstruct_->params()),
// tordmain.cpp ///////////////////////////////////////////
BOOL_MEMBER(textord_no_rejects, false, "Don't remove noise blobs",
ccstruct_->params()),
@ -212,28 +188,21 @@ Textord::Textord(CCStruct* ccstruct)
double_MEMBER(textord_blob_size_bigile, 95, "Percentile for large blobs",
ccstruct_->params()),
double_MEMBER(textord_noise_area_ratio, 0.7,
"Fraction of bounding box for noise",
ccstruct_->params()),
"Fraction of bounding box for noise", ccstruct_->params()),
double_MEMBER(textord_blob_size_smallile, 20,
"Percentile for small blobs",
ccstruct_->params()),
"Percentile for small blobs", ccstruct_->params()),
double_MEMBER(textord_initialx_ile, 0.75,
"Ile of sizes for xheight guess",
ccstruct_->params()),
"Ile of sizes for xheight guess", ccstruct_->params()),
double_MEMBER(textord_initialasc_ile, 0.90,
"Ile of sizes for xheight guess",
ccstruct_->params()),
INT_MEMBER(textord_noise_sizefraction, 10,
"Fraction of size for maxima",
"Ile of sizes for xheight guess", ccstruct_->params()),
INT_MEMBER(textord_noise_sizefraction, 10, "Fraction of size for maxima",
ccstruct_->params()),
double_MEMBER(textord_noise_sizelimit, 0.5,
"Fraction of x for big t count",
ccstruct_->params()),
"Fraction of x for big t count", ccstruct_->params()),
INT_MEMBER(textord_noise_translimit, 16, "Transitions for normal blob",
ccstruct_->params()),
double_MEMBER(textord_noise_normratio, 2.0,
"Dot to norm ratio for deletion",
ccstruct_->params()),
"Dot to norm ratio for deletion", ccstruct_->params()),
BOOL_MEMBER(textord_noise_rejwords, true, "Reject noise-like words",
ccstruct_->params()),
BOOL_MEMBER(textord_noise_rejrows, true, "Reject noise-like rows",
@ -242,24 +211,20 @@ Textord::Textord(CCStruct* ccstruct)
"xh fract height error for norm blobs",
ccstruct_->params()),
double_MEMBER(textord_noise_sxfract, 0.4,
"xh fract width error for norm blobs",
ccstruct_->params()),
double_MEMBER(textord_noise_hfract, 1.0/64,
"xh fract width error for norm blobs", ccstruct_->params()),
double_MEMBER(textord_noise_hfract, 1.0 / 64,
"Height fraction to discard outlines as speckle noise",
ccstruct_->params()),
INT_MEMBER(textord_noise_sncount, 1, "super norm blobs to save row",
ccstruct_->params()),
double_MEMBER(textord_noise_rowratio, 6.0,
"Dot to norm ratio for deletion",
ccstruct_->params()),
"Dot to norm ratio for deletion", ccstruct_->params()),
BOOL_MEMBER(textord_noise_debug, false, "Debug row garbage detector",
ccstruct_->params()),
double_MEMBER(textord_blshift_maxshift, 0.00, "Max baseline shift",
ccstruct_->params()),
double_MEMBER(textord_blshift_xfraction, 9.99,
"Min size of baseline shift",
ccstruct_->params()) {
}
"Min size of baseline shift", ccstruct_->params()) {}
Textord::~Textord() {
}
@ -324,10 +289,9 @@ void Textord::TextordPage(PageSegMode pageseg_mode, const FCOORD& reskew,
BaselineDetect baseline_detector(textord_baseline_debug,
reskew, to_blocks);
baseline_detector.ComputeStraightBaselines(use_box_bottoms);
baseline_detector.ComputeBaselineSplinesAndXheights(page_tr_, true,
textord_heavy_nr,
textord_show_final_rows,
this);
baseline_detector.ComputeBaselineSplinesAndXheights(
page_tr_, pageseg_mode != PSM_RAW_LINE, textord_heavy_nr,
textord_show_final_rows, this);
// Now make the words in the lines.
if (PSM_WORD_FIND_ENABLED(pageseg_mode)) {
// SINGLE_LINE uses the old word maker on the single line.

2
textord/topitch.cpp
View File

@ -1084,7 +1084,7 @@ BOOL8 count_pitch_stats( //find lines
return FALSE;
prev_valid = FALSE;
prev_centre = 0;
prev_right = 0; //stop compiler warning
prev_right = 0; // stop compiler warning
joined_box = blob_it.data ()->bounding_box ();
do {
blob_it.forward ();

2
textord/tordmain.cpp
View File

@ -360,7 +360,7 @@ void Textord::cleanup_nontext_block(BLOCK* block) {
// Non-text blocks must contain at least one row.
ROW_IT row_it(block->row_list());
if (row_it.empty()) {
TBOX box = block->bounding_box();
const TBOX& box = block->bounding_box();
float height = box.height();
inT32 xstarts[2] = {box.left(), box.right()};
double coeffs[3] = {0.0, 0.0, static_cast<double>(box.bottom())};

40
textord/tospace.cpp
View File

@ -419,9 +419,8 @@ void Textord::row_spacing_stats(
if (suspected_table &&
(row->space_size < tosp_table_kn_sp_ratio * row->kern_size)) {
if (tosp_debug_level > 5)
tprintf ("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f.\n",
block_idx, row_idx,
row->kern_size, row->space_threshold, row->space_size);
tprintf("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f.\n", block_idx,
row_idx, row->kern_size, row->space_threshold, row->space_size);
row->space_threshold =
(inT32) (tosp_table_kn_sp_ratio * row->kern_size);
row->space_size = MAX (row->space_threshold + 1, row->xheight);
@ -441,8 +440,7 @@ void Textord::row_spacing_stats(
MAX (tosp_min_sane_kn_sp * MAX (row->kern_size, 2.5),
row->xheight / 2);
if (tosp_debug_level > 5)
tprintf
("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f -> %3.2f.\n",
tprintf("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f -> %3.2f.\n",
block_idx, row_idx, row->kern_size, row->space_threshold,
row->space_size, sane_space);
row->space_size = sane_space;
@ -455,10 +453,9 @@ void Textord::row_spacing_stats(
MAX (row->kern_size, 2.5)));
if (row->space_threshold > sane_threshold) {
if (tosp_debug_level > 5)
tprintf ("B:%d R:%d -- DON'T BELIEVE THRESH %3.2f %d %3.2f->%d.\n",
block_idx, row_idx,
row->kern_size,
row->space_threshold, row->space_size, sane_threshold);
tprintf("B:%d R:%d -- DON'T BELIEVE THRESH %3.2f %d %3.2f->%d.\n",
block_idx, row_idx, row->kern_size, row->space_threshold,
row->space_size, sane_threshold);
row->space_threshold = sane_threshold;
if (row->space_size <= sane_threshold)
row->space_size = row->space_threshold + 1.0f;
@ -498,7 +495,7 @@ void Textord::row_spacing_stats(
MIN (inT32 (ceil (tosp_fuzzy_space_factor * row->xheight)),
inT32 (row->space_size));
if (row->min_space <= row->space_threshold)
//Don't be silly
// Don't be silly
row->min_space = row->space_threshold + 1;
/*
Lets try to guess the max certain kern gap by looking at the cluster of
@ -559,7 +556,7 @@ void Textord::row_spacing_stats(
row->kern_size));
}
if (row->max_nonspace > row->space_threshold) {
//Don't be silly
// Don't be silly
row->max_nonspace = row->space_threshold;
}
@ -700,8 +697,8 @@ BOOL8 Textord::isolated_row_stats(TO_ROW *row,
((small_gaps_count / (float) total) < tosp_enough_small_gaps) ||
(total - small_gaps_count < 1)) {
if (tosp_debug_level > 5)
tprintf ("B:%d R:%d -- Can't do isolated row stats.\n",
block_idx, row_idx);
tprintf("B:%d R:%d -- Can't do isolated row stats.\n", block_idx,
row_idx);
return FALSE;
}
blob_it.set_to_list (row->blob_list ());
@ -1130,9 +1127,9 @@ ROW *Textord::make_prop_words(
else
blanks = 0;
if (tosp_debug_level > 5)
tprintf
("Repch wd at EOL (%d,%d). rep spacing %5.2f; Lgap:%d (%d blanks)\n",
word->bounding_box ().left (), word->bounding_box ().bottom (),
tprintf(
"Repch wd at EOL (%d,%d). rep spacing %5.2f; Lgap:%d (%d blanks)\n",
word->bounding_box().left(), word->bounding_box().bottom(),
repetition_spacing, current_gap, blanks);
word->set_blanks (blanks);
//NO uncertainty
@ -1686,10 +1683,9 @@ void Textord::mark_gap(
blob.bottom () + blob.height () / 2.0f);
}
if (tosp_debug_level > 5)
tprintf (" (%d,%d) Sp<->Kn Rule %d %d %d %d %d %d\n",
blob.left () - current_gap / 2, blob.bottom (), rule,
prev_gap, prev_blob_width, current_gap,
next_blob_width, next_gap);
tprintf(" (%d,%d) Sp<->Kn Rule %d %d %d %d %d %d\n",
blob.left() - current_gap / 2, blob.bottom(), rule, prev_gap,
prev_blob_width, current_gap, next_blob_width, next_gap);
}
#endif
@ -1727,8 +1723,7 @@ BOOL8 Textord::ignore_big_gap(TO_ROW *row,
inT16 right) {
inT16 gap = right - left + 1;
if (tosp_ignore_big_gaps > 999)
return FALSE; //Don't ignore
if (tosp_ignore_big_gaps > 999) return FALSE; // Don't ignore
if (tosp_ignore_big_gaps > 0)
return (gap > tosp_ignore_big_gaps * row->xheight);
if (gap > tosp_ignore_very_big_gaps * row->xheight)
@ -1750,7 +1745,6 @@ BOOL8 Textord::ignore_big_gap(TO_ROW *row,
return FALSE;
}
/**********************************************************************
* reduced_box_next
*

6
textord/tovars.cpp
View File

@ -49,8 +49,8 @@ EXTERN double_VAR (textord_words_default_minspace, 0.6,
EXTERN double_VAR (textord_words_min_minspace, 0.3, "Fraction of xheight");
EXTERN double_VAR (textord_words_default_nonspace, 0.2,
"Fraction of xheight");
EXTERN double_VAR (textord_words_initial_lower, 0.25,
"Max initial cluster size");
EXTERN double_VAR(textord_words_initial_lower, 0.25,
"Max initial cluster size");
EXTERN double_VAR (textord_words_initial_upper, 0.15,
"Min initial cluster spacing");
EXTERN double_VAR (textord_words_minlarge, 0.75,
@ -67,7 +67,7 @@ EXTERN double_VAR (textord_pitch_rowsimilarity, 0.08,
"Fraction of xheight for sameness");
EXTERN BOOL_VAR (textord_pitch_scalebigwords, FALSE,
"Scale scores on big words");
EXTERN double_VAR (words_initial_lower, 0.5, "Max initial cluster size");
EXTERN double_VAR(words_initial_lower, 0.5, "Max initial cluster size");
EXTERN double_VAR (words_initial_upper, 0.15, "Min initial cluster spacing");
EXTERN double_VAR (words_default_prop_nonspace, 0.25, "Fraction of xheight");
EXTERN double_VAR (words_default_fixed_space, 0.75, "Fraction of xheight");

Some files were not shown because too many files have changed in this diff Show More