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 9 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: Other Dependencies and Licenses:
================================ ================================
Tesseract uses Leptonica library (http://leptonica.com/) with a very weakly Tesseract uses Leptonica library (http://leptonica.com/) which essentially
restricted copyright license (http://leptonica.com/about-the-license.html) 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_MODULE := tesseract-$(APP_ABI)
LOCAL_STATIC_LIBRARIES := \ LOCAL_STATIC_LIBRARIES := \
mobile_base \ base \
leptonica-$(APP_ABI) leptonica-$(APP_ABI)
LOCAL_C_INCLUDES := $(APP_C_INCLUDES) LOCAL_C_INCLUDES := $(APP_C_INCLUDES)
@ -51,7 +51,6 @@ LOCAL_CFLAGS := -DANDROID_BUILD -DNO_CUBE_BUILD -DGRAPHICS_DISABLED
include $(BUILD_SHARED_LIBRARY) include $(BUILD_SHARED_LIBRARY)
$(call import-module,mobile/base) $(call import-module,base/port)
$(call import-module,mobile/base)
$(call import-module,mobile/util/hash) $(call import-module,mobile/util/hash)
$(call import-module,third_party/leptonica/android/jni) $(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 * has not been subjected to a call of Init, SetImage, Recognize, Clear, End
* DetectOS, or anything else that changes the internal PAGE_RES. * DetectOS, or anything else that changes the internal PAGE_RES.
*/ */
PageIterator* TessBaseAPI::AnalyseLayout() { PageIterator* TessBaseAPI::AnalyseLayout() { return AnalyseLayout(false); }
return AnalyseLayout(false);
}
PageIterator* TessBaseAPI::AnalyseLayout(bool merge_similar_words) { PageIterator* TessBaseAPI::AnalyseLayout(bool merge_similar_words) {
if (FindLines() == 0) { if (FindLines() == 0) {
@ -1379,8 +1377,9 @@ static void AddBaselineCoordsTohOCR(const PageIterator *it,
hocr_str->add_str_double(" ", round(p0 * 1000.0) / 1000.0); 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) { static void AddIdTohOCR(STRING* hocr_str, const std::string base, int num1,
const unsigned long BUFSIZE = 64; int num2) {
const size_t BUFSIZE = 64;
char id_buffer[BUFSIZE]; char id_buffer[BUFSIZE];
if (num2 >= 0) { if (num2 >= 0) {
snprintf(id_buffer, BUFSIZE - 1, "%s_%d_%d", base.c_str(), num1, num2); 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 += "'"; *hocr_str += "'";
} }
static void AddBoxTohOCR(const ResultIterator *it, static void AddBoxTohOCR(const ResultIterator* it, PageIteratorLevel level,
PageIteratorLevel level,
STRING* hocr_str) { STRING* hocr_str) {
int left, top, right, bottom; int left, top, right, bottom;
it->BoundingBox(level, &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 // add custom height measures
float row_height, descenders, ascenders; // row attributes float row_height, descenders, ascenders; // row attributes
it->RowAttributes(&row_height, &descenders, &ascenders); 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_size ", row_height);
hocr_str->add_str_double("; x_descenders ", descenders * -1); hocr_str->add_str_double("; x_descenders ", descenders * -1);
hocr_str->add_str_double("; x_ascenders ", ascenders); hocr_str->add_str_double("; x_ascenders ", ascenders);
@ -1418,8 +1416,7 @@ static void AddBoxTohOCR(const ResultIterator *it,
*hocr_str += "\">"; *hocr_str += "\">";
} }
static void AddBoxToTSV(const PageIterator *it, static void AddBoxToTSV(const PageIterator* it, PageIteratorLevel level,
PageIteratorLevel level,
STRING* hocr_str) { STRING* hocr_str) {
int left, top, right, bottom; int left, top, right, bottom;
it->BoundingBox(level, &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); hocr_str->add_str_int("\t", bottom - top);
} }
/** /**
* Make a HTML-formatted string with hOCR markup from the internal * Make a HTML-formatted string with hOCR markup from the internal
* data structures. * data structures.
@ -1440,7 +1435,7 @@ static void AddBoxToTSV(const PageIterator *it,
* STL removed from original patch submission and refactored by rays. * STL removed from original patch submission and refactored by rays.
*/ */
char* TessBaseAPI::GetHOCRText(int page_number) { 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. * STL removed from original patch submission and refactored by rays.
*/ */
char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) { char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
if (tesseract_ == NULL || if (tesseract_ == NULL || (page_res_ == NULL && Recognize(monitor) < 0))
(page_res_ == NULL && Recognize(monitor) < 0))
return NULL; return NULL;
int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1; int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
@ -1470,13 +1464,13 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
#ifdef _WIN32 #ifdef _WIN32
// convert input name from ANSI encoding to utf-8 // convert input name from ANSI encoding to utf-8
int str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1, int str16_len =
NULL, 0); MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1, NULL, 0);
wchar_t *uni16_str = new WCHAR[str16_len]; wchar_t *uni16_str = new WCHAR[str16_len];
str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1, str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1,
uni16_str, str16_len); uni16_str, str16_len);
int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, NULL, int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, NULL, 0,
0, NULL, NULL); NULL, NULL);
char *utf8_str = new char[utf8_len]; char *utf8_str = new char[utf8_len];
WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, utf8_str, WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, utf8_str,
utf8_len, NULL, NULL); utf8_len, NULL, NULL);
@ -1567,8 +1561,12 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
} }
switch (res_it->WordDirection()) { switch (res_it->WordDirection()) {
// Only emit direction if different from current paragraph direction // 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_LEFT_TO_RIGHT:
case DIR_RIGHT_TO_LEFT: if (para_is_ltr) hocr_str += " dir='rtl'"; break; 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_MIX:
case DIR_NEUTRAL: case DIR_NEUTRAL:
default: // Do nothing. 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. * page_number is 0-based but will appear in the output as 1-based.
*/ */
char* TessBaseAPI::GetTSVText(int page_number) { char* TessBaseAPI::GetTSVText(int page_number) {
if (tesseract_ == NULL || if (tesseract_ == NULL || (page_res_ == NULL && Recognize(NULL) < 0))
(page_res_ == NULL && Recognize(NULL) < 0))
return NULL; return NULL;
int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1; int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
@ -1629,7 +1626,8 @@ char* TessBaseAPI::GetTSVText(int page_number) {
STRING tsv_str(""); 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("1\t", page_num); // level 1 - page
tsv_str.add_str_int("\t", block_num); 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.add_str_int("\t", rect_height_);
tsv_str += "\t-1\t\n"; tsv_str += "\t-1\t\n";
ResultIterator *res_it = GetIterator(); ResultIterator* res_it = GetIterator();
while (!res_it->Empty(RIL_BLOCK)) { while (!res_it->Empty(RIL_BLOCK)) {
if (res_it->Empty(RIL_WORD)) { if (res_it->Empty(RIL_WORD)) {
res_it->Next(RIL_WORD); res_it->Next(RIL_WORD);
@ -1685,11 +1683,11 @@ char* TessBaseAPI::GetTSVText(int page_number) {
int left, top, right, bottom; int left, top, right, bottom;
bool bold, italic, underlined, monospace, serif, smallcaps; bool bold, italic, underlined, monospace, serif, smallcaps;
int pointsize, font_id; int pointsize, font_id;
const char *font_name; const char* font_name;
res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom); res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
font_name = res_it->WordFontAttributes(&bold, &italic, &underlined, font_name =
&monospace, &serif, &smallcaps, res_it->WordFontAttributes(&bold, &italic, &underlined, &monospace,
&pointsize, &font_id); &serif, &smallcaps, &pointsize, &font_id);
word_num++; word_num++;
tsv_str.add_str_int("5\t", page_num); // level 5 - word tsv_str.add_str_int("5\t", page_num); // level 5 - word
tsv_str.add_str_int("\t", block_num); tsv_str.add_str_int("\t", block_num);
@ -1716,7 +1714,7 @@ char* TessBaseAPI::GetTSVText(int page_number) {
wcnt++; wcnt++;
} }
char *ret = new char[tsv_str.length() + 1]; char* ret = new char[tsv_str.length() + 1];
strcpy(ret, tsv_str.string()); strcpy(ret, tsv_str.string());
delete res_it; delete res_it;
return ret; return ret;
@ -1760,7 +1758,7 @@ char* TessBaseAPI::GetBoxText(int page_number) {
int total_length = blob_count * kBytesPerBoxFileLine + utf8_length + int total_length = blob_count * kBytesPerBoxFileLine + utf8_length +
kMaxBytesPerLine; kMaxBytesPerLine;
char* result = new char[total_length]; char* result = new char[total_length];
strcpy(result, "\0"); result[0] = '\0';
int output_length = 0; int output_length = 0;
LTRResultIterator* it = GetLTRIterator(); LTRResultIterator* it = GetLTRIterator();
do { do {
@ -1907,7 +1905,7 @@ char* TessBaseAPI::GetUNLVText() {
return result; return result;
} }
/** /**
* The recognized text is returned as a char* which is coded * The recognized text is returned as a char* which is coded
* as UTF8 and must be freed with the delete [] operator. * 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. * 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 // clockwise rotation needed to make the page upright
int rotate = OrientationIdToValue(orient_id); int rotate = OrientationIdToValue(orient_id);
char* osd_buf = new char[255]; const int kOsdBufsize = 255;
snprintf(osd_buf, 255, char* osd_buf = new char[kOsdBufsize];
snprintf(osd_buf, kOsdBufsize,
"Page number: %d\n" "Page number: %d\n"
"Orientation in degrees: %d\n" "Orientation in degrees: %d\n"
"Rotate: %d\n" "Rotate: %d\n"
"Orientation confidence: %.2f\n" "Orientation confidence: %.2f\n"
"Script: %s\n" "Script: %s\n"
"Script confidence: %.2f\n", "Script confidence: %.2f\n",
page_number, page_number, orient_deg, rotate, orient_conf, script_name,
orient_deg, rotate, orient_conf, script_conf);
script_name, script_conf);
return osd_buf; return osd_buf;
} }
@ -2063,7 +2061,7 @@ void TessBaseAPI::Clear() {
if (thresholder_ != NULL) if (thresholder_ != NULL)
thresholder_->Clear(); thresholder_->Clear();
ClearResults(); ClearResults();
SetInputImage(NULL); if (tesseract_ != NULL) SetInputImage(NULL);
} }
/** /**
@ -2767,7 +2765,7 @@ void TessBaseAPI::GetFeaturesForBlob(TBLOB* blob,
INT_FX_RESULT_STRUCT fx_info; INT_FX_RESULT_STRUCT fx_info;
tesseract_->ExtractFeatures(*blob, false, &bl_features, tesseract_->ExtractFeatures(*blob, false, &bl_features,
&cn_features, &fx_info, &outline_counts); &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; *num_features = 0;
return; // Feature extraction failed. 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); static void NormalizeTBLOB(TBLOB *tblob, ROW *row, bool numeric_mode);
Tesseract* tesseract() const { Tesseract* tesseract() const { return tesseract_; }
return tesseract_;
}
OcrEngineMode oem() const { OcrEngineMode oem() const { return last_oem_requested_; }
return last_oem_requested_;
}
void InitTruthCallback(TruthCallback *cb) { truth_cb_ = cb; } void InitTruthCallback(TruthCallback *cb) { truth_cb_ = cb; }
@ -898,7 +894,7 @@ class TESS_API TessBaseAPI {
const char* retry_config, int timeout_millisec, const char* retry_config, int timeout_millisec,
TessResultRenderer* renderer, TessResultRenderer* renderer,
int tessedit_page_number); int tessedit_page_number);
// TIFF supports multipage so gets special consideration // TIFF supports multipage so gets special consideration.
bool ProcessPagesMultipageTiff(const unsigned char *data, bool ProcessPagesMultipageTiff(const unsigned char *data,
size_t size, size_t size,
const char* filename, const char* filename,

7
api/pdfrenderer.cpp
View File

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

15
api/renderer.cpp
View File

@ -198,25 +198,25 @@ bool TessHOcrRenderer::AddImageHandler(TessBaseAPI* api) {
/********************************************************************** /**********************************************************************
* TSV Text Renderer interface implementation * TSV Text Renderer interface implementation
**********************************************************************/ **********************************************************************/
TessTsvRenderer::TessTsvRenderer(const char *outputbase) TessTsvRenderer::TessTsvRenderer(const char* outputbase)
: TessResultRenderer(outputbase, "tsv") { : TessResultRenderer(outputbase, "tsv") {
font_info_ = false; font_info_ = false;
} }
TessTsvRenderer::TessTsvRenderer(const char *outputbase, bool font_info) TessTsvRenderer::TessTsvRenderer(const char* outputbase, bool font_info)
: TessResultRenderer(outputbase, "tsv") { : TessResultRenderer(outputbase, "tsv") {
font_info_ = font_info; font_info_ = font_info;
} }
bool TessTsvRenderer::BeginDocumentHandler() { bool TessTsvRenderer::BeginDocumentHandler() {
// Output TSV column headings // 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; return true;
} }
bool TessTsvRenderer::EndDocumentHandler() { bool TessTsvRenderer::EndDocumentHandler() { return true; }
return true;
}
bool TessTsvRenderer::AddImageHandler(TessBaseAPI* api) { bool TessTsvRenderer::AddImageHandler(TessBaseAPI* api) {
char* tsv = api->GetTSVText(imagenum()); char* tsv = api->GetTSVText(imagenum());
@ -266,8 +266,7 @@ bool TessBoxTextRenderer::AddImageHandler(TessBaseAPI* api) {
* Osd Text Renderer interface implementation * Osd Text Renderer interface implementation
**********************************************************************/ **********************************************************************/
TessOsdRenderer::TessOsdRenderer(const char* outputbase) TessOsdRenderer::TessOsdRenderer(const char* outputbase)
: TessResultRenderer(outputbase, "osd") { : TessResultRenderer(outputbase, "osd") {}
}
bool TessOsdRenderer::AddImageHandler(TessBaseAPI* api) { bool TessOsdRenderer::AddImageHandler(TessBaseAPI* api) {
char* osd = api->GetOsdText(imagenum()); 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, bool font_info);
explicit TessHOcrRenderer(const char *outputbase); explicit TessHOcrRenderer(const char *outputbase);
protected: protected:
virtual bool BeginDocumentHandler(); virtual bool BeginDocumentHandler();
virtual bool AddImageHandler(TessBaseAPI* api); virtual bool AddImageHandler(TessBaseAPI* api);
virtual bool EndDocumentHandler(); virtual bool EndDocumentHandler();
private: private:
bool font_info_; // whether to print font information bool font_info_; // whether to print font information
}; };
@ -167,15 +167,15 @@ private:
*/ */
class TESS_API TessTsvRenderer : public TessResultRenderer { class TESS_API TessTsvRenderer : public TessResultRenderer {
public: public:
explicit TessTsvRenderer(const char *outputbase, bool font_info); explicit TessTsvRenderer(const char* outputbase, bool font_info);
explicit TessTsvRenderer(const char *outputbase); explicit TessTsvRenderer(const char* outputbase);
protected: protected:
virtual bool BeginDocumentHandler(); virtual bool BeginDocumentHandler();
virtual bool AddImageHandler(TessBaseAPI* api); virtual bool AddImageHandler(TessBaseAPI* api);
virtual bool EndDocumentHandler(); virtual bool EndDocumentHandler();
private: private:
bool font_info_; // whether to print font information 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. // we load a custom PDF font from this location.
TessPDFRenderer(const char *outputbase, const char *datadir); TessPDFRenderer(const char *outputbase, const char *datadir);
protected: protected:
virtual bool BeginDocumentHandler(); virtual bool BeginDocumentHandler();
virtual bool AddImageHandler(TessBaseAPI* api); virtual bool AddImageHandler(TessBaseAPI* api);
virtual bool EndDocumentHandler(); virtual bool EndDocumentHandler();
private: private:
// We don't want to have every image in memory at once, // We don't want to have every image in memory at once,
// so we store some metadata as we go along producing // so we store some metadata as we go along producing
// PDFs one page at a time. At the end that metadata is // 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 */ #endif /* HAVE_TIFFIO_H && _WIN32 */
void PrintVersionInfo() { void PrintVersionInfo() {
char *versionStrP; char* versionStrP;
printf("tesseract %s\n", tesseract::TessBaseAPI::Version()); printf("tesseract %s\n", tesseract::TessBaseAPI::Version());
@ -82,7 +82,7 @@ void PrintVersionInfo() {
printf(" Found %d devices.\n", num_devices); printf(" Found %d devices.\n", num_devices);
for (i = 0; i < num_devices; ++i) { for (i = 0; i < num_devices; ++i) {
clGetDeviceInfo(devices[i], CL_DEVICE_NAME, 256, info, 0); 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 #endif
} }
@ -111,16 +111,11 @@ void PrintHelpForPSM() {
" 8 Treat the image as a single word.\n" " 8 Treat the image as a single word.\n"
" 9 Treat the image as a single word in a circle.\n" " 9 Treat the image as a single word in a circle.\n"
" 10 Treat the image as a single character.\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" " 11 Sparse text. Find as much text as possible in no"
" particular order.\n" " particular order.\n"
" 12 Sparse text with OSD.\n" " 12 Sparse text with OSD.\n"
" 13 Raw line. Treat the image as a single text line,\n" " 13 Raw line. Treat the image as a single text line,\n"
"\t\t\tbypassing hacks that are Tesseract-specific.\n" "\t\t\tbypassing hacks that are Tesseract-specific.\n";
#endif
;
printf("%s", msg); printf("%s", msg);
} }
@ -137,31 +132,30 @@ void PrintHelpMessage(const char* program) {
" -c VAR=VALUE Set value for config variables.\n" " -c VAR=VALUE Set value for config variables.\n"
" Multiple -c arguments are allowed.\n" " Multiple -c arguments are allowed.\n"
" -psm NUM Specify page segmentation mode.\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); printf("\n%s\n", ocr_options);
PrintHelpForPSM(); PrintHelpForPSM();
const char *single_options = const char* single_options =
"Single options:\n" "Single options:\n"
" -h, --help Show this help message.\n" " -h, --help Show this help message.\n"
" --help-psm Show page segmentation modes.\n" " --help-psm Show page segmentation modes.\n"
" -v, --version Show version information.\n" " -v, --version Show version information.\n"
" --list-langs List available languages for tesseract engine.\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); 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]; char opt1[256], opt2[255];
for (int i = 0; i < argc; i++) { for (int i = 0; i < argc; i++) {
if (strcmp(argv[i], "-c") == 0 && i + 1 < argc) { if (strcmp(argv[i], "-c") == 0 && i + 1 < argc) {
strncpy(opt1, argv[i + 1], 255); strncpy(opt1, argv[i + 1], 255);
opt1[255] = '\0'; opt1[255] = '\0';
char *p = strchr(opt1, '='); char* p = strchr(opt1, '=');
if (!p) { if (!p) {
fprintf(stderr, "Missing = in configvar assignment\n"); fprintf(stderr, "Missing = in configvar assignment\n");
exit(1); 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 // NOTE: arg_i is used here to avoid ugly *i so many times in this function
void ParseArgs(const int argc, char** argv, void ParseArgs(const int argc, char** argv, const char** lang,
const char** lang, const char** image, const char** outputbase,
const char** image, const char** datapath, bool* list_langs, bool* print_parameters,
const char** outputbase,
const char** datapath,
bool* list_langs,
bool* print_parameters,
GenericVector<STRING>* vars_vec, GenericVector<STRING>* vars_vec,
GenericVector<STRING>* vars_values, GenericVector<STRING>* vars_values, int* arg_i,
int* arg_i,
tesseract::PageSegMode* pagesegmode) { tesseract::PageSegMode* pagesegmode) {
if (argc == 1) { if (argc == 1) {
PrintHelpMessage(argv[0]); PrintHelpMessage(argv[0]);
@ -232,8 +221,7 @@ void ParseArgs(const int argc, char** argv,
} }
if (argc == 2) { if (argc == 2) {
if ((strcmp(argv[1], "-h") == 0) || if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
(strcmp(argv[1], "--help") == 0)) {
PrintHelpMessage(argv[0]); PrintHelpMessage(argv[0]);
exit(0); exit(0);
} }
@ -241,8 +229,7 @@ void ParseArgs(const int argc, char** argv,
PrintHelpForPSM(); PrintHelpForPSM();
exit(0); exit(0);
} }
if ((strcmp(argv[1], "-v") == 0) || if ((strcmp(argv[1], "-v") == 0) || (strcmp(argv[1], "--version") == 0)) {
(strcmp(argv[1], "--version") == 0)) {
PrintVersionInfo(); PrintVersionInfo();
exit(0); 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::PointerVector<tesseract::TessResultRenderer>* renderers,
tesseract::PageSegMode pagesegmode, tesseract::PageSegMode pagesegmode, const char* outputbase) {
const char* outputbase) {
if (pagesegmode == tesseract::PSM_OSD_ONLY) { if (pagesegmode == tesseract::PSM_OSD_ONLY) {
renderers->push_back(new tesseract::TessOsdRenderer(outputbase)); renderers->push_back(new tesseract::TessOsdRenderer(outputbase));
} else { } else {
@ -324,8 +311,8 @@ void PreloadRenderers(tesseract::TessBaseAPI* api,
api->GetBoolVariable("tessedit_create_pdf", &b); api->GetBoolVariable("tessedit_create_pdf", &b);
if (b) { if (b) {
renderers->push_back(new tesseract::TessPDFRenderer(outputbase, renderers->push_back(
api->GetDatapath())); new tesseract::TessPDFRenderer(outputbase, api->GetDatapath()));
} }
api->GetBoolVariable("tessedit_write_unlv", &b); 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* lang = "eng";
const char* image = NULL; const char* image = NULL;
const char* outputbase = NULL; const char* outputbase = NULL;
@ -380,10 +366,8 @@ int main(int argc, char **argv) {
TIFFSetWarningHandler(Win32WarningHandler); TIFFSetWarningHandler(Win32WarningHandler);
#endif /* HAVE_TIFFIO_H && _WIN32 */ #endif /* HAVE_TIFFIO_H && _WIN32 */
ParseArgs(argc, argv, ParseArgs(argc, argv, &lang, &image, &outputbase, &datapath, &list_langs,
&lang, &image, &outputbase, &datapath, &print_parameters, &vars_vec, &vars_values, &arg_i, &pagesegmode);
&list_langs, &print_parameters,
&vars_vec, &vars_values, &arg_i, &pagesegmode);
bool banner = false; bool banner = false;
if (outputbase != NULL && strcmp(outputbase, "-") && if (outputbase != NULL && strcmp(outputbase, "-") &&
@ -396,8 +380,9 @@ int main(int argc, char **argv) {
api.SetOutputName(outputbase); api.SetOutputName(outputbase);
int init_failed = api.Init(datapath, lang, tesseract::OEM_DEFAULT, int init_failed =
&(argv[arg_i]), argc - arg_i, &vars_vec, &vars_values, false); api.Init(datapath, lang, tesseract::OEM_DEFAULT, &(argv[arg_i]),
argc - arg_i, &vars_vec, &vars_values, false);
if (init_failed) { if (init_failed) {
fprintf(stderr, "Could not initialize tesseract.\n"); fprintf(stderr, "Could not initialize tesseract.\n");
exit(1); exit(1);
@ -439,7 +424,8 @@ int main(int argc, char **argv) {
tesseract::PageIterator* it = api.AnalyseLayout(); tesseract::PageIterator* it = api.AnalyseLayout();
if (it) { if (it) {
it->Orientation(&orientation, &direction, &order, &deskew_angle); 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", "Deskew angle: %.4f\n",
orientation, direction, order, deskew_angle); orientation, direction, order, deskew_angle);
} else { } else {
@ -462,8 +448,6 @@ int main(int argc, char **argv) {
tesseract::PointerVector<tesseract::TessResultRenderer> renderers; tesseract::PointerVector<tesseract::TessResultRenderer> renderers;
if (in_training_mode) { if (in_training_mode) {
renderers.push_back(NULL); renderers.push_back(NULL);
} else { } 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. * 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. // Excellent, we have some bigram matches.
if (EqualIgnoringCaseAndTerminalPunct(*w_prev->best_choice, if (EqualIgnoringCaseAndTerminalPunct(*w_prev->best_choice,
*overrides_word1[best_idx]) && *overrides_word1[best_idx]) &&

8
ccmain/docqual.cpp
View File

@ -98,8 +98,8 @@ void Tesseract::word_char_quality(WERD_RES *word,
ROW *row, ROW *row,
inT16 *match_count, inT16 *match_count,
inT16 *accepted_match_count) { inT16 *accepted_match_count) {
if (word->bln_boxes == NULL || if (word->bln_boxes == NULL || word->rebuild_word == NULL ||
word->rebuild_word == NULL || word->rebuild_word->blobs.empty()) { word->rebuild_word->blobs.empty()) {
*match_count = 0; *match_count = 0;
*accepted_match_count = 0; *accepted_match_count = 0;
return; return;
@ -132,7 +132,7 @@ inT16 Tesseract::count_outline_errs(char c, inT16 outline_count) {
int expected_outline_count; int expected_outline_count;
if (STRING (outlines_odd).contains (c)) 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)) else if (STRING (outlines_2).contains (c))
expected_outline_count = 2; expected_outline_count = 2;
else else
@ -151,7 +151,6 @@ void Tesseract::quality_based_rejection(PAGE_RES_IT &page_res_it,
} }
} }
/************************************************************************* /*************************************************************************
* unrej_good_quality_words() * unrej_good_quality_words()
* Accept potential rejects in words which pass the following checks: * 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 } // namespace tesseract
/************************************************************************* /*************************************************************************
* reject_whole_page() * reject_whole_page()
* Don't believe any of it - set the reject map to 00..00 in all words * 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() * @name eval_word_spacing()
* The basic measure is the number of characters in contextually confirmed * 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; return 0.0f;
} }
void LTRResultIterator::RowAttributes(float* row_height, void LTRResultIterator::RowAttributes(float* row_height, float* descenders,
float* descenders,
float* ascenders) const { float* ascenders) const {
*row_height = it_->row()->row->x_height() + it_->row()-> row->ascenders() *row_height = it_->row()->row->x_height() + it_->row()->row->ascenders() -
- it_->row()->row->descenders(); it_->row()->row->descenders();
*descenders = it_->row()->row->descenders(); *descenders = it_->row()->row->descenders();
*ascenders = it_->row()->row->ascenders(); *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; float Confidence(PageIteratorLevel level) const;
// Returns the attributes of the current row. // Returns the attributes of the current row.
void RowAttributes(float* row_height, void RowAttributes(float* row_height, float* descenders,
float* descenders,
float* ascenders) const; float* ascenders) const;
// ============= Functions that refer to words only ============. // ============= 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) { while (page_res_it.word () != NULL) {
check_debug_pt (page_res_it.word (), 120); check_debug_pt (page_res_it.word (), 120);
if (target_word_box) if (target_word_box) {
{ TBOX current_word_box = page_res_it.word()->word->bounding_box();
FCOORD center_pt(
TBOX current_word_box=page_res_it.word ()->word->bounding_box(); (current_word_box.right() + current_word_box.left()) / 2,
FCOORD center_pt((current_word_box.right()+current_word_box.left())/2,(current_word_box.bottom()+current_word_box.top())/2); (current_word_box.bottom() + current_word_box.top()) / 2);
if (!target_word_box->contains(center_pt)) if (!target_word_box->contains(center_pt)) {
{ page_res_it.forward();
page_res_it.forward ();
continue; continue;
} }
} }
if (tessedit_write_block_separators && if (tessedit_write_block_separators &&
block_of_last_word != page_res_it.block ()) { 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(); rating_per_ch = word.rating() / word_res->reject_map.length();
if (rating_per_ch >= suspect_rating_per_ch) 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)) { if ((word_res->tess_accepted) || (rating_per_ch < suspect_accept_rating)) {
/* Unreject any Tess Acceptable word - but NOT tess reject chs*/ /* 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); "Don't rotate.\n", osd_margin);
osd_orientation = 0; osd_orientation = 0;
} else { } 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", "but using orientation anyway: %d\n",
osd_margin, osd_blobs.length(), osd_orientation); osd_margin, osd_blobs.length(), osd_orientation);
} }

12
ccmain/paragraphs.cpp
View File

@ -2052,7 +2052,7 @@ void ConvertHypothesizedModelRunsToParagraphs(
bool single_line_paragraph = false; bool single_line_paragraph = false;
SetOfModels models; SetOfModels models;
rows[start].NonNullHypotheses(&models); rows[start].NonNullHypotheses(&models);
if (models.size() > 0) { if (!models.empty()) {
model = models[0]; model = models[0];
if (rows[start].GetLineType(model) != LT_BODY) if (rows[start].GetLineType(model) != LT_BODY)
single_line_paragraph = true; single_line_paragraph = true;
@ -2190,17 +2190,17 @@ void LeftoverSegments(const GenericVector<RowScratchRegisters> &rows,
SetOfModels models_w_crowns; SetOfModels models_w_crowns;
rows[i].StrongHypotheses(&models); rows[i].StrongHypotheses(&models);
rows[i].NonNullHypotheses(&models_w_crowns); 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? // Crown paragraph. Is it followed by a modeled line?
for (int end = i + 1; end < rows.size(); end++) { for (int end = i + 1; end < rows.size(); end++) {
SetOfModels end_models; SetOfModels end_models;
SetOfModels strong_end_models; SetOfModels strong_end_models;
rows[end].NonNullHypotheses(&end_models); rows[end].NonNullHypotheses(&end_models);
rows[end].StrongHypotheses(&strong_end_models); rows[end].StrongHypotheses(&strong_end_models);
if (end_models.size() == 0) { if (end_models.empty()) {
needs_fixing = true; needs_fixing = true;
break; break;
} else if (strong_end_models.size() > 0) { } else if (!strong_end_models.empty()) {
needs_fixing = false; needs_fixing = false;
break; break;
} }
@ -2485,7 +2485,7 @@ void InitializeRowInfo(bool after_recognition,
info->ltr = ltr >= rtl; info->ltr = ltr >= rtl;
info->has_leaders = num_leaders > 3; info->has_leaders = num_leaders > 3;
info->num_words = werds.size(); info->num_words = werds.size();
if (werds.size() > 0) { if (!werds.empty()) {
WERD_RES *lword = werds[0], *rword = werds[werds.size() - 1]; WERD_RES *lword = werds[0], *rword = werds[werds.size() - 1];
info->lword_text = lword->best_choice->unichar_string().string(); info->lword_text = lword->best_choice->unichar_string().string();
info->rword_text = rword->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 // If we're called before text recognition, we might not have
// tight block bounding boxes, so trim by the minimum on each side. // 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_lmargin = row_infos[0].pix_ldistance;
int min_rmargin = row_infos[0].pix_rdistance; int min_rmargin = row_infos[0].pix_rdistance;
for (int i = 1; i < row_infos.size(); i++) { 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); fclose(fp);
sprintf (msg_str, "Overwrite file " "%s" "? (Y/N)", filename); sprintf (msg_str, "Overwrite file " "%s" "? (Y/N)", filename);
int a = sv_window_->ShowYesNoDialog(msg_str); 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? fp = fopen (filename, "wb"); // can we write to it?
if (fp == NULL) { if (fp == NULL) {
sv_window_->AddMessage("Can't write to file " "%s" "", filename); sv_window_->AddMessage(
"Can't write to file "
"%s"
"",
filename);
return; return;
} }

2
ccmain/tessedit.cpp
View File

@ -44,7 +44,7 @@
#include "params.h" #include "params.h"
#define VARDIR "configs/" /*variables files */ #define VARDIR "configs/" /*variables files */
//config under api // config under api
#define API_CONFIG "configs/api_config" #define API_CONFIG "configs/api_config"
ETEXT_DESC *global_monitor = NULL; // progress monitor 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()), "Don't suspect dict wds longer than this", this->params()),
BOOL_MEMBER(suspect_constrain_1Il, false, "UNLV keep 1Il chars rejected", BOOL_MEMBER(suspect_constrain_1Il, false, "UNLV keep 1Il chars rejected",
this->params()), this->params()),
double_MEMBER(suspect_rating_per_ch, 999.9, "Don't touch bad rating limit", double_MEMBER(suspect_rating_per_ch, 999.9,
this->params()), "Don't touch bad rating limit", this->params()),
double_MEMBER(suspect_accept_rating, -999.9, "Accept good rating limit", double_MEMBER(suspect_accept_rating, -999.9, "Accept good rating limit",
this->params()), this->params()),
BOOL_MEMBER(tessedit_minimal_rejection, false, BOOL_MEMBER(tessedit_minimal_rejection, false,
@ -512,7 +512,6 @@ Tesseract::Tesseract()
"Page separator (default is form feed control character)", "Page separator (default is form feed control character)",
this->params()), this->params()),
// The following parameters were deprecated and removed from their // The following parameters were deprecated and removed from their
// original // original
// locations. The parameters are temporarily kept here to give Tesseract // 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 BLOB_CHOICE_LIST_CLIST;
class BLOCK_LIST; class BLOCK_LIST;
class CharSamp;
struct OSResults; struct OSResults;
class PAGE_RES; class PAGE_RES;
class PAGE_RES_IT; class PAGE_RES_IT;
@ -98,6 +97,7 @@ namespace tesseract {
class ColumnFinder; class ColumnFinder;
#ifndef NO_CUBE_BUILD #ifndef NO_CUBE_BUILD
class CharSamp;
class CubeLineObject; class CubeLineObject;
class CubeObject; class CubeObject;
class CubeRecoContext; class CubeRecoContext;
@ -1010,8 +1010,7 @@ class Tesseract : public Wordrec {
INT_VAR_H(suspect_level, 99, "Suspect marker level"); INT_VAR_H(suspect_level, 99, "Suspect marker level");
INT_VAR_H(suspect_space_level, 100, INT_VAR_H(suspect_space_level, 100,
"Min suspect level for rejecting spaces"); "Min suspect level for rejecting spaces");
INT_VAR_H(suspect_short_words, 2, INT_VAR_H(suspect_short_words, 2, "Don't Suspect dict wds longer than this");
"Don't Suspect dict wds longer than this");
BOOL_VAR_H(suspect_constrain_1Il, false, "UNLV keep 1Il chars rejected"); 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_rating_per_ch, 999.9, "Don't touch bad rating limit");
double_VAR_H(suspect_accept_rating, -999.9, "Accept good 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 PROJECTION_MARGIN 10 //arbitrary
#define EXTERN #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. // Up to 30 degrees is allowed for rotations of diacritic blobs.
const double kCosSmallAngle = 0.866; const double kCosSmallAngle = 0.866;
@ -176,7 +178,7 @@ void BLOBNBOX::NeighbourGaps(int gaps[BND_COUNT]) const {
gaps[dir] = MAX_INT16; gaps[dir] = MAX_INT16;
BLOBNBOX* neighbour = neighbours_[dir]; BLOBNBOX* neighbour = neighbours_[dir];
if (neighbour != NULL) { if (neighbour != NULL) {
TBOX n_box = neighbour->bounding_box(); const TBOX& n_box = neighbour->bounding_box();
if (dir == BND_LEFT || dir == BND_RIGHT) { if (dir == BND_LEFT || dir == BND_RIGHT) {
gaps[dir] = box.x_gap(n_box); gaps[dir] = box.x_gap(n_box);
} else { } else {

3
ccstruct/boxread.cpp
View File

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

4
ccstruct/boxword.h
View File

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

66
ccstruct/coutln.cpp
View File

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

13
ccstruct/mod128.cpp
View File

@ -86,16 +86,3 @@ DIR128::DIR128( //from fcoord
while (high - low > 1); while (high - low > 1);
dir = low; 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 inT8 get_dir() const { //access function
return dir; return dir;
} }
ICOORD vector() const; //turn to vector
private: private:
inT8 dir; //a direction 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 // only use opencl if compiled w/ OpenCL and selected device is opencl
#ifdef USE_OPENCL #ifdef USE_OPENCL
// all of channel 0 then all of channel 1... // 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 // Calculate Histogram on GPU
OpenclDevice od; OpenclDevice od;
if (od.selectedDeviceIsOpenCL() && if (od.selectedDeviceIsOpenCL() && (num_channels == 1 || num_channels == 4) &&
(num_channels == 1 || num_channels == 4) && top == 0 && left == 0 ) { top == 0 && left == 0) {
od.HistogramRectOCL( od.HistogramRectOCL((const unsigned char*)pixGetData(src_pix), num_channels,
(const unsigned char*)pixGetData(src_pix), pixGetWpl(src_pix) * 4, left, top, width, height,
num_channels, kHistogramSize, histogramAllChannels);
pixGetWpl(src_pix) * 4,
left,
top,
width,
height,
kHistogramSize,
histogramAllChannels);
// Calculate Threshold from Histogram on cpu // Calculate Threshold from Histogram on cpu
for (int ch = 0; ch < num_channels; ++ch) { 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; delete[] histogramAllChannels;
#endif // USE_OPENCL #endif // USE_OPENCL
if (!any_good_hivalue) { if (!any_good_hivalue) {
// Use the best of the ones that were not good enough. // Use the best of the ones that were not good enough.
(*hi_values)[best_hi_index] = best_hi_value; (*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. // Deep copies everything except the ratings MATRIX.
// To get that use deep_copy below. // 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(); InitPointers();
*this = source; // see operator= *this = source; // see operator=
} }
@ -630,7 +630,7 @@ class WERD_RES : public ELIST_LINK {
static WERD_RES* deep_copy(const WERD_RES* src) { static WERD_RES* deep_copy(const WERD_RES* src) {
WERD_RES* result = new 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 // That didn't copy the ratings, but we want a copy if there is one to
// begin width. // begin with.
if (src->ratings != NULL) if (src->ratings != NULL)
result->ratings = src->ratings->DeepCopy(); result->ratings = src->ratings->DeepCopy();
return result; return result;

66
ccstruct/pdblock.h
View File

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

6
ccstruct/rect.cpp
View File

@ -29,9 +29,9 @@
* *
**********************************************************************/ **********************************************************************/
TBOX::TBOX( //constructor TBOX::TBOX( // constructor
const ICOORD pt1, //one corner const ICOORD pt1, // one corner
const ICOORD pt2 //the other corner const ICOORD pt2 // the other corner
) { ) {
if (pt1.x () <= pt2.x ()) { if (pt1.x () <= pt2.x ()) {
if (pt1.y () <= pt2.y ()) { 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 "bits16.h"
#include "params.h" #include "params.h"
enum REJ_FLAGS enum REJ_FLAGS {
{
/* Reject modes which are NEVER overridden */ /* Reject modes which are NEVER overridden */
R_TESS_FAILURE, // PERM Tess didn't classify R_TESS_FAILURE, // PERM Tess didn't classify
R_SMALL_XHT, // PERM Xht too small R_SMALL_XHT, // PERM Xht too small
@ -83,11 +82,11 @@ enum REJ_FLAGS
R_UNLV_REJ, // TEMP ~ turned to - or ^ turned to space R_UNLV_REJ, // TEMP ~ turned to - or ^ turned to space
/* Accept modes which occur between the above rejection groups */ /* Accept modes which occur between the above rejection groups */
R_NN_ACCEPT, //NN acceptance R_NN_ACCEPT, // NN acceptance
R_HYPHEN_ACCEPT, //Hyphen acceptance R_HYPHEN_ACCEPT, // Hyphen acceptance
R_MM_ACCEPT, //Matrix match acceptance R_MM_ACCEPT, // Matrix match acceptance
R_QUALITY_ACCEPT, //Accept word in good quality doc R_QUALITY_ACCEPT, // Accept word in good quality doc
R_MINIMAL_REJ_ACCEPT //Accept EVERYTHING except tess failures R_MINIMAL_REJ_ACCEPT // Accept EVERYTHING except tess failures
}; };
/* REJECT MAP VALUES */ /* REJECT MAP VALUES */

1
ccstruct/statistc.cpp
View File

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

9
ccutil/clst.cpp
View File

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

194
ccutil/clst.h
View File

@ -50,12 +50,12 @@ class DLLSYM CLIST_LINK
data = next = NULL; data = next = NULL;
} }
CLIST_LINK( //copy constructor CLIST_LINK( // copy constructor
const CLIST_LINK &) { //don't copy link const CLIST_LINK &) { // don't copy link
data = next = NULL; data = next = NULL;
} }
void operator= ( //don't copy links void operator=( // don't copy links
const CLIST_LINK &) { const CLIST_LINK &) {
data = next = NULL; data = next = NULL;
} }
@ -89,8 +89,8 @@ class DLLSYM CLIST
void internal_deep_clear ( //destroy all links void internal_deep_clear ( //destroy all links
void (*zapper) (void *)); //ptr to zapper functn void (*zapper) (void *)); //ptr to zapper functn
void shallow_clear(); //clear list but don't void shallow_clear(); // clear list but don't
//delete data elements // delete data elements
bool empty() const { //is list empty? bool empty() const { //is list empty?
return !last; return !last;
@ -138,7 +138,8 @@ class DLLSYM CLIST
/*********************************************************************** /***********************************************************************
* CLASS - CLIST_ITERATOR * 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 class DLLSYM CLIST_ITERATOR
@ -231,8 +232,8 @@ class DLLSYM CLIST_ITERATOR
BOOL8 cycled_list(); //Completed a cycle? BOOL8 cycled_list(); //Completed a cycle?
void add_to_end( //add at end & void add_to_end( // add at end &
void *new_data); //don't move void *new_data); // don't move
void exchange( //positions of 2 links void exchange( //positions of 2 links
CLIST_ITERATOR *other_it); //other iterator 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; ex_current_was_cycle_pt = FALSE;
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::CLIST_ITERATOR * CLIST_ITERATOR::CLIST_ITERATOR
* *
@ -281,7 +281,6 @@ inline CLIST_ITERATOR::CLIST_ITERATOR(CLIST *list_to_iterate) {
set_to_list(list_to_iterate); set_to_list(list_to_iterate);
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::add_after_then_move * CLIST_ITERATOR::add_after_then_move
* *
@ -329,7 +328,6 @@ inline void CLIST_ITERATOR::add_after_then_move( // element to add
current = new_element; current = new_element;
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::add_after_stay_put * 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 * CLIST_ITERATOR::add_before_then_move
* *
@ -425,7 +422,6 @@ inline void CLIST_ITERATOR::add_before_then_move( // element to add
current = new_element; current = new_element;
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::add_before_stay_put * 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 * 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. * iterator.
**********************************************************************/ **********************************************************************/
@ -518,7 +514,6 @@ inline void CLIST_ITERATOR::add_list_after(CLIST *list_to_add) {
} }
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::add_list_before * CLIST_ITERATOR::add_list_before
* *
@ -563,7 +558,6 @@ inline void CLIST_ITERATOR::add_list_before(CLIST *list_to_add) {
} }
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::extract * CLIST_ITERATOR::extract
* *
@ -606,7 +600,6 @@ inline void *CLIST_ITERATOR::extract() {
return extracted_data; return extracted_data;
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::move_to_first() * CLIST_ITERATOR::move_to_first()
* *
@ -626,7 +619,6 @@ inline void *CLIST_ITERATOR::move_to_first() {
return current != NULL ? current->data : NULL; return current != NULL ? current->data : NULL;
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::mark_cycle_pt() * CLIST_ITERATOR::mark_cycle_pt()
* *
@ -651,7 +643,6 @@ inline void CLIST_ITERATOR::mark_cycle_pt() {
started_cycling = FALSE; started_cycling = FALSE;
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::at_first() * CLIST_ITERATOR::at_first()
* *
@ -671,7 +662,6 @@ inline BOOL8 CLIST_ITERATOR::at_first() {
!ex_current_was_last)); //first and last !ex_current_was_last)); //first and last
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::at_last() * CLIST_ITERATOR::at_last()
* *
@ -691,7 +681,6 @@ inline BOOL8 CLIST_ITERATOR::at_last() {
ex_current_was_last)); //first and last ex_current_was_last)); //first and last
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::cycled_list() * CLIST_ITERATOR::cycled_list()
* *
@ -709,7 +698,6 @@ inline BOOL8 CLIST_ITERATOR::cycled_list() {
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::length() * CLIST_ITERATOR::length()
* *
@ -726,7 +714,6 @@ inline inT32 CLIST_ITERATOR::length() {
return list->length (); return list->length ();
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::sort() * CLIST_ITERATOR::sort()
* *
@ -747,7 +734,6 @@ const void *, const void *)) {
move_to_first(); move_to_first();
} }
/*********************************************************************** /***********************************************************************
* CLIST_ITERATOR::add_to_end * CLIST_ITERATOR::add_to_end
* *
@ -830,114 +816,116 @@ CLISTIZEH is a concatenation of 3 fragments CLISTIZEH_A, CLISTIZEH_B and
CLISTIZEH_C. CLISTIZEH_C.
***********************************************************************/ ***********************************************************************/
#define CLISTIZEH_A( CLASSNAME ) \ #define CLISTIZEH_A(CLASSNAME) \
\ \
extern DLLSYM void CLASSNAME##_c1_zapper( /*delete a link*/ \ extern DLLSYM void CLASSNAME##_c1_zapper( /*delete a link*/ \
void* link); /*link to delete*/ \ void *link); /*link to delete*/ \
\ \
extern DLLSYM void* CLASSNAME##_c1_copier( /*deep copy a link*/ \ extern DLLSYM void \
void* old_element); /*source link */ *CLASSNAME##_c1_copier( /*deep copy a link*/ \
void *old_element); /*source link */
#define CLISTIZEH_B( CLASSNAME ) \ #define CLISTIZEH_B(CLASSNAME) \
\ \
/*********************************************************************** \ /*********************************************************************** \
* CLASS - CLASSNAME##_CLIST \ * CLASS - \
* \ *CLASSNAME##_CLIST \
* List class for class CLASSNAME \ * \
* \ * List class for class \
**********************************************************************/ \ *CLASSNAME \
* \
**********************************************************************/ \
\ \
class DLLSYM CLASSNAME##_CLIST : public CLIST \ class DLLSYM CLASSNAME##_CLIST : public CLIST { \
{ \ public: \
public: \ CLASSNAME##_CLIST() : CLIST() {} \
CLASSNAME##_CLIST():CLIST() {} \
/* constructor */ \ /* constructor */ \
\ \
CLASSNAME##_CLIST( /* don't construct */ \ CLASSNAME##_CLIST( /* don't construct */ \
const CLASSNAME##_CLIST&) /*by initial assign*/ \ const CLASSNAME##_CLIST &) /*by initial assign*/ \
{ DONT_CONSTRUCT_LIST_BY_COPY.error( QUOTE_IT( CLASSNAME##_CLIST ), \ { \
ABORT, NULL ); } \ DONT_CONSTRUCT_LIST_BY_COPY.error(QUOTE_IT(CLASSNAME##_CLIST), ABORT, \
NULL); \
} \
\ \
void deep_clear() /* delete elements */ \ void deep_clear() /* delete elements */ \
{ CLIST::internal_deep_clear( &CLASSNAME##_c1_zapper ); } \ { \
CLIST::internal_deep_clear(&CLASSNAME##_c1_zapper); \
} \
\ \
void operator=( /* prevent assign */ \ void operator=(/* prevent assign */ \
const CLASSNAME##_CLIST&) \ const CLASSNAME##_CLIST &) { \
{ DONT_ASSIGN_LISTS.error( QUOTE_IT( CLASSNAME##_CLIST ), \ DONT_ASSIGN_LISTS.error(QUOTE_IT(CLASSNAME##_CLIST), ABORT, NULL); \
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) {} \
\ \
/*********************************************************************** \ CLASSNAME *data() { return (CLASSNAME *)CLIST_ITERATOR::data(); } \
* 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 \ CLASSNAME *data_relative(inT8 offset) { \
{ \ return (CLASSNAME *)CLIST_ITERATOR::data_relative(offset); \
public: \ } \
CLASSNAME##_C_IT():CLIST_ITERATOR(){} \
\ \
CLASSNAME##_C_IT( \ CLASSNAME *forward() { return (CLASSNAME *)CLIST_ITERATOR::forward(); } \
CLASSNAME##_CLIST* list):CLIST_ITERATOR(list){} \
\ \
CLASSNAME* data() \ CLASSNAME *extract() { return (CLASSNAME *)CLIST_ITERATOR::extract(); } \
{ return (CLASSNAME*) CLIST_ITERATOR::data(); } \
\ \
CLASSNAME* data_relative( \ CLASSNAME *move_to_first() { \
inT8 offset) \ return (CLASSNAME *)CLIST_ITERATOR::move_to_first(); \
{ return (CLASSNAME*) CLIST_ITERATOR::data_relative( offset ); } \ } \
\ \
CLASSNAME* forward() \ CLASSNAME *move_to_last() { \
{ return (CLASSNAME*) CLIST_ITERATOR::forward(); } \ return (CLASSNAME *)CLIST_ITERATOR::move_to_last(); \
\ } \
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(); } \
};
#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 CLISTIZE( CLASSNAME ) MACRO
***********************************************************************/ ***********************************************************************/
#define CLISTIZE( CLASSNAME ) \ #define CLISTIZE(CLASSNAME) \
\ \
/*********************************************************************** \ /*********************************************************************** \
* CLASSNAME##_c1_zapper \ * CLASSNAME##_c1_zapper \
* \ * \
* A function which can delete a CLASSNAME element. This is passed to the \ * 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 \ * generic deep_clear list member function so that when a list is cleared \
* elements on the list are properly destroyed from the base class, even \ *the \
* though we don't use a virtual destructor function. \ * 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*/ \ DLLSYM void CLASSNAME##_c1_zapper( /*delete a link*/ \
void* link) /*link to delete*/ \ void *link) /*link to delete*/ \
{ \ { \
delete (CLASSNAME *) link; \ delete (CLASSNAME *)link; \
} \ }
#endif #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); last = start_it->extract_sublist (end_it);
} }
/*********************************************************************** /***********************************************************************
* ELIST::length * ELIST::length
* *
@ -97,7 +96,6 @@ inT32 ELIST::length() const { // count elements
return count; return count;
} }
/*********************************************************************** /***********************************************************************
* ELIST::sort * ELIST::sort
* *
@ -224,7 +222,6 @@ ELIST_LINK *ELIST_ITERATOR::forward() {
return current; return current;
} }
/*********************************************************************** /***********************************************************************
* ELIST_ITERATOR::data_relative * ELIST_ITERATOR::data_relative
* *
@ -260,7 +257,6 @@ ELIST_LINK *ELIST_ITERATOR::data_relative( //get data + or - ...
return ptr; return ptr;
} }
/*********************************************************************** /***********************************************************************
* ELIST_ITERATOR::move_to_last() * ELIST_ITERATOR::move_to_last()
* *
@ -281,7 +277,6 @@ ELIST_LINK *ELIST_ITERATOR::move_to_last() {
return current; return current;
} }
/*********************************************************************** /***********************************************************************
* ELIST_ITERATOR::exchange() * ELIST_ITERATOR::exchange()
* *
@ -379,7 +374,6 @@ void ELIST_ITERATOR::exchange( //positions of 2 link
other_it->current = old_current; other_it->current = old_current;
} }
/*********************************************************************** /***********************************************************************
* ELIST_ITERATOR::extract_sublist() * ELIST_ITERATOR::extract_sublist()
* *
@ -425,7 +419,7 @@ ELIST_LINK *ELIST_ITERATOR::extract_sublist( //from
temp_it.mark_cycle_pt (); temp_it.mark_cycle_pt ();
do { //walk sublist 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); BAD_SUBLIST.error ("ELIST_ITERATOR.extract_sublist", ABORT, NULL);
if (temp_it.at_last ()) { if (temp_it.at_last ()) {

44
ccutil/elst.h
View File

@ -98,7 +98,7 @@ class DLLSYM ELIST_LINK
next = NULL; next = NULL;
} }
void operator= ( //don't copy links void operator=( // don't copy links
const ELIST_LINK &) { const ELIST_LINK &) {
next = NULL; next = NULL;
} }
@ -273,8 +273,8 @@ class DLLSYM ELIST_ITERATOR
bool cycled_list(); //Completed a cycle? bool cycled_list(); //Completed a cycle?
void add_to_end( //add at end & void add_to_end( // add at end &
ELIST_LINK *new_link); //don't move ELIST_LINK *new_link); // don't move
void exchange( //positions of 2 links void exchange( //positions of 2 links
ELIST_ITERATOR *other_it); //other iterator ELIST_ITERATOR *other_it); //other iterator
@ -458,7 +458,6 @@ inline void ELIST_ITERATOR::add_before_then_move( // element to add
current = new_element; current = new_element;
} }
/*********************************************************************** /***********************************************************************
* ELIST_ITERATOR::add_before_stay_put * 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 * 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. * iterator.
**********************************************************************/ **********************************************************************/
@ -961,28 +960,27 @@ ELISTIZEH_C( CLASSNAME )
#define ELISTIZE(CLASSNAME) \ #define ELISTIZE(CLASSNAME) \
\ \
/*********************************************************************** \ /*********************************************************************** \
* CLASSNAME##_zapper \ * CLASSNAME##_zapper \
* \ * \
* A function which can delete a CLASSNAME element. This is passed to the \ * 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 \ * 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 \ * elements on the list are properly destroyed from the base class, even \
* though we don't use a virtual destructor function. \ * though we don't use a virtual destructor function. \
**********************************************************************/ \ **********************************************************************/ \
\ \
DLLSYM void CLASSNAME##_zapper(ELIST_LINK* link) { \ DLLSYM void CLASSNAME##_zapper(ELIST_LINK *link) { \
delete reinterpret_cast<CLASSNAME*>(link); \ delete reinterpret_cast<CLASSNAME *>(link); \
} \ } \
\ \
/* Become a deep copy of src_list*/ \ /* Become a deep copy of src_list*/ \
void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST* src_list, \ void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST *src_list, \
CLASSNAME* (*copier)(const CLASSNAME*)) { \ CLASSNAME *(*copier)(const CLASSNAME *)) { \
\ CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST *>(src_list)); \
CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST*>(src_list)); \
CLASSNAME##_IT to_it(this); \ CLASSNAME##_IT to_it(this); \
\ \
for (from_it.mark_cycle_pt(); !from_it.cycled_list(); from_it.forward()) \ for (from_it.mark_cycle_pt(); !from_it.cycled_list(); from_it.forward()) \
to_it.add_after_then_move((*copier)(from_it.data())); \ to_it.add_after_then_move((*copier)(from_it.data())); \
} }
#endif #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); last = start_it->extract_sublist (end_it);
} }
/*********************************************************************** /***********************************************************************
* ELIST2::length * ELIST2::length
* *
@ -98,7 +97,6 @@ inT32 ELIST2::length() const { // count elements
return count; return count;
} }
/*********************************************************************** /***********************************************************************
* ELIST2::sort * ELIST2::sort
* *
@ -218,7 +216,6 @@ ELIST2_LINK *ELIST2_ITERATOR::forward() {
return current; return current;
} }
/*********************************************************************** /***********************************************************************
* ELIST2_ITERATOR::backward * ELIST2_ITERATOR::backward
* *
@ -257,7 +254,6 @@ ELIST2_LINK *ELIST2_ITERATOR::backward() {
return current; return current;
} }
/*********************************************************************** /***********************************************************************
* ELIST2_ITERATOR::data_relative * ELIST2_ITERATOR::data_relative
* *
@ -289,7 +285,6 @@ ELIST2_LINK *ELIST2_ITERATOR::data_relative( //get data + or - ..
return ptr; return ptr;
} }
/*********************************************************************** /***********************************************************************
* ELIST2_ITERATOR::exchange() * ELIST2_ITERATOR::exchange()
* *
@ -399,7 +394,6 @@ void ELIST2_ITERATOR::exchange( //positions of 2 li
other_it->current = old_current; other_it->current = old_current;
} }
/*********************************************************************** /***********************************************************************
* ELIST2_ITERATOR::extract_sublist() * ELIST2_ITERATOR::extract_sublist()
* *
@ -445,7 +439,7 @@ ELIST2_LINK *ELIST2_ITERATOR::extract_sublist( //fr
temp_it.mark_cycle_pt (); temp_it.mark_cycle_pt ();
do { //walk sublist 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); BAD_SUBLIST.error ("ELIST2_ITERATOR.extract_sublist", ABORT, NULL);
if (temp_it.at_last ()) { if (temp_it.at_last ()) {

217
ccutil/elst2.h
View File

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

7
ccutil/errcode.h
View File

@ -87,11 +87,10 @@ const ERRCODE ASSERT_FAILED = "Assert failed";
__FILE__, __LINE__); \ __FILE__, __LINE__); \
} }
#define ASSERT_HOST_MSG(x, ...) if (!(x)) \ #define ASSERT_HOST_MSG(x, ...) \
{ \ if (!(x)) { \
tprintf(__VA_ARGS__); \ tprintf(__VA_ARGS__); \
ASSERT_FAILED.error(#x, ABORT, "in file %s, line %d", \ ASSERT_FAILED.error(#x, ABORT, "in file %s, line %d", __FILE__, __LINE__); \
__FILE__, __LINE__); \
} }
void signal_exit(int signal_code); 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. // Remove newline (if any) at the end of the string.
inline void chomp_string(char *str) { 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 && while (last_index >= 0 &&
(str[last_index] == '\n' || str[last_index] == '\r')) { (str[last_index] == '\n' || str[last_index] == '\r')) {
str[last_index--] = '\0'; str[last_index--] = '\0';

12
ccutil/host.h
View File

@ -59,6 +59,7 @@
** of the computer and/or operating system. ** of the computer and/or operating system.
******************************************************************************/ ******************************************************************************/
#include <limits>
#include "platform.h" #include "platform.h"
/* _WIN32 */ /* _WIN32 */
#ifdef _WIN32 #ifdef _WIN32
@ -121,15 +122,16 @@ typedef unsigned char BOOL8;
#define MAX_UINT8 0xff #define MAX_UINT8 0xff
#define MAX_UINT16 0xffff #define MAX_UINT16 0xffff
#define MAX_UINT32 0xffffffff #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_INT8 static_cast<inT8>(0x80)
#define MIN_INT16 0x8000 #define MIN_INT16 static_cast<inT16>(0x8000)
#define MIN_INT32 static_cast<int>(0x80000000) #define MIN_INT32 static_cast<inT32>(0x80000000)
#define MIN_UINT8 0x00 #define MIN_UINT8 0x00
#define MIN_UINT16 0x0000 #define MIN_UINT16 0x0000
#define MIN_UINT32 0x00000000 #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 // Defines
#ifndef TRUE #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 EMPTY_LIST = "List is empty";
const ERRCODE BAD_PARAMETER = "List parameter error"; const ERRCODE BAD_PARAMETER = "List parameter error";
const ERRCODE STILL_LINKED = 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
#endif #endif

2
ccutil/mainblk.cpp
View File

@ -74,7 +74,7 @@ void CCUtil::main_setup(const char *argv0, const char *basename) {
#endif /* _WIN32 */ #endif /* _WIN32 */
#if defined(TESSDATA_PREFIX) #if defined(TESSDATA_PREFIX)
} else { } else {
/* Use tessdata prefix which was compiled in. */ /* Use tessdata prefix which was compiled in. */
#define _STR(a) #a #define _STR(a) #a
#define _XSTR(a) _STR(a) #define _XSTR(a) _STR(a)
datadir = _XSTR(TESSDATA_PREFIX); 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. * user words found. If it returns true then operation is cancelled.
**********************************************************************/ **********************************************************************/
typedef bool (*CANCEL_FUNC)(void* cancel_this, int words); typedef bool (*CANCEL_FUNC)(void* cancel_this, int words);
typedef bool (*PROGRESS_FUNC)(int progress, typedef bool (*PROGRESS_FUNC)(int progress, int left, int right, int top,
int left, int right, int top, int bottom); int bottom);
class ETEXT_DESC { // output header class ETEXT_DESC { // output header
public: public:
@ -126,12 +126,19 @@ class ETEXT_DESC { // output header
CANCEL_FUNC cancel; /// returns true to cancel CANCEL_FUNC cancel; /// returns true to cancel
PROGRESS_FUNC progress_callback; /// called whenever progress increases PROGRESS_FUNC progress_callback; /// called whenever progress increases
void* cancel_this; /// this or other data for cancel void* cancel_this; /// this or other data for cancel
struct timeval end_time; /** time to stop. expected to be set only by call struct timeval end_time; /// Time to stop. Expected to be set only
* to set_deadline_msecs() */ /// by call to set_deadline_msecs().
EANYCODE_CHAR text[1]; /// character data EANYCODE_CHAR text[1]; /// character data
ETEXT_DESC() : count(0), progress(0), more_to_come(0), ocr_alive(0), ETEXT_DESC()
err_code(0), cancel(NULL), cancel_this(NULL) { : 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_sec = 0;
end_time.tv_usec = 0; end_time.tv_usec = 0;
} }

3
ccutil/params.cpp
View File

@ -31,8 +31,7 @@
#define EQUAL '=' #define EQUAL '='
tesseract::ParamsVectors *GlobalParams() { tesseract::ParamsVectors *GlobalParams() {
static tesseract::ParamsVectors global_params = static tesseract::ParamsVectors global_params = tesseract::ParamsVectors();
tesseract::ParamsVectors();
return &global_params; 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 // Return the UNICHAR_ID of a given unichar representation within the
// UNICHARSET. Only the first length characters from unichar_repr are used. // UNICHARSET. Only the first length characters from unichar_repr are used.
UNICHAR_ID unichar_to_id(const char* const unichar_repr, UNICHAR_ID unichar_to_id(const char* const unichar_repr, int length) const;
int length) const;
// Return the minimum number of bytes that matches a legal UNICHAR_ID, // Return the minimum number of bytes that matches a legal UNICHAR_ID,
// while leaving the rest of the string encodable. Returns 0 if the // 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); NumFeatures = GetAdaptiveFeatures(Blob, IntFeatures, &FloatFeatures);
if (NumFeatures <= 0) { if (NumFeatures <= 0) {
FreeFeatureSet(FloatFeatures); return; // Features already freed by GetAdaptiveFeatures.
return;
} }
// Only match configs with the matching font. // Only match configs with the matching font.
@ -1008,8 +1007,6 @@ void Classify::DisplayAdaptedChar(TBLOB* blob, INT_CLASS_STRUCT* int_class) {
#endif #endif
} }
/** /**
* This routine adds the result of a classification into * This routine adds the result of a classification into
* Results. If the new rating is much worse than the current * 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, INT_MEMBER(classify_integer_matcher_multiplier, 10,
"Integer Matcher Multiplier 0-255: ", this->params()), "Integer Matcher Multiplier 0-255: ", this->params()),
EnableLearning(true), EnableLearning(true),
INT_MEMBER(il1_adaption_test, 0, "Don't adapt to i/I at beginning of word", INT_MEMBER(il1_adaption_test, 0,
this->params()), "Don't adapt to i/I at beginning of word", this->params()),
BOOL_MEMBER(classify_bln_numeric_mode, 0, BOOL_MEMBER(classify_bln_numeric_mode, 0,
"Assume the input is numbers [0-9].", this->params()), "Assume the input is numbers [0-9].", this->params()),
double_MEMBER(speckle_large_max_size, 0.30, "Max large speckle size", 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; return Clusterer;
} // MakeClusterer } // MakeClusterer
/** /**
* This routine creates a new sample data structure to hold * This routine creates a new sample data structure to hold
* the specified feature. This sample is added to the clusterer * the specified feature. This sample is added to the clusterer
@ -490,7 +489,6 @@ SAMPLE* MakeSample(CLUSTERER * Clusterer, const FLOAT32* Feature,
return (Sample); return (Sample);
} // MakeSample } // MakeSample
/** /**
* This routine first checks to see if the samples in this * This routine first checks to see if the samples in this
* clusterer have already been clustered before; if so, it does * 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 //compute prototypes starting at the root node in the tree
ComputePrototypes(Clusterer, Config); 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 } // ClusterSamples
/** /**
* This routine frees all of the memory allocated to the * This routine frees all of the memory allocated to the
* specified data structure. It will not, however, free * specified data structure. It will not, however, free
@ -558,7 +562,6 @@ void FreeClusterer(CLUSTERER *Clusterer) {
} }
} // FreeClusterer } // FreeClusterer
/** /**
* This routine frees all of the memory allocated to the * This routine frees all of the memory allocated to the
* specified list of prototypes. The clusters which are * specified list of prototypes. The clusters which are
@ -572,7 +575,6 @@ void FreeProtoList(LIST *ProtoList) {
destroy_nodes(*ProtoList, FreePrototype); destroy_nodes(*ProtoList, FreePrototype);
} // FreeProtoList } // FreeProtoList
/** /**
* This routine deallocates the memory consumed by the specified * This routine deallocates the memory consumed by the specified
* prototype and modifies the corresponding cluster so that it * prototype and modifies the corresponding cluster so that it
@ -606,7 +608,6 @@ void FreePrototype(void *arg) { //PROTOTYPE *Prototype)
memfree(Prototype); memfree(Prototype);
} // FreePrototype } // FreePrototype
/** /**
* This routine is used to find all of the samples which * This routine is used to find all of the samples which
* belong to a cluster. It starts by removing the top * belong to a cluster. It starts by removing the top
@ -637,7 +638,6 @@ CLUSTER *NextSample(LIST *SearchState) {
} }
} // NextSample } // NextSample
/** /**
* This routine returns the mean of the specified * This routine returns the mean of the specified
* prototype in the indicated dimension. * prototype in the indicated dimension.
@ -651,7 +651,6 @@ FLOAT32 Mean(PROTOTYPE *Proto, uinT16 Dimension) {
return (Proto->Mean[Dimension]); return (Proto->Mean[Dimension]);
} // Mean } // Mean
/** /**
* This routine returns the standard deviation of the * This routine returns the standard deviation of the
* prototype in the indicated dimension. * prototype in the indicated dimension.
@ -760,7 +759,6 @@ void CreateClusterTree(CLUSTERER *Clusterer) {
memfree(context.candidates); memfree(context.candidates);
} // CreateClusterTree } // CreateClusterTree
/** /**
* This routine is designed to be used in concert with the * This routine is designed to be used in concert with the
* KDWalk routine. It will create a potential cluster for * KDWalk routine. It will create a potential cluster for
@ -786,7 +784,6 @@ void MakePotentialClusters(ClusteringContext *context,
} }
} // MakePotentialClusters } // MakePotentialClusters
/** /**
* This routine searches the specified kd-tree for the nearest * This routine searches the specified kd-tree for the nearest
* neighbor of the specified cluster. It actually uses the * neighbor of the specified cluster. It actually uses the
@ -830,7 +827,6 @@ FindNearestNeighbor(KDTREE * Tree, CLUSTER * Cluster, FLOAT32 * Distance)
return BestNeighbor; return BestNeighbor;
} // FindNearestNeighbor } // FindNearestNeighbor
/** /**
* This routine creates a new permanent cluster from the * This routine creates a new permanent cluster from the
* clusters specified in TempCluster. The 2 clusters in * clusters specified in TempCluster. The 2 clusters in
@ -872,7 +868,6 @@ CLUSTER *MakeNewCluster(CLUSTERER *Clusterer, TEMPCLUSTER *TempCluster) {
return Cluster; return Cluster;
} // MakeNewCluster } // MakeNewCluster
/** /**
* This routine merges two clusters into one larger cluster. * This routine merges two clusters into one larger cluster.
* To do this it computes the number of samples in the new * To do this it computes the number of samples in the new
@ -921,7 +916,6 @@ inT32 MergeClusters(inT16 N,
return n; return n;
} // MergeClusters } // MergeClusters
/** /**
* This routine decides which clusters in the cluster tree * This routine decides which clusters in the cluster tree
* should be represented by prototypes, forms a list of these * should be represented by prototypes, forms a list of these
@ -961,7 +955,6 @@ void ComputePrototypes(CLUSTERER *Clusterer, CLUSTERCONFIG *Config) {
} }
} // ComputePrototypes } // ComputePrototypes
/** /**
* This routine attempts to create a prototype from the * This routine attempts to create a prototype from the
* specified cluster that conforms to the distribution * specified cluster that conforms to the distribution
@ -1050,7 +1043,6 @@ PROTOTYPE *MakePrototype(CLUSTERER *Clusterer,
return Proto; return Proto;
} // MakePrototype } // MakePrototype
/** /**
* This routine checks for clusters which are degenerate and * This routine checks for clusters which are degenerate and
* therefore cannot be analyzed in a statistically valid way. * therefore cannot be analyzed in a statistically valid way.
@ -1247,7 +1239,6 @@ PROTOTYPE *MakeSphericalProto(CLUSTERER *Clusterer,
return (Proto); return (Proto);
} // MakeSphericalProto } // MakeSphericalProto
/** /**
* This routine tests the specified cluster to see if it can * This routine tests the specified cluster to see if it can
* be approximated by an elliptical normal distribution. If it * be approximated by an elliptical normal distribution. If it
@ -1286,7 +1277,6 @@ PROTOTYPE *MakeEllipticalProto(CLUSTERER *Clusterer,
return (Proto); return (Proto);
} // MakeEllipticalProto } // MakeEllipticalProto
/** /**
* This routine tests each dimension of the specified cluster to * This routine tests each dimension of the specified cluster to
* see what distribution would best approximate that dimension. * see what distribution would best approximate that dimension.
@ -1355,7 +1345,6 @@ PROTOTYPE *MakeMixedProto(CLUSTERER *Clusterer,
return (Proto); return (Proto);
} // MakeMixedProto } // MakeMixedProto
/** /**
* This routine alters the ith dimension of the specified * This routine alters the ith dimension of the specified
* mixed prototype to be D_random. * 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 // note that the proto Weight is irrelevant for D_random protos
} // MakeDimRandom } // MakeDimRandom
/** /**
* This routine alters the ith dimension of the specified * This routine alters the ith dimension of the specified
* mixed prototype to be uniform. * 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 // note that the proto Weight is irrelevant for uniform protos
} // MakeDimUniform } // MakeDimUniform
/** /**
* This routine searches the cluster tree for all leaf nodes * This routine searches the cluster tree for all leaf nodes
* which are samples in the specified cluster. It computes * which are samples in the specified cluster. It computes
@ -1502,7 +1489,6 @@ ComputeStatistics (inT16 N, PARAM_DESC ParamDesc[], CLUSTER * Cluster) {
return (Statistics); return (Statistics);
} // ComputeStatistics } // ComputeStatistics
/** /**
* This routine creates a spherical prototype data structure to * This routine creates a spherical prototype data structure to
* approximate the samples in the specified cluster. * approximate the samples in the specified cluster.
@ -1537,7 +1523,6 @@ PROTOTYPE *NewSphericalProto(uinT16 N,
return (Proto); return (Proto);
} // NewSphericalProto } // NewSphericalProto
/** /**
* This routine creates an elliptical prototype data structure to * This routine creates an elliptical prototype data structure to
* approximate the samples in the specified cluster. * approximate the samples in the specified cluster.
@ -1579,7 +1564,6 @@ PROTOTYPE *NewEllipticalProto(inT16 N,
return (Proto); return (Proto);
} // NewEllipticalProto } // NewEllipticalProto
/** /**
* This routine creates a mixed prototype data structure to * This routine creates a mixed prototype data structure to
* approximate the samples in the specified cluster. * approximate the samples in the specified cluster.
@ -1609,7 +1593,6 @@ PROTOTYPE *NewMixedProto(inT16 N, CLUSTER *Cluster, STATISTICS *Statistics) {
return (Proto); return (Proto);
} // NewMixedProto } // NewMixedProto
/** /**
* This routine allocates memory to hold a simple prototype * This routine allocates memory to hold a simple prototype
* data structure, i.e. one without independent distributions * data structure, i.e. one without independent distributions
@ -1640,7 +1623,6 @@ PROTOTYPE *NewSimpleProto(inT16 N, CLUSTER *Cluster) {
return (Proto); return (Proto);
} // NewSimpleProto } // NewSimpleProto
/** /**
* This routine returns TRUE if the specified covariance * This routine returns TRUE if the specified covariance
* matrix indicates that all N dimensions are independent of * matrix indicates that all N dimensions are independent of
@ -1692,7 +1674,6 @@ inT16 N, FLOAT32 * CoVariance, FLOAT32 Independence) {
return (TRUE); return (TRUE);
} // Independent } // Independent
/** /**
* This routine returns a histogram data structure which can * This routine returns a histogram data structure which can
* be used by other routines to place samples into histogram * be used by other routines to place samples into histogram
@ -1739,7 +1720,6 @@ BUCKETS *GetBuckets(CLUSTERER* clusterer,
return Buckets; return Buckets;
} // GetBuckets } // GetBuckets
/** /**
* This routine creates a histogram data structure which can * This routine creates a histogram data structure which can
* be used by other routines to place samples into histogram * be used by other routines to place samples into histogram
@ -1840,7 +1820,6 @@ BUCKETS *MakeBuckets(DISTRIBUTION Distribution,
return Buckets; return Buckets;
} // MakeBuckets } // MakeBuckets
/** /**
* This routine computes the optimum number of histogram * This routine computes the optimum number of histogram
* buckets that should be used in a chi-squared goodness of * buckets that should be used in a chi-squared goodness of
@ -1874,7 +1853,6 @@ uinT16 OptimumNumberOfBuckets(uinT32 SampleCount) {
return kBucketsTable[Last]; return kBucketsTable[Last];
} // OptimumNumberOfBuckets } // OptimumNumberOfBuckets
/** /**
* This routine computes the chi-squared value which will * This routine computes the chi-squared value which will
* leave a cumulative probability of Alpha in the right tail * leave a cumulative probability of Alpha in the right tail
@ -1932,7 +1910,6 @@ ComputeChiSquared (uinT16 DegreesOfFreedom, FLOAT64 Alpha)
} // ComputeChiSquared } // ComputeChiSquared
/** /**
* This routine computes the probability density function * This routine computes the probability density function
* of a discrete normal distribution defined by the global * of a discrete normal distribution defined by the global
@ -1943,7 +1920,8 @@ ComputeChiSquared (uinT16 DegreesOfFreedom, FLOAT64 Alpha)
* @note Globals: * @note Globals:
* kNormalMean mean of a discrete normal distribution * kNormalMean mean of a discrete normal distribution
* kNormalVariance variance 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. * @return The value of the normal distribution at x.
* @note Exceptions: None * @note Exceptions: None
* @note History: 6/4/89, DSJ, Created. * @note History: 6/4/89, DSJ, Created.
@ -1955,7 +1933,6 @@ FLOAT64 NormalDensity(inT32 x) {
return kNormalMagnitude * exp(-0.5 * Distance * Distance / kNormalVariance); return kNormalMagnitude * exp(-0.5 * Distance * Distance / kNormalVariance);
} // NormalDensity } // NormalDensity
/** /**
* This routine computes the probability density function * This routine computes the probability density function
* of a uniform distribution at the specified point. The * of a uniform distribution at the specified point. The
@ -1974,7 +1951,6 @@ FLOAT64 UniformDensity(inT32 x) {
return (FLOAT64) 0.0; return (FLOAT64) 0.0;
} // UniformDensity } // UniformDensity
/** /**
* This routine computes a trapezoidal approximation to the * This routine computes a trapezoidal approximation to the
* integral of a function over a small delta in x. * 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; return (f1 + f2) * Dx / 2.0;
} // Integral } // Integral
/** /**
* This routine counts the number of cluster samples which * This routine counts the number of cluster samples which
* fall within the various histogram buckets in Buckets. Only * fall within the various histogram buckets in Buckets. Only
@ -2071,7 +2046,6 @@ void FillBuckets(BUCKETS *Buckets,
} }
} // FillBuckets } // FillBuckets
/** /**
* This routine determines which bucket x falls into in the * This routine determines which bucket x falls into in the
* discrete normal distribution defined by kNormalMean * discrete normal distribution defined by kNormalMean
@ -2107,7 +2081,6 @@ uinT16 NormalBucket(PARAM_DESC *ParamDesc,
return (uinT16) floor((FLOAT64) X); return (uinT16) floor((FLOAT64) X);
} // NormalBucket } // NormalBucket
/** /**
* This routine determines which bucket x falls into in the * This routine determines which bucket x falls into in the
* discrete uniform distribution defined by * discrete uniform distribution defined by
@ -2143,7 +2116,6 @@ uinT16 UniformBucket(PARAM_DESC *ParamDesc,
return (uinT16) floor((FLOAT64) X); return (uinT16) floor((FLOAT64) X);
} // UniformBucket } // UniformBucket
/** /**
* This routine performs a chi-square goodness of fit test * This routine performs a chi-square goodness of fit test
* on the histogram data in the Buckets data structure. TRUE * on the histogram data in the Buckets data structure. TRUE
@ -2176,7 +2148,6 @@ BOOL8 DistributionOK(BUCKETS *Buckets) {
return TRUE; return TRUE;
} // DistributionOK } // DistributionOK
/** /**
* This routine frees the memory used by the statistics * This routine frees the memory used by the statistics
* data structure. * data structure.
@ -2192,7 +2163,6 @@ void FreeStatistics(STATISTICS *Statistics) {
memfree(Statistics); memfree(Statistics);
} // FreeStatistics } // FreeStatistics
/** /**
* This routine properly frees the memory used by a BUCKETS. * This routine properly frees the memory used by a BUCKETS.
* *
@ -2204,7 +2174,6 @@ void FreeBuckets(BUCKETS *buckets) {
Efree(buckets); Efree(buckets);
} // FreeBuckets } // FreeBuckets
/** /**
* This routine frees the memory consumed by the specified * This routine frees the memory consumed by the specified
* cluster and all of its subclusters. This is done by * cluster and all of its subclusters. This is done by
@ -2225,7 +2194,6 @@ void FreeCluster(CLUSTER *Cluster) {
} }
} // FreeCluster } // FreeCluster
/** /**
* This routine computes the degrees of freedom that should * This routine computes the degrees of freedom that should
* be used in a chi-squared test with the specified number of * be used in a chi-squared test with the specified number of
@ -2252,7 +2220,6 @@ uinT16 DegreesOfFreedom(DISTRIBUTION Distribution, uinT16 HistogramBuckets) {
} // DegreesOfFreedom } // DegreesOfFreedom
/** /**
* This routine is used to search a list of histogram data * This routine is used to search a list of histogram data
* structures to find one with the specified number of * structures to find one with the specified number of
@ -2272,7 +2239,6 @@ int NumBucketsMatch(void *arg1, // BUCKETS *Histogram,
} // NumBucketsMatch } // NumBucketsMatch
/** /**
* This routine is used to search a list for a list node * This routine is used to search a list for a list node
* whose contents match Key. It is called by the list * whose contents match Key. It is called by the list
@ -2287,7 +2253,6 @@ int ListEntryMatch(void *arg1, //ListNode
} // ListEntryMatch } // ListEntryMatch
/** /**
* This routine multiplies each ExpectedCount histogram entry * This routine multiplies each ExpectedCount histogram entry
* by NewSampleCount/OldSampleCount so that the histogram * by NewSampleCount/OldSampleCount so that the histogram
@ -2313,7 +2278,6 @@ void AdjustBuckets(BUCKETS *Buckets, uinT32 NewSampleCount) {
} // AdjustBuckets } // AdjustBuckets
/** /**
* This routine sets the bucket counts in the specified histogram * This routine sets the bucket counts in the specified histogram
* to zero. * to zero.
@ -2331,7 +2295,6 @@ void InitBuckets(BUCKETS *Buckets) {
} // InitBuckets } // InitBuckets
/** /**
* This routine is used to search a list of structures which * This routine is used to search a list of structures which
* hold pre-computed chi-squared values for a chi-squared * hold pre-computed chi-squared values for a chi-squared
@ -2355,7 +2318,6 @@ int AlphaMatch(void *arg1, //CHISTRUCT *ChiStruct
} // AlphaMatch } // AlphaMatch
/** /**
* This routine allocates a new data structure which is used * This routine allocates a new data structure which is used
* to hold a chi-squared value along with its associated * to hold a chi-squared value along with its associated
@ -2377,7 +2339,6 @@ CHISTRUCT *NewChiStruct(uinT16 DegreesOfFreedom, FLOAT64 Alpha) {
} // NewChiStruct } // NewChiStruct
/** /**
* This routine attempts to find an x value at which Function * This routine attempts to find an x value at which Function
* goes to zero (i.e. a root of the function ). It will only * goes to zero (i.e. a root of the function ). It will only
@ -2440,7 +2401,6 @@ void *FunctionParams, FLOAT64 InitialGuess, FLOAT64 Accuracy)
} // Solve } // Solve
/** /**
* This routine computes the area under a chi density curve * This routine computes the area under a chi density curve
* from 0 to x, minus the desired area under the curve. The * from 0 to x, minus the desired area under the curve. The
@ -2480,7 +2440,6 @@ FLOAT64 ChiArea(CHISTRUCT *ChiParams, FLOAT64 x) {
} // ChiArea } // ChiArea
/** /**
* This routine looks at all samples in the specified cluster. * This routine looks at all samples in the specified cluster.
* It computes a running estimate of the percentage of the * 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-------------------- //---------------Global Data Definitions and Declarations--------------------
#define TOKENSIZE 80 //< max size of tokens read from an input file #define TOKENSIZE 80 //< max size of tokens read from an input file
#define MAXSAMPLESIZE 65535 //< max num of dimensions in feature space #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 * 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 Exceptions: None
* @note History: 6/6/89, DSJ, Created. * @note History: 6/6/89, DSJ, Created.
*/ */
void void WriteParamDesc(FILE *File, uinT16 N, const PARAM_DESC ParamDesc[]) {
WriteParamDesc (FILE * File, uinT16 N, PARAM_DESC ParamDesc[]) {
int i; int i;
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
@ -446,14 +446,9 @@ void WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle) {
* @note History: 6/12/89, DSJ, Created. * @note History: 6/12/89, DSJ, Created.
*/ */
void WriteProtoList( void WriteProtoList(FILE *File, uinT16 N, PARAM_DESC ParamDesc[],
FILE *File, LIST ProtoList, BOOL8 WriteSigProtos,
uinT16 N, BOOL8 WriteInsigProtos) {
PARAM_DESC ParamDesc[],
LIST ProtoList,
BOOL8 WriteSigProtos,
BOOL8 WriteInsigProtos)
{
PROTOTYPE *Proto; PROTOTYPE *Proto;
/* write file header */ /* write file header */
@ -464,8 +459,8 @@ void WriteProtoList(
iterate(ProtoList) iterate(ProtoList)
{ {
Proto = (PROTOTYPE *) first_node ( ProtoList ); Proto = (PROTOTYPE *) first_node ( ProtoList );
if (( Proto->Significant && WriteSigProtos ) || if ((Proto->Significant && WriteSigProtos) ||
( ! Proto->Significant && WriteInsigProtos ) ) (!Proto->Significant && WriteInsigProtos))
WritePrototype( File, N, Proto ); 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[]); 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); 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 WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle);
void WriteProtoList( void WriteProtoList(FILE *File, uinT16 N, PARAM_DESC ParamDesc[],
FILE *File, LIST ProtoList, BOOL8 WriteSigProtos,
uinT16 N,
PARAM_DESC ParamDesc[],
LIST ProtoList,
BOOL8 WriteSigProtos,
BOOL8 WriteInsigProtos); BOOL8 WriteInsigProtos);
//--------------Global Data Definitions and Declarations--------------------- //--------------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) if (Angle < 0.0 || Angle >= FullScale)
Angle = 0.0; Angle = 0.0;
return (Angle); return (Angle);
} }

2
classify/intfx.cpp
View File

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

26
classify/intmatcher.cpp
View File

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

26
classify/intproto.cpp
View File

@ -46,9 +46,7 @@
#include "config_auto.h" #include "config_auto.h"
#endif #endif
using tesseract::FontInfo;
using tesseract::FontSet; using tesseract::FontSet;
using tesseract::FontSpacingInfo;
/* match debug display constants*/ /* match debug display constants*/
#define PROTO_PRUNER_SCALE (4.0) #define PROTO_PRUNER_SCALE (4.0)
@ -326,10 +324,8 @@ int AddIntProto(INT_CLASS Class) {
Word < Proto->Configs + WERDS_PER_CONFIG_VEC; *Word++ = 0); Word < Proto->Configs + WERDS_PER_CONFIG_VEC; *Word++ = 0);
return (Index); return (Index);
} }
/** /**
* This routine adds Proto to the class pruning tables * This routine adds Proto to the class pruning tables
* for the specified class in Templates. * for the specified class in Templates.
@ -372,7 +368,6 @@ void AddProtoToClassPruner (PROTO Proto, CLASS_ID ClassId,
} }
} /* AddProtoToClassPruner */ } /* AddProtoToClassPruner */
/** /**
* This routine updates the proto pruner lookup tables * This routine updates the proto pruner lookup tables
* for Class to include a new proto identified by ProtoId * 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); FillPPLinearBits(ProtoSet->ProtoPruner[PRUNER_Y], Index, Y, Pad, debug);
} /* AddProtoToProtoPruner */ } /* AddProtoToProtoPruner */
/** /**
* Returns a quantized bucket for the given param shifted by offset, * Returns a quantized bucket for the given param shifted by offset,
* notionally (param + offset) * num_buckets, but clipped and casted to the * 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]); P->A, P->B, P->C, Class->ProtoLengths[ProtoId]);
} /* ConvertProto */ } /* ConvertProto */
/** /**
* This routine converts from the old floating point format * This routine converts from the old floating point format
* to the new integer format. * to the new integer format.
@ -627,7 +620,7 @@ INT_TEMPLATES Classify::CreateIntTemplates(CLASSES FloatProtos,
* @note Exceptions: none * @note Exceptions: none
* @note History: Thu Mar 21 14:45:04 1991, DSJ, Created. * @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); ScrollView::Color color = GetMatchColorFor(Evidence);
RenderIntFeature(IntMatchWindow, Feature, color); RenderIntFeature(IntMatchWindow, Feature, color);
if (FeatureDisplayWindow) { if (FeatureDisplayWindow) {
@ -635,7 +628,6 @@ void DisplayIntFeature(const INT_FEATURE_STRUCT* Feature, FLOAT32 Evidence) {
} }
} /* DisplayIntFeature */ } /* DisplayIntFeature */
/** /**
* This routine renders the specified proto into a * This routine renders the specified proto into a
* global display list. * global display list.
@ -720,7 +712,6 @@ void free_int_class(INT_CLASS int_class) {
Efree(int_class); Efree(int_class);
} }
/** /**
* This routine allocates a new set of integer templates * This routine allocates a new set of integer templates
* initialized to hold 0 classes. * initialized to hold 0 classes.
@ -1218,7 +1209,6 @@ FLOAT32 BucketStart(int Bucket, FLOAT32 Offset, int NumBuckets) {
} /* BucketStart */ } /* BucketStart */
/** /**
* This routine returns the parameter value which * This routine returns the parameter value which
* corresponds to the end of the specified bucket. * 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); return (((FLOAT32) (Bucket + 1) / NumBuckets) - Offset);
} /* BucketEnd */ } /* BucketEnd */
/** /**
* This routine fills in the section of a class pruner * This routine fills in the section of a class pruner
* corresponding to a single x value for a single proto of * corresponding to a single x value for a single proto of
@ -1284,7 +1273,6 @@ void DoFill(FILL_SPEC *FillSpec,
} }
} /* DoFill */ } /* DoFill */
/** /**
* Return TRUE if the specified table filler is done, i.e. * Return TRUE if the specified table filler is done, i.e.
* if it has no more lines to fill. * if it has no more lines to fill.
@ -1306,7 +1294,6 @@ BOOL8 FillerDone(TABLE_FILLER *Filler) {
} /* FillerDone */ } /* FillerDone */
/** /**
* This routine sets Bit in each bit vector whose * This routine sets Bit in each bit vector whose
* bucket lies within the range Center +- Spread. The fill * 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 */ } /* FillPPCircularBits */
/** /**
* This routine sets Bit in each bit vector whose * This routine sets Bit in each bit vector whose
* bucket lies within the range Center +- Spread. The fill * bucket lies within the range Center +- Spread. The fill
@ -1516,7 +1502,6 @@ void GetCPPadsForLevel(int Level,
} /* GetCPPadsForLevel */ } /* GetCPPadsForLevel */
/** /**
* @param Evidence evidence value to return color for * @param Evidence evidence value to return color for
* @return Color which corresponds to specified Evidence value. * @return Color which corresponds to specified Evidence value.
@ -1538,7 +1523,6 @@ ScrollView::Color GetMatchColorFor(FLOAT32 Evidence) {
return ScrollView::BLUE; return ScrollView::BLUE;
} /* GetMatchColorFor */ } /* GetMatchColorFor */
/** /**
* This routine returns (in Fill) the specification of * This routine returns (in Fill) the specification of
* the next line to be filled from Filler. FillerDone() should * the next line to be filled from Filler. FillerDone() should
@ -1589,7 +1573,6 @@ void GetNextFill(TABLE_FILLER *Filler, FILL_SPEC *Fill) {
} /* GetNextFill */ } /* GetNextFill */
/** /**
* This routine computes a data structure (Filler) * This routine computes a data structure (Filler)
* which can be used to fill in a rectangle surrounding * 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 */ /* translate into bucket positions and deltas */
Filler->X = Bucket8For(Start.x, XS, NB); Filler->X = Bucket8For(Start.x, XS, NB);
Filler->StartDelta = -(inT16) ((Sin / Cos) * 256); Filler->StartDelta = static_cast<inT16>(ClipToRange<int>(
Filler->EndDelta = (inT16) ((Cos / Sin) * 256); -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; XAdjust = BucketEnd(Filler->X, XS, NB) - Start.x;
YAdjust = XAdjust * Sin / Cos; YAdjust = XAdjust * Sin / Cos;
@ -1787,7 +1772,6 @@ void RenderIntFeature(ScrollView *window, const INT_FEATURE_STRUCT* Feature,
window->DrawTo(X + Dx, Y + Dy); window->DrawTo(X + Dx, Y + Dy);
} /* RenderIntFeature */ } /* RenderIntFeature */
/** /**
* This routine extracts the parameters of the specified * This routine extracts the parameters of the specified
* proto from the class description and adds a rendering of * 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 NUM_CP_BUCKETS 24
#define CLASSES_PER_CP 32 #define CLASSES_PER_CP 32
#define NUM_BITS_PER_CLASS 2 #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 CLASSES_PER_CP_WERD (CLASSES_PER_CP / NUM_BITS_PER_CLASS)
#define PROTOS_PER_PP_WERD BITS_PER_WERD #define PROTOS_PER_PP_WERD BITS_PER_WERD
#define BITS_PER_CP_VECTOR (CLASSES_PER_CP * NUM_BITS_PER_CLASS) #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: private:
const Key max_key_; //< the maximum possible Key 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 elements_count_; //< the number of results collected so far
int k_; //< the number of results we want from the search int k_; //< the number of results we want from the search
int max_index_; //< the index of the result with the largest key 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 { class KDTreeSearch {
public: public:
KDTreeSearch(KDTREE* tree, FLOAT32 *query_point, int k_closest); 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); *PtrToNode = MakeKDNode(Tree, Key, (void *) Data, Level);
} /* KDStore */ } /* KDStore */
/** /**
* This routine deletes a node from Tree. The node to be * This routine deletes a node from Tree. The node to be
* deleted is specified by the Key for the node and the Data * deleted is specified by the Key for the node and the Data
@ -298,7 +298,6 @@ KDDelete (KDTREE * Tree, FLOAT32 Key[], void *Data) {
} }
} /* KDDelete */ } /* KDDelete */
/** /**
* This routine searches the K-D tree specified by Tree and * This routine searches the K-D tree specified by Tree and
* finds the QuerySize nearest neighbors of Query. All neighbors * 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)); Walk(tree, action, context, sub_tree->Right, NextLevel(tree, level));
} }
/** Given a subtree nodes, insert all of its elements into tree. */ /** Given a subtree nodes, insert all of its elements into tree. */
void InsertNodes(KDTREE *tree, KDNODE *nodes) { void InsertNodes(KDTREE *tree, KDNODE *nodes) {
if (nodes == NULL) if (nodes == NULL)

8
classify/mastertrainer.cpp
View File

@ -362,9 +362,11 @@ bool MasterTrainer::LoadFontInfo(const char* filename) {
fontinfo.name = font_name; fontinfo.name = font_name;
fontinfo.properties = 0; fontinfo.properties = 0;
fontinfo.universal_id = 0; fontinfo.universal_id = 0;
if (tfscanf(fp, "%1024s %i %i %i %i %i\n", font_name, if (tfscanf(fp, "%1024s %i %i %i %i %i\n", font_name, &italic, &bold,
&italic, &bold, &fixed, &serif, &fraktur) != 6) &fixed, &serif, &fraktur) != 6) {
delete[] font_name;
continue; continue;
}
fontinfo.properties = fontinfo.properties =
(italic << 0) + (italic << 0) +
(bold << 1) + (bold << 1) +
@ -373,6 +375,8 @@ bool MasterTrainer::LoadFontInfo(const char* filename) {
(fraktur << 4); (fraktur << 4);
if (!fontinfo_table_.contains(fontinfo)) { if (!fontinfo_table_.contains(fontinfo)) {
fontinfo_table_.push_back(fontinfo); fontinfo_table_.push_back(fontinfo);
} else {
delete[] font_name;
} }
} }
fclose(fp); 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 ConvertBlob(TBLOB *blob) {
LIST outlines = NIL_LIST; LIST outlines = NIL_LIST;
return (blob == NULL) return (blob == NULL)
@ -344,7 +345,6 @@ void ChangeDirection(MFOUTLINE Start, MFOUTLINE End, DIRECTION Direction) {
} /* ChangeDirection */ } /* ChangeDirection */
/** /**
* This routine normalizes each point in Outline by * This routine normalizes each point in Outline by
* translating it to the specified center and scaling it * translating it to the specified center and scaling it
@ -378,7 +378,6 @@ void CharNormalizeOutline(MFOUTLINE Outline, const DENORM& cn_denorm) {
} /* CharNormalizeOutline */ } /* CharNormalizeOutline */
/** /**
* This routine computes the slope from Start to Finish and * This routine computes the slope from Start to Finish and
* and then computes the approximate direction of the line * 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); return (Orientation);
} /* ComputeOrientation */ } /* ComputeOrientation */
/** /**
* Convert Outline to MicroFeatures * Convert Outline to MicroFeatures
* @param Outline outline to extract micro-features from * @param Outline outline to extract micro-features from
@ -164,7 +163,6 @@ MICROFEATURES ConvertToMicroFeatures(MFOUTLINE Outline,
return (MicroFeatures); return (MicroFeatures);
} /* ConvertToMicroFeatures */ } /* ConvertToMicroFeatures */
/** /**
* This routine computes the feature parameters which describe * This routine computes the feature parameters which describe
* the micro-feature that starts and Start and ends at End. * 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 (Feature->Params[CharNormLength] * LENGTH_COMPRESSION);
} }
/** /**
* Return the character normalization feature for a blob. * Return the character normalization feature for a blob.
* *

17
classify/ocrfeatures.cpp
View File

@ -66,7 +66,6 @@ void FreeFeature(FEATURE Feature) {
} /* FreeFeature */ } /* FreeFeature */
/** /**
* Release the memory consumed by the specified feature * Release the memory consumed by the specified feature
* set. This routine also frees the memory consumed by the * set. This routine also frees the memory consumed by the
@ -85,7 +84,6 @@ void FreeFeatureSet(FEATURE_SET FeatureSet) {
} }
} /* FreeFeatureSet */ } /* FreeFeatureSet */
/** /**
* Allocate and return a new feature of the specified * Allocate and return a new feature of the specified
* type. * type.
@ -105,7 +103,6 @@ FEATURE NewFeature(const FEATURE_DESC_STRUCT* FeatureDesc) {
} /* NewFeature */ } /* NewFeature */
/** /**
* Allocate and return a new feature set large enough to * Allocate and return a new feature set large enough to
* hold the specified number of features. * hold the specified number of features.
@ -124,7 +121,6 @@ FEATURE_SET NewFeatureSet(int NumFeatures) {
} /* NewFeatureSet */ } /* NewFeatureSet */
/** /**
* Create a new feature of the specified type and read in * Create a new feature of the specified type and read in
* the value of its parameters from File. The extra penalty * 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 File open text file to read feature from
* @param FeatureDesc specifies type of feature to read from File * @param FeatureDesc specifies type of feature to read from File
* @return New #FEATURE 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. * @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; FEATURE Feature;
int i; int i;
@ -153,7 +150,6 @@ FEATURE ReadFeature(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
return (Feature); return (Feature);
} /* ReadFeature */ } /* ReadFeature */
/** /**
* Create a new feature set of the specified type and read in * Create a new feature set of the specified type and read in
* the features from File. The correct text representation * 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. * @return New feature set read from File.
* @note History: Wed May 23 09:17:31 1990, DSJ, Created. * @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; FEATURE_SET FeatureSet;
int NumFeatures; int NumFeatures;
int i; int i;
@ -180,7 +176,6 @@ FEATURE_SET ReadFeatureSet(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
return (FeatureSet); return (FeatureSet);
} /* ReadFeatureSet */ } /* ReadFeatureSet */
/** /**
* Appends a textual representation of Feature to str. * Appends a textual representation of Feature to str.
* This representation is simply a list of the N parameters * This representation is simply a list of the N parameters
@ -203,7 +198,6 @@ void WriteFeature(FEATURE Feature, STRING* str) {
*str += "\n"; *str += "\n";
} /* WriteFeature */ } /* WriteFeature */
/** /**
* Write a textual representation of FeatureSet to File. * Write a textual representation of FeatureSet to File.
* This representation is an integer specifying the number of * This representation is an integer specifying the number of
@ -224,7 +218,6 @@ void WriteFeatureSet(FEATURE_SET FeatureSet, STRING* str) {
} }
} /* WriteFeatureSet */ } /* WriteFeatureSet */
/** /**
* Write a textual representation of FeatureDesc to File * Write a textual representation of FeatureDesc to File
* in the old format (i.e. the format used by the clusterer). * 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 * @return none
* @note History: Fri May 25 15:27:18 1990, DSJ, Created. * @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; int i;
fprintf (File, "%d\n", FeatureDesc->NumParams); 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) { for (int i = 0; i < results.size(); ++i) {
tprintf("%g: c_id=%d=%s", results[i].rating, results[i].unichar_id, tprintf("%g: c_id=%d=%s", results[i].rating, results[i].unichar_id,
GetUnicharset().id_to_unichar(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:"); tprintf(" Font Vector:");
for (int f = 0; f < results[i].fonts.size(); ++f) { for (int f = 0; f < results[i].fonts.size(); ++f) {
tprintf(" %d", results[i].fonts[f].fontinfo_id); 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; float prob = 0.0;
// gap is too small => no space // 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; prob = 0.0;
} else if (gap > max_spc_gap_) { } else if (gap > max_spc_gap_) {
// gap is too big => definite space // 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 // split into lines
vector<string> str_vec; vector<string> str_vec;
CubeUtils::SplitStringUsing(str, "\r\n", &str_vec); CubeUtils::SplitStringUsing(str, "\r\n", &str_vec);
if (str_vec.size() <= 0) { if (str_vec.empty()) {
return false; 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); CubeUtils::SplitStringUsing(key_str, " \t", &words);
// no words => no cost // no words => no cost
if (words.size() <= 0) { if (words.empty()) {
return 0; return 0;
} }

42
cutil/bitvec.h
View File

@ -30,29 +30,29 @@ typedef uinT32 *BIT_VECTOR;
/*----------------------------------------------------------------------------- /*-----------------------------------------------------------------------------
Public Function Prototypes Public Function Prototypes
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
#define zero_all_bits(array,length) \ #define zero_all_bits(array, length) \
{\ { \
int index; /*temporary index*/\ int index; /*temporary index*/ \
\ \
for (index=0;index<length;index++)\ for (index = 0; index < length; index++) \
array[index]=0; /*zero all bits*/\ array[index] = 0; /*zero all bits*/ \
} }
#define set_all_bits(array,length) \ #define set_all_bits(array, length) \
{\ { \
int index; /*temporary index*/\ int index; /*temporary index*/ \
\ \
for (index=0;index<length;index++)\ for (index = 0; index < length; index++) \
array[index]= ~0; /*set all bits*/\ array[index] = ~0; /*set all bits*/ \
} }
#define copy_all_bits(source,dest,length) \ #define copy_all_bits(source, dest, length) \
{\ { \
int index; /*temporary index*/\ int index; /*temporary index*/ \
\ \
for (index=0;index<length;index++)\ for (index = 0; index < length; index++) \
dest[index]=source[index]; /*copy all bits*/\ dest[index] = source[index]; /*copy all bits*/ \
} }
#define SET_BIT(array,bit) (array[bit/BITSINLONG]|=1<<(bit&(BITSINLONG-1))) #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; destructor = memfree;
while (list != NIL_LIST) { while (list != NIL_LIST) {
(*destructor) (first_node (list)); if (first_node(list) != NULL) (*destructor)(first_node(list));
list = pop (list); list = pop(list);
} }
} }

34
dict/context.cpp
View File

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

54
dict/dict.cpp
View File

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

6
opencl/oclkernels.h
View File

@ -1092,7 +1092,8 @@ void kernel_ThresholdRectToPix(
for ( int c = 0; c < NUM_CHANNELS; c++) { for ( int c = 0; c < NUM_CHANNELS; c++) {
unsigned char pixChan = pixels.s[p*NUM_CHANNELS + c]; unsigned char pixChan = pixels.s[p*NUM_CHANNELS + c];
if (pHi_Values[c] >= 0 && (pixChan > pThresholds[c]) == (pHi_Values[c] == 0)) { 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 \n#endif\n
unsigned char pixChan = pixels.s[idx]; unsigned char pixChan = pixels.s[idx];
if (pHi_Values[0] >= 0 && (pixChan > pThresholds[0]) == (pHi_Values[0] == 0)) { 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) { if (profile->devices!=NULL && sr!=NULL) {
unsigned int i; unsigned int i;
for (i = 0; i < profile->numDevices; i++) { for (i = 0; i < profile->numDevices; i++) {
if (profile->devices[i].oclDeviceName) free(profile->devices[i].oclDeviceName); if (profile->devices[i].oclDeviceName)
if (profile->devices[i].oclDriverVersion) free(profile->devices[i].oclDriverVersion); free(profile->devices[i].oclDeviceName);
if (profile->devices[i].oclDriverVersion)
free(profile->devices[i].oclDriverVersion);
status = sr(profile->devices[i].score); status = sr(profile->devices[i].score);
if (status != DS_SUCCESS) if (status != DS_SUCCESS)
break; 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 // including CL/cl.h doesn't occur until USE_OPENCL defined below
// platform preprocessor commands // 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_WINDOWS 1
#define ON_LINUX 0 #define ON_LINUX 0
#define ON_APPLE 0 #define ON_APPLE 0
@ -82,7 +83,8 @@
#define PERF_COUNT_END \ #define PERF_COUNT_END \
QueryPerformanceCounter(&time_funct_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); printf(PERF_COUNT_REPORT_STR, funct_name, "total", elapsed_time_sec);
#else #else
#define PERF_COUNT_START(FUNCT_NAME) #define PERF_COUNT_START(FUNCT_NAME)
@ -92,7 +94,8 @@
#if PERF_COUNT_VERBOSE >= 3 #if PERF_COUNT_VERBOSE >= 3
#define PERF_COUNT_SUB(SUB) \ #define PERF_COUNT_SUB(SUB) \
QueryPerformanceCounter(&time_sub_end); \ 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); \ printf(PERF_COUNT_REPORT_STR, funct_name, SUB, elapsed_time_sec); \
time_sub_start = time_sub_end; time_sub_start = time_sub_end;
#else #else
@ -113,8 +116,10 @@
time_sub_end = time_funct_start; time_sub_end = time_funct_start;
#define PERF_COUNT_END \ #define PERF_COUNT_END \
clock_gettime( CLOCK_MONOTONIC, &time_funct_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; \ 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); printf(PERF_COUNT_REPORT_STR, funct_name, "total", elapsed_time_sec);
#else #else
#define PERF_COUNT_START(FUNCT_NAME) #define PERF_COUNT_START(FUNCT_NAME)
@ -123,8 +128,10 @@
#if PERF_COUNT_VERBOSE >= 3 #if PERF_COUNT_VERBOSE >= 3
#define PERF_COUNT_SUB(SUB) \ #define PERF_COUNT_SUB(SUB) \
clock_gettime( CLOCK_MONOTONIC, &time_sub_end ); \ 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; \ 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); \ printf(PERF_COUNT_REPORT_STR, funct_name, SUB, elapsed_time_sec); \
time_sub_start = time_sub_end; time_sub_start = time_sub_end;
#else #else
@ -253,12 +260,12 @@ public:
// OpenCL implementation of Morphology (Hollow = Closed - Open) // 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 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, static void pixGetLinesCL(PIX *pixd, PIX *pixs, PIX **pix_vline,
PIX** pix_vline, PIX** pix_hline, PIX **pix_hline, PIX **pixClosed,
PIX** pixClosed, bool getpixClosed, bool getpixClosed, l_int32 close_hsize,
l_int32 close_hsize, l_int32 close_vsize, l_int32 close_vsize, l_int32 open_hsize,
l_int32 open_hsize, l_int32 open_vsize, l_int32 open_vsize, l_int32 line_hsize,
l_int32 line_hsize, l_int32 line_vsize); l_int32 line_vsize);
//int InitOpenclAttr( OpenCLEnv * env ); //int InitOpenclAttr( OpenCLEnv * env );
//int ReleaseKernel( KernelEnv * env ); //int ReleaseKernel( KernelEnv * env );
@ -279,34 +286,24 @@ public:
static void FreeOpenclDll(); static void FreeOpenclDll();
#endif #endif
inline static int AddKernelConfig( int kCount, const char *kName ); inline static int AddKernelConfig( int kCount, const char *kName );
/* for binarization */ /* for binarization */
static int HistogramRectOCL( static int HistogramRectOCL(const unsigned char *imagedata,
const unsigned char *imagedata, int bytes_per_pixel, int bytes_per_line,
int bytes_per_pixel, int left, int top, int width, int height,
int bytes_per_line, int kHistogramSize, int *histogramAllChannels);
int left,
int top,
int width,
int height,
int kHistogramSize,
int *histogramAllChannels);
static int ThresholdRectToPixOCL( static int ThresholdRectToPixOCL(const unsigned char *imagedata,
const unsigned char* imagedata, int bytes_per_pixel, int bytes_per_line,
int bytes_per_pixel, const int *thresholds,
int bytes_per_line, const int *hi_values, Pix **pix,
const int* thresholds, int rect_height, int rect_width,
const int* hi_values, int rect_top, int rect_left);
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 getDeviceSelection();
static ds_device selectedDevice; static ds_device selectedDevice;

2
textord/alignedblob.cpp
View File

@ -188,7 +188,7 @@ ScrollView* AlignedBlob::DisplayTabs(const char* window_name,
gsearch.StartFullSearch(); gsearch.StartFullSearch();
BLOBNBOX* bbox; BLOBNBOX* bbox;
while ((bbox = gsearch.NextFullSearch()) != NULL) { while ((bbox = gsearch.NextFullSearch()) != NULL) {
TBOX box = bbox->bounding_box(); const TBOX& box = bbox->bounding_box();
int left_x = box.left(); int left_x = box.left();
int right_x = box.right(); int right_x = box.right();
int top_y = box.top(); 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. // Note that the Pix is used upside-down, with (0, 0) being the bottom-left.
Pix* TraceOutlineOnReducedPix(C_OUTLINE* outline, int gridsize, Pix* TraceOutlineOnReducedPix(C_OUTLINE* outline, int gridsize,
ICOORD bleft, int* left, int* bottom) { 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); Pix* pix = GridReducedPix(box, gridsize, bleft, left, bottom);
int wpl = pixGetWpl(pix); int wpl = pixGetWpl(pix);
l_uint32* data = pixGetData(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. // As TraceOutlineOnReducedPix above, but on a BLOCK instead of a C_OUTLINE.
Pix* TraceBlockOnReducedPix(BLOCK* block, int gridsize, Pix* TraceBlockOnReducedPix(BLOCK* block, int gridsize,
ICOORD bleft, int* left, int* bottom) { 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); Pix* pix = GridReducedPix(box, gridsize, bleft, left, bottom);
int wpl = pixGetWpl(pix); int wpl = pixGetWpl(pix);
l_uint32* data = pixGetData(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(); gsearch.StartFullSearch();
BBC* bbox; BBC* bbox;
while ((bbox = gsearch.NextFullSearch()) != NULL) { while ((bbox = gsearch.NextFullSearch()) != NULL) {
TBOX box = bbox->bounding_box(); const TBOX& box = bbox->bounding_box();
int left_x = box.left(); int left_x = box.left();
int right_x = box.right(); int right_x = box.right();
int top_y = box.top(); 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. // Search the grid to see what intersects it.
// Setup a Rectangle search for overlapping this blob. // Setup a Rectangle search for overlapping this blob.
BlobGridSearch rsearch(this); BlobGridSearch rsearch(this);
TBOX box = blob->bounding_box(); const TBOX& box = blob->bounding_box();
rsearch.StartRectSearch(box); rsearch.StartRectSearch(box);
rsearch.SetUniqueMode(true); rsearch.SetUniqueMode(true);
BLOBNBOX* neighbour; 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()) { for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
bbox = it.data(); bbox = it.data();
if (non_leader_count == 0 || bbox->flow() != BTFT_LEADER) { if (non_leader_count == 0 || bbox->flow() != BTFT_LEADER) {
TBOX box = bbox->bounding_box(); const TBOX& box = bbox->bounding_box();
int area = box.area(); int area = box.area();
top_stats.add(box.top(), area); top_stats.add(box.top(), area);
bottom_stats.add(box.bottom(), area); bottom_stats.add(box.bottom(), area);
@ -1181,8 +1181,8 @@ bool ColPartition::MarkAsLeaderIfMonospaced() {
if (best_end == NULL) { if (best_end == NULL) {
tprintf("No path\n"); tprintf("No path\n");
} else { } else {
tprintf("Total cost = %d vs allowed %d\n", tprintf("Total cost = %d vs allowed %d\n", best_end->total_cost(),
best_end->total_cost(), blob_count); blob_count);
} }
} }
delete [] projection; delete [] projection;
@ -2121,7 +2121,7 @@ void ColPartition::RefinePartnersByOverlap(bool upper,
// Return true if bbox belongs better in this than other. // Return true if bbox belongs better in this than other.
bool ColPartition::ThisPartitionBetter(BLOBNBOX* bbox, bool ColPartition::ThisPartitionBetter(BLOBNBOX* bbox,
const ColPartition& other) { const ColPartition& other) {
TBOX box = bbox->bounding_box(); const TBOX& box = bbox->bounding_box();
// Margins take priority. // Margins take priority.
int left = box.left(); int left = box.left();
int right = box.right(); int right = box.right();

10
textord/colpartitiongrid.cpp
View File

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

4
textord/devanagari_processing.h
View File

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

3
textord/drawedg.h
View File

@ -1,6 +1,7 @@
/********************************************************************** /**********************************************************************
* File: drawedg.h (Formerly drawedge.h) * 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 * Author: Ray Smith
* Created: Thu Jun 06 13:29:20 BST 1991 * 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; return NULL;
} }
/********************************************************************** /**********************************************************************
* join_segments * join_segments
* *

4
textord/imagefind.cpp
View File

@ -1115,7 +1115,7 @@ static bool TestWeakIntersectedPart(const TBOX& im_box,
ColPartition* part) { ColPartition* part) {
if (part->flow() < BTFT_STRONG_CHAIN) { if (part->flow() < BTFT_STRONG_CHAIN) {
// A weak partition intersects the box. // 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)) { if (im_box.contains(part_box)) {
int area = part_box.area(); int area = part_box.area();
int intersect_area = IntersectArea(part_box, part_list); 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) { part->flow() == BTFT_STRONG_CHAIN) {
// Text intersects the box. // Text intersects the box.
any_text_in_padded_rect = true; any_text_in_padded_rect = true;
TBOX part_box = part->bounding_box(); const TBOX& part_box = part->bounding_box();
if (box->overlap(part_box)) { if (box->overlap(part_box)) {
return true; 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 TO_ROW_IT *row_it, //current position
BOOL8 testing_on //correct orientation BOOL8 testing_on //correct orientation
) { ) {
inT32 next_index; //of neighbouring row inT32 next_index; // of neighbouring row
inT32 row_offset; //from current row inT32 row_offset; //from current row
inT32 abs_dist; //absolute distance inT32 abs_dist; //absolute distance
inT8 row_inc; //increment to row_index 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); BLOBNBOX_IT blob_it(blobs);
for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) { for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
BLOBNBOX* blob = blob_it.data(); 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)) { if (blob_box.height() >= min_height && box.major_overlap(blob_box)) {
++overlaps; ++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 TO_ROW **rows; //array of ptrs
int rowcount; /*no of rows to do */ int rowcount; /*no of rows to do */
int rowindex; /*no of row */ int rowindex; /*no of row */
//iterator // iterator
TO_ROW_IT row_it = block->get_rows (); TO_ROW_IT row_it = block->get_rows ();
rowcount = row_it.length (); rowcount = row_it.length ();
@ -1018,61 +1018,6 @@ int *partcount /*no of partitions */
return bestpart; 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 * partition_coords
* *
@ -1414,15 +1359,13 @@ int bestpart /*biggest partition */
bestneg = 0.0; /*no step yet */ bestneg = 0.0; /*no step yet */
for (partition = 0; partition < partcount; partition++) { for (partition = 0; partition < partcount; partition++) {
if (partition != bestpart) { if (partition != bestpart) {
// by jetsoft divide by zero possible
//by jetsoft divide by zero possible if (partsizes[partition] == 0)
if (partsizes[partition]==0) partsteps[partition] = 0;
partsteps[partition]=0;
else else
partsteps[partition] /= partsizes[partition]; partsteps[partition] /= partsizes[partition];
// //
if (partsteps[partition] >= MINASCRISE if (partsteps[partition] >= MINASCRISE
&& partsizes[partition] > poscount) { && partsizes[partition] > poscount) {
poscount = partsizes[partition]; poscount = partsizes[partition];

2
textord/pithsync.h
View File

@ -66,7 +66,7 @@ class FPCUTPT
inT16 pitch, //proposed pitch inT16 pitch, //proposed pitch
inT16 pitch_error); //allowed tolerance inT16 pitch_error); //allowed tolerance
inT32 position() { //access func inT32 position() { // access func
return xpos; return xpos;
} }
double cost_function() { 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_LIST *prev_list); //previous segment
FPSEGPT(FPCUTPT *cutpt); //build from new type FPSEGPT(FPCUTPT *cutpt); //build from new type
inT32 position() { //access func inT32 position() { // access func
return xpos; return xpos;
} }
double cost_function() { double cost_function() {

4
textord/strokewidth.cpp
View File

@ -393,7 +393,7 @@ void StrokeWidth::GradeBlobsIntoPartitions(
} }
static void PrintBoxWidths(BLOBNBOX* neighbour) { 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", 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(), nbox.left(), nbox.bottom(), nbox.right(), nbox.top(),
neighbour->horz_stroke_width(), neighbour->vert_stroke_width(), neighbour->horz_stroke_width(), neighbour->vert_stroke_width(),
@ -1939,7 +1939,7 @@ ScrollView* StrokeWidth::DisplayGoodBlobs(const char* window_name,
gsearch.StartFullSearch(); gsearch.StartFullSearch();
BLOBNBOX* bbox; BLOBNBOX* bbox;
while ((bbox = gsearch.NextFullSearch()) != NULL) { while ((bbox = gsearch.NextFullSearch()) != NULL) {
TBOX box = bbox->bounding_box(); const TBOX& box = bbox->bounding_box();
int left_x = box.left(); int left_x = box.left();
int right_x = box.right(); int right_x = box.right();
int top_y = box.top(); 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, bbox->flow() == BTFT_TEXT_ON_IMAGE, 0.0,
*gutter_width, box.top(), box.bottom()); *gutter_width, box.top(), box.bottom());
if (gutter_bbox != NULL) { 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_width = left ? tab_x - gutter_box.right()
: gutter_box.left() - tab_x; : 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) int neighbour_edge = left ? RightEdgeForBox(box, true, false)
: LeftEdgeForBox(box, true, false); : LeftEdgeForBox(box, true, false);
if (neighbour != NULL) { if (neighbour != NULL) {
TBOX n_box = neighbour->bounding_box(); const TBOX& n_box = neighbour->bounding_box();
if (debug) { if (debug) {
tprintf("Found neighbour:"); tprintf("Found neighbour:");
n_box.print(); 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 // iterate through the source list
for (src_it.mark_cycle_pt(); !src_it.cycled_list(); src_it.forward()) { for (src_it.mark_cycle_pt(); !src_it.cycled_list(); src_it.forward()) {
ColSegment* src_seg = src_it.data(); 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; bool match_found = false;
// iterate through the destination list to find a matching column block // iterate through the destination list to find a matching column block
for (dest_it.mark_cycle_pt(); !dest_it.cycled_list(); dest_it.forward()) { 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 // create a bool array to hold projection on y-axis
bool* table_region = new bool[page_height]; bool* table_region = new bool[page_height];
while ((part = gsearch.NextFullSearch()) != NULL) { while ((part = gsearch.NextFullSearch()) != NULL) {
TBOX part_box = part->bounding_box(); const TBOX& part_box = part->bounding_box();
// reset the projection array // reset the projection array
for (int i = 0; i < page_height; i++) { for (int i = 0; i < page_height; i++) {
table_region[i] = false; table_region[i] = false;
@ -1974,7 +1974,7 @@ void TableFinder::DisplayColPartitionConnections(
ColPartition* upper_part = part->nearest_neighbor_above(); ColPartition* upper_part = part->nearest_neighbor_above();
if (upper_part) { 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_x = (left_x + right_x) / 2;
int mid_y = (top_y + bottom_y) / 2; int mid_y = (top_y + bottom_y) / 2;
int other_x = (upper_box.left() + upper_box.right()) / 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(); ColPartition* lower_part = part->nearest_neighbor_below();
if (lower_part) { 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_x = (left_x + right_x) / 2;
int mid_y = (top_y + bottom_y) / 2; int mid_y = (top_y + bottom_y) / 2;
int other_x = (lower_box.left() + lower_box.right()) / 2; int other_x = (lower_box.left() + lower_box.right()) / 2;
@ -2098,7 +2098,7 @@ void TableFinder::MakeTableBlocks(ColPartitionGrid* grid,
table_search.StartFullSearch(); table_search.StartFullSearch();
ColSegment* table; ColSegment* table;
while ((table = table_search.NextFullSearch()) != NULL) { 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 // Start a rect search on table_box
GridSearch<ColPartition, ColPartition_CLIST, ColPartition_C_IT> GridSearch<ColPartition, ColPartition_CLIST, ColPartition_C_IT>
rectsearch(grid); rectsearch(grid);

14
textord/tabvector.cpp
View File

@ -435,7 +435,7 @@ bool TabVector::SimilarTo(const ICOORD& vertical,
vsearch.StartVerticalSearch(left, right, top_y); vsearch.StartVerticalSearch(left, right, top_y);
BLOBNBOX* blob; BLOBNBOX* blob;
while ((blob = vsearch.NextVerticalSearch(true)) != NULL) { while ((blob = vsearch.NextVerticalSearch(true)) != NULL) {
TBOX box = blob->bounding_box(); const TBOX& box = blob->bounding_box();
if (box.top() > bottom_y) if (box.top() > bottom_y)
return true; // Nothing found. return true; // Nothing found.
if (box.bottom() < top_y) if (box.bottom() < top_y)
@ -523,11 +523,11 @@ const char* kAlignmentNames[] = {
// Print basic information about this tab vector. // Print basic information about this tab vector.
void TabVector::Print(const char* prefix) { 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", " partners=%d\n",
prefix, kAlignmentNames[alignment_], prefix, kAlignmentNames[alignment_], startpt_.x(), startpt_.y(),
startpt_.x(), startpt_.y(), endpt_.x(), endpt_.y(), endpt_.x(), endpt_.y(), mean_width_, percent_score_, sort_key_,
mean_width_, percent_score_, sort_key_,
boxes_.length(), partners_.length()); 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. // Fit a line to all the boxes in the list.
for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) { for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
BLOBNBOX* bbox = it.data(); BLOBNBOX* bbox = it.data();
TBOX box = bbox->bounding_box(); const TBOX& box = bbox->bounding_box();
int x1 = IsRightTab() ? box.right() : box.left(); int x1 = IsRightTab() ? box.right() : box.left();
ICOORD boxpt(x1, box.bottom()); ICOORD boxpt(x1, box.bottom());
linepoints.Add(boxpt); linepoints.Add(boxpt);
@ -831,7 +831,7 @@ bool TabVector::Fit(ICOORD vertical, bool force_parallel) {
int width_count = 0; int width_count = 0;
for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) { for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
BLOBNBOX* bbox = it.data(); BLOBNBOX* bbox = it.data();
TBOX box = bbox->bounding_box(); const TBOX& box = bbox->bounding_box();
mean_width_ += box.width(); mean_width_ += box.width();
++width_count; ++width_count;
int x1 = IsRightTab() ? box.right() : box.left(); 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); pt->y = ClipToRange<int>(pt->y, 0, pixGetHeight(pix_) - 1);
} }
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma optimize( "", on ) #pragma optimize("", on)
#endif // _MSC_VER #endif // _MSC_VER
// Transform tesseract image coordinates to coordinates used in the projection. // Transform tesseract image coordinates to coordinates used in the projection.

118
textord/textord.cpp
View File

@ -33,7 +33,8 @@
namespace tesseract { namespace tesseract {
Textord::Textord(CCStruct* ccstruct) Textord::Textord(CCStruct* ccstruct)
: ccstruct_(ccstruct), use_cjk_fp_model_(false), : ccstruct_(ccstruct),
use_cjk_fp_model_(false),
// makerow.cpp /////////////////////////////////////////// // makerow.cpp ///////////////////////////////////////////
BOOL_MEMBER(textord_single_height_mode, false, BOOL_MEMBER(textord_single_height_mode, false,
"Script has no xheight, so use a single mode", "Script has no xheight, so use a single mode",
@ -46,24 +47,20 @@ Textord::Textord(CCStruct* ccstruct)
"old_to_method.", "old_to_method.",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_only_use_prop_rows, true, BOOL_MEMBER(tosp_only_use_prop_rows, true,
"Block stats to use fixed pitch rows?", "Block stats to use fixed pitch rows?", ccstruct_->params()),
ccstruct_->params()),
BOOL_MEMBER(tosp_force_wordbreak_on_punct, false, BOOL_MEMBER(tosp_force_wordbreak_on_punct, false,
"Force word breaks on punct to break long lines in non-space " "Force word breaks on punct to break long lines in non-space "
"delimited langs", "delimited langs",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_use_pre_chopping, false, BOOL_MEMBER(tosp_use_pre_chopping, false, "Space stats use prechopping?",
"Space stats use prechopping?",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_old_to_bug_fix, false, "Fix suspected bug in old code", BOOL_MEMBER(tosp_old_to_bug_fix, false, "Fix suspected bug in old code",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_block_use_cert_spaces, true, BOOL_MEMBER(tosp_block_use_cert_spaces, true, "Only stat OBVIOUS spaces",
"Only stat OBVIOUS spaces",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_row_use_cert_spaces, true, "Only stat OBVIOUS spaces", BOOL_MEMBER(tosp_row_use_cert_spaces, true, "Only stat OBVIOUS spaces",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_narrow_blobs_not_cert, true, BOOL_MEMBER(tosp_narrow_blobs_not_cert, true, "Only stat OBVIOUS spaces",
"Only stat OBVIOUS spaces",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_row_use_cert_spaces1, true, "Only stat OBVIOUS spaces", BOOL_MEMBER(tosp_row_use_cert_spaces1, true, "Only stat OBVIOUS spaces",
ccstruct_->params()), ccstruct_->params()),
@ -78,30 +75,24 @@ Textord::Textord(CCStruct* ccstruct)
"Don't restrict kn->sp fuzzy limit to tables", "Don't restrict kn->sp fuzzy limit to tables",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_stats_use_xht_gaps, true, BOOL_MEMBER(tosp_stats_use_xht_gaps, true,
"Use within xht gap for wd breaks", "Use within xht gap for wd breaks", ccstruct_->params()),
ccstruct_->params()),
BOOL_MEMBER(tosp_use_xht_gaps, true, "Use within xht gap for wd breaks", BOOL_MEMBER(tosp_use_xht_gaps, true, "Use within xht gap for wd breaks",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_only_use_xht_gaps, false, BOOL_MEMBER(tosp_only_use_xht_gaps, false,
"Only use within xht gap for wd breaks", "Only use within xht gap for wd breaks", ccstruct_->params()),
ccstruct_->params()),
BOOL_MEMBER(tosp_rule_9_test_punct, false, BOOL_MEMBER(tosp_rule_9_test_punct, false,
"Don't chng kn to space next to punct", "Don't chng kn to space next to punct", ccstruct_->params()),
ccstruct_->params()),
BOOL_MEMBER(tosp_flip_fuzz_kn_to_sp, true, "Default flip", BOOL_MEMBER(tosp_flip_fuzz_kn_to_sp, true, "Default flip",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_flip_fuzz_sp_to_kn, true, "Default flip", BOOL_MEMBER(tosp_flip_fuzz_sp_to_kn, true, "Default flip",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(tosp_improve_thresh, false, "Enable improvement heuristic", BOOL_MEMBER(tosp_improve_thresh, false, "Enable improvement heuristic",
ccstruct_->params()), ccstruct_->params()),
INT_MEMBER(tosp_debug_level, 0, "Debug data", INT_MEMBER(tosp_debug_level, 0, "Debug data", ccstruct_->params()),
ccstruct_->params()),
INT_MEMBER(tosp_enough_space_samples_for_median, 3, INT_MEMBER(tosp_enough_space_samples_for_median, 3,
"or should we use mean", "or should we use mean", ccstruct_->params()),
ccstruct_->params()),
INT_MEMBER(tosp_redo_kern_limit, 10, INT_MEMBER(tosp_redo_kern_limit, 10,
"No.samples reqd to reestimate for row", "No.samples reqd to reestimate for row", ccstruct_->params()),
ccstruct_->params()),
INT_MEMBER(tosp_few_samples, 40, INT_MEMBER(tosp_few_samples, 40,
"No.gaps reqd with 1 large gap to treat as a table", "No.gaps reqd with 1 large gap to treat as a table",
ccstruct_->params()), ccstruct_->params()),
@ -114,30 +105,24 @@ Textord::Textord(CCStruct* ccstruct)
"Factor for defining space threshold in terms of space and " "Factor for defining space threshold in terms of space and "
"kern sizes", "kern sizes",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_threshold_bias1, 0, double_MEMBER(tosp_threshold_bias1, 0, "how far between kern and space?",
"how far between kern and space?",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_threshold_bias2, 0, double_MEMBER(tosp_threshold_bias2, 0, "how far between kern and space?",
"how far between kern and space?",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_narrow_fraction, 0.3, "Fract of xheight for narrow", double_MEMBER(tosp_narrow_fraction, 0.3, "Fract of xheight for narrow",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_narrow_aspect_ratio, 0.48, double_MEMBER(tosp_narrow_aspect_ratio, 0.48,
"narrow if w/h less than this", "narrow if w/h less than this", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_wide_fraction, 0.52, "Fract of xheight for wide", double_MEMBER(tosp_wide_fraction, 0.52, "Fract of xheight for wide",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_wide_aspect_ratio, 0.0, "wide if w/h less than this", double_MEMBER(tosp_wide_aspect_ratio, 0.0, "wide if w/h less than this",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_fuzzy_space_factor, 0.6, double_MEMBER(tosp_fuzzy_space_factor, 0.6,
"Fract of xheight for fuzz sp", "Fract of xheight for fuzz sp", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_fuzzy_space_factor1, 0.5, double_MEMBER(tosp_fuzzy_space_factor1, 0.5,
"Fract of xheight for fuzz sp", "Fract of xheight for fuzz sp", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_fuzzy_space_factor2, 0.72, double_MEMBER(tosp_fuzzy_space_factor2, 0.72,
"Fract of xheight for fuzz sp", "Fract of xheight for fuzz sp", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_gap_factor, 0.83, "gap ratio to flip sp->kern", double_MEMBER(tosp_gap_factor, 0.83, "gap ratio to flip sp->kern",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_kern_gap_factor1, 2.0, "gap ratio to flip kern->sp", 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", "Fract of kerns reqd for isolated row stats",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_table_kn_sp_ratio, 2.25, double_MEMBER(tosp_table_kn_sp_ratio, 2.25,
"Min difference of kn & sp in table", "Min difference of kn & sp in table", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_table_xht_sp_ratio, 0.33, double_MEMBER(tosp_table_xht_sp_ratio, 0.33,
"Expect spaces bigger than this", "Expect spaces bigger than this", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_table_fuzzy_kn_sp_ratio, 3.0, double_MEMBER(tosp_table_fuzzy_kn_sp_ratio, 3.0,
"Fuzzy if less than this", "Fuzzy if less than this", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_fuzzy_kn_fraction, 0.5, "New fuzzy kn alg", double_MEMBER(tosp_fuzzy_kn_fraction, 0.5, "New fuzzy kn alg",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_fuzzy_sp_fraction, 0.5, "New fuzzy sp alg", 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", "Don't trust spaces less than this time kn",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_init_guess_kn_mult, 2.2, double_MEMBER(tosp_init_guess_kn_mult, 2.2,
"Thresh guess - mult kn by this", "Thresh guess - mult kn by this", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_init_guess_xht_mult, 0.28, double_MEMBER(tosp_init_guess_xht_mult, 0.28,
"Thresh guess - mult xht by this", "Thresh guess - mult xht by this", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_max_sane_kn_thresh, 5.0, double_MEMBER(tosp_max_sane_kn_thresh, 5.0,
"Multiplier on kn to limit thresh", "Multiplier on kn to limit thresh", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_flip_caution, 0.0, double_MEMBER(tosp_flip_caution, 0.0,
"Don't autoflip kn to sp when large separation", "Don't autoflip kn to sp when large separation",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_large_kerning, 0.19, double_MEMBER(tosp_large_kerning, 0.19,
"Limit use of xht gap with large kns", "Limit use of xht gap with large kns", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_dont_fool_with_small_kerns, -1, double_MEMBER(tosp_dont_fool_with_small_kerns, -1,
"Limit use of xht gap with odd small kns", "Limit use of xht gap with odd small kns",
ccstruct_->params()), ccstruct_->params()),
@ -193,11 +171,9 @@ Textord::Textord(CCStruct* ccstruct)
"Don't reduce box if the top left is non blank", "Don't reduce box if the top left is non blank",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(tosp_silly_kn_sp_gap, 0.2, double_MEMBER(tosp_silly_kn_sp_gap, 0.2,
"Don't let sp minus kn get too small", "Don't let sp minus kn get too small", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(tosp_pass_wide_fuzz_sp_to_context, 0.75, double_MEMBER(tosp_pass_wide_fuzz_sp_to_context, 0.75,
"How wide fuzzies need context", "How wide fuzzies need context", ccstruct_->params()),
ccstruct_->params()),
// tordmain.cpp /////////////////////////////////////////// // tordmain.cpp ///////////////////////////////////////////
BOOL_MEMBER(textord_no_rejects, false, "Don't remove noise blobs", BOOL_MEMBER(textord_no_rejects, false, "Don't remove noise blobs",
ccstruct_->params()), ccstruct_->params()),
@ -212,28 +188,21 @@ Textord::Textord(CCStruct* ccstruct)
double_MEMBER(textord_blob_size_bigile, 95, "Percentile for large blobs", double_MEMBER(textord_blob_size_bigile, 95, "Percentile for large blobs",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(textord_noise_area_ratio, 0.7, double_MEMBER(textord_noise_area_ratio, 0.7,
"Fraction of bounding box for noise", "Fraction of bounding box for noise", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(textord_blob_size_smallile, 20, double_MEMBER(textord_blob_size_smallile, 20,
"Percentile for small blobs", "Percentile for small blobs", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(textord_initialx_ile, 0.75, double_MEMBER(textord_initialx_ile, 0.75,
"Ile of sizes for xheight guess", "Ile of sizes for xheight guess", ccstruct_->params()),
ccstruct_->params()),
double_MEMBER(textord_initialasc_ile, 0.90, double_MEMBER(textord_initialasc_ile, 0.90,
"Ile of sizes for xheight guess", "Ile of sizes for xheight guess", ccstruct_->params()),
ccstruct_->params()), INT_MEMBER(textord_noise_sizefraction, 10, "Fraction of size for maxima",
INT_MEMBER(textord_noise_sizefraction, 10,
"Fraction of size for maxima",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(textord_noise_sizelimit, 0.5, double_MEMBER(textord_noise_sizelimit, 0.5,
"Fraction of x for big t count", "Fraction of x for big t count", ccstruct_->params()),
ccstruct_->params()),
INT_MEMBER(textord_noise_translimit, 16, "Transitions for normal blob", INT_MEMBER(textord_noise_translimit, 16, "Transitions for normal blob",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(textord_noise_normratio, 2.0, double_MEMBER(textord_noise_normratio, 2.0,
"Dot to norm ratio for deletion", "Dot to norm ratio for deletion", ccstruct_->params()),
ccstruct_->params()),
BOOL_MEMBER(textord_noise_rejwords, true, "Reject noise-like words", BOOL_MEMBER(textord_noise_rejwords, true, "Reject noise-like words",
ccstruct_->params()), ccstruct_->params()),
BOOL_MEMBER(textord_noise_rejrows, true, "Reject noise-like rows", 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", "xh fract height error for norm blobs",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(textord_noise_sxfract, 0.4, double_MEMBER(textord_noise_sxfract, 0.4,
"xh fract width error for norm blobs", "xh fract width error for norm blobs", ccstruct_->params()),
ccstruct_->params()), double_MEMBER(textord_noise_hfract, 1.0 / 64,
double_MEMBER(textord_noise_hfract, 1.0/64,
"Height fraction to discard outlines as speckle noise", "Height fraction to discard outlines as speckle noise",
ccstruct_->params()), ccstruct_->params()),
INT_MEMBER(textord_noise_sncount, 1, "super norm blobs to save row", INT_MEMBER(textord_noise_sncount, 1, "super norm blobs to save row",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(textord_noise_rowratio, 6.0, double_MEMBER(textord_noise_rowratio, 6.0,
"Dot to norm ratio for deletion", "Dot to norm ratio for deletion", ccstruct_->params()),
ccstruct_->params()),
BOOL_MEMBER(textord_noise_debug, false, "Debug row garbage detector", BOOL_MEMBER(textord_noise_debug, false, "Debug row garbage detector",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(textord_blshift_maxshift, 0.00, "Max baseline shift", double_MEMBER(textord_blshift_maxshift, 0.00, "Max baseline shift",
ccstruct_->params()), ccstruct_->params()),
double_MEMBER(textord_blshift_xfraction, 9.99, double_MEMBER(textord_blshift_xfraction, 9.99,
"Min size of baseline shift", "Min size of baseline shift", ccstruct_->params()) {}
ccstruct_->params()) {
}
Textord::~Textord() { Textord::~Textord() {
} }
@ -324,10 +289,9 @@ void Textord::TextordPage(PageSegMode pageseg_mode, const FCOORD& reskew,
BaselineDetect baseline_detector(textord_baseline_debug, BaselineDetect baseline_detector(textord_baseline_debug,
reskew, to_blocks); reskew, to_blocks);
baseline_detector.ComputeStraightBaselines(use_box_bottoms); baseline_detector.ComputeStraightBaselines(use_box_bottoms);
baseline_detector.ComputeBaselineSplinesAndXheights(page_tr_, true, baseline_detector.ComputeBaselineSplinesAndXheights(
textord_heavy_nr, page_tr_, pageseg_mode != PSM_RAW_LINE, textord_heavy_nr,
textord_show_final_rows, textord_show_final_rows, this);
this);
// Now make the words in the lines. // Now make the words in the lines.
if (PSM_WORD_FIND_ENABLED(pageseg_mode)) { if (PSM_WORD_FIND_ENABLED(pageseg_mode)) {
// SINGLE_LINE uses the old word maker on the single line. // 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; return FALSE;
prev_valid = FALSE; prev_valid = FALSE;
prev_centre = 0; prev_centre = 0;
prev_right = 0; //stop compiler warning prev_right = 0; // stop compiler warning
joined_box = blob_it.data ()->bounding_box (); joined_box = blob_it.data ()->bounding_box ();
do { do {
blob_it.forward (); 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. // Non-text blocks must contain at least one row.
ROW_IT row_it(block->row_list()); ROW_IT row_it(block->row_list());
if (row_it.empty()) { if (row_it.empty()) {
TBOX box = block->bounding_box(); const TBOX& box = block->bounding_box();
float height = box.height(); float height = box.height();
inT32 xstarts[2] = {box.left(), box.right()}; inT32 xstarts[2] = {box.left(), box.right()};
double coeffs[3] = {0.0, 0.0, static_cast<double>(box.bottom())}; 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 && if (suspected_table &&
(row->space_size < tosp_table_kn_sp_ratio * row->kern_size)) { (row->space_size < tosp_table_kn_sp_ratio * row->kern_size)) {
if (tosp_debug_level > 5) if (tosp_debug_level > 5)
tprintf ("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f.\n", tprintf("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f.\n", block_idx,
block_idx, row_idx, row_idx, row->kern_size, row->space_threshold, row->space_size);
row->kern_size, row->space_threshold, row->space_size);
row->space_threshold = row->space_threshold =
(inT32) (tosp_table_kn_sp_ratio * row->kern_size); (inT32) (tosp_table_kn_sp_ratio * row->kern_size);
row->space_size = MAX (row->space_threshold + 1, row->xheight); 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), MAX (tosp_min_sane_kn_sp * MAX (row->kern_size, 2.5),
row->xheight / 2); row->xheight / 2);
if (tosp_debug_level > 5) if (tosp_debug_level > 5)
tprintf tprintf("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f -> %3.2f.\n",
("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, block_idx, row_idx, row->kern_size, row->space_threshold,
row->space_size, sane_space); row->space_size, sane_space);
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))); MAX (row->kern_size, 2.5)));
if (row->space_threshold > sane_threshold) { if (row->space_threshold > sane_threshold) {
if (tosp_debug_level > 5) if (tosp_debug_level > 5)
tprintf ("B:%d R:%d -- DON'T BELIEVE THRESH %3.2f %d %3.2f->%d.\n", tprintf("B:%d R:%d -- DON'T BELIEVE THRESH %3.2f %d %3.2f->%d.\n",
block_idx, row_idx, block_idx, row_idx, row->kern_size, row->space_threshold,
row->kern_size, row->space_size, sane_threshold);
row->space_threshold, row->space_size, sane_threshold);
row->space_threshold = sane_threshold; row->space_threshold = sane_threshold;
if (row->space_size <= sane_threshold) if (row->space_size <= sane_threshold)
row->space_size = row->space_threshold + 1.0f; 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)), MIN (inT32 (ceil (tosp_fuzzy_space_factor * row->xheight)),
inT32 (row->space_size)); inT32 (row->space_size));
if (row->min_space <= row->space_threshold) if (row->min_space <= row->space_threshold)
//Don't be silly // Don't be silly
row->min_space = row->space_threshold + 1; row->min_space = row->space_threshold + 1;
/* /*
Lets try to guess the max certain kern gap by looking at the cluster of 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)); row->kern_size));
} }
if (row->max_nonspace > row->space_threshold) { if (row->max_nonspace > row->space_threshold) {
//Don't be silly // Don't be silly
row->max_nonspace = row->space_threshold; 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) || ((small_gaps_count / (float) total) < tosp_enough_small_gaps) ||
(total - small_gaps_count < 1)) { (total - small_gaps_count < 1)) {
if (tosp_debug_level > 5) if (tosp_debug_level > 5)
tprintf ("B:%d R:%d -- Can't do isolated row stats.\n", tprintf("B:%d R:%d -- Can't do isolated row stats.\n", block_idx,
block_idx, row_idx); row_idx);
return FALSE; return FALSE;
} }
blob_it.set_to_list (row->blob_list ()); blob_it.set_to_list (row->blob_list ());
@ -1130,9 +1127,9 @@ ROW *Textord::make_prop_words(
else else
blanks = 0; blanks = 0;
if (tosp_debug_level > 5) if (tosp_debug_level > 5)
tprintf tprintf(
("Repch wd at EOL (%d,%d). rep spacing %5.2f; Lgap:%d (%d blanks)\n", "Repch wd at EOL (%d,%d). rep spacing %5.2f; Lgap:%d (%d blanks)\n",
word->bounding_box ().left (), word->bounding_box ().bottom (), word->bounding_box().left(), word->bounding_box().bottom(),
repetition_spacing, current_gap, blanks); repetition_spacing, current_gap, blanks);
word->set_blanks (blanks); word->set_blanks (blanks);
//NO uncertainty //NO uncertainty
@ -1686,10 +1683,9 @@ void Textord::mark_gap(
blob.bottom () + blob.height () / 2.0f); blob.bottom () + blob.height () / 2.0f);
} }
if (tosp_debug_level > 5) if (tosp_debug_level > 5)
tprintf (" (%d,%d) Sp<->Kn Rule %d %d %d %d %d %d\n", tprintf(" (%d,%d) Sp<->Kn Rule %d %d %d %d %d %d\n",
blob.left () - current_gap / 2, blob.bottom (), rule, blob.left() - current_gap / 2, blob.bottom(), rule, prev_gap,
prev_gap, prev_blob_width, current_gap, prev_blob_width, current_gap, next_blob_width, next_gap);
next_blob_width, next_gap);
} }
#endif #endif
@ -1727,8 +1723,7 @@ BOOL8 Textord::ignore_big_gap(TO_ROW *row,
inT16 right) { inT16 right) {
inT16 gap = right - left + 1; inT16 gap = right - left + 1;
if (tosp_ignore_big_gaps > 999) if (tosp_ignore_big_gaps > 999) return FALSE; // Don't ignore
return FALSE; //Don't ignore
if (tosp_ignore_big_gaps > 0) if (tosp_ignore_big_gaps > 0)
return (gap > tosp_ignore_big_gaps * row->xheight); return (gap > tosp_ignore_big_gaps * row->xheight);
if (gap > tosp_ignore_very_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; return FALSE;
} }
/********************************************************************** /**********************************************************************
* reduced_box_next * 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_min_minspace, 0.3, "Fraction of xheight");
EXTERN double_VAR (textord_words_default_nonspace, 0.2, EXTERN double_VAR (textord_words_default_nonspace, 0.2,
"Fraction of xheight"); "Fraction of xheight");
EXTERN double_VAR (textord_words_initial_lower, 0.25, EXTERN double_VAR(textord_words_initial_lower, 0.25,
"Max initial cluster size"); "Max initial cluster size");
EXTERN double_VAR (textord_words_initial_upper, 0.15, EXTERN double_VAR (textord_words_initial_upper, 0.15,
"Min initial cluster spacing"); "Min initial cluster spacing");
EXTERN double_VAR (textord_words_minlarge, 0.75, 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"); "Fraction of xheight for sameness");
EXTERN BOOL_VAR (textord_pitch_scalebigwords, FALSE, EXTERN BOOL_VAR (textord_pitch_scalebigwords, FALSE,
"Scale scores on big words"); "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_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_prop_nonspace, 0.25, "Fraction of xheight");
EXTERN double_VAR (words_default_fixed_space, 0.75, "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