tesseract/ccstruct/pageres.h
theraysmith c4f4840fbe Fixed name collision with jpeg library
git-svn-id: https://tesseract-ocr.googlecode.com/svn/trunk@163 d0cd1f9f-072b-0410-8dd7-cf729c803f20
2008-04-22 00:41:37 +00:00

312 lines
9.6 KiB
C++

/**********************************************************************
* File: pageres.h (Formerly page_res.h)
* Description: Results classes used by control.c
* Author: Phil Cheatle
* Created: Tue Sep 22 08:42:49 BST 1992
*
* (C) Copyright 1992, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef PAGERES_H
#define PAGERES_H
#include "elst.h"
#include "ocrblock.h"
#include "ocrrow.h"
#include "werd.h"
#include "ratngs.h"
#include "rejctmap.h"
#include "notdll.h"
#include "notdll.h"
/* Forward declarations */
class BLOCK_RES;
ELISTIZEH (BLOCK_RES) CLISTIZEH (BLOCK_RES)
class
ROW_RES;
ELISTIZEH (ROW_RES)
class WERD_RES;
ELISTIZEH (WERD_RES)
/*************************************************************************
* PAGE_RES - Page results
*************************************************************************/
class PAGE_RES //page result
{
public:
inT32 char_count;
inT32 rej_count;
BLOCK_RES_LIST block_res_list;
BOOL8 rejected;
PAGE_RES() {
} //empty constructor
PAGE_RES( //simple constructor
BLOCK_LIST *block_list); //real blocks
~PAGE_RES () { //destructor
}
};
/*************************************************************************
* BLOCK_RES - Block results
*************************************************************************/
class BLOCK_RES:public ELIST_LINK
//page block result
{
public:
BLOCK * block; //real block
inT32 char_count; //chars in block
inT32 rej_count; //rejected chars
inT16 font_class; //
inT16 row_count;
float x_height;
BOOL8 font_assigned; // block already
// processed
BOOL8 bold; // all bold
BOOL8 italic; // all italic
ROW_RES_LIST row_res_list;
BLOCK_RES() {
} //empty constructor
BLOCK_RES( //simple constructor
BLOCK *the_block); //real block
~BLOCK_RES () { //destructor
}
};
/*************************************************************************
* ROW_RES - Row results
*************************************************************************/
class ROW_RES:public ELIST_LINK //row result
{
public:
ROW * row; //real row
inT32 char_count; //chars in block
inT32 rej_count; //rejected chars
inT32 whole_word_rej_count; //rejs in total rej wds
WERD_RES_LIST word_res_list;
float font_class_score;
inT16 font_class; //
inT32 italic;
inT32 bold;
inT8 font1; //primary font
inT8 font1_count; //no of voters
inT8 font2; //secondary font
inT8 font2_count; //no of voters
ROW_RES() {
} //empty constructor
ROW_RES( //simple constructor
ROW *the_row); //real row
~ROW_RES () { //destructor
}
};
/*************************************************************************
* WERD_RES - Word results
*************************************************************************/
enum CRUNCH_MODE
{
CR_NONE,
CR_KEEP_SPACE,
CR_LOOSE_SPACE,
CR_DELETE
};
class WERD_RES:public ELIST_LINK //word result
{
public:
WERD * word; //non-bln real word
WERD *outword; //bln best choice
//segmentation
DENORM denorm; //for use on outword
WERD_CHOICE *best_choice; //tess output
WERD_CHOICE *raw_choice; //top choice permuter
WERD_CHOICE *ep_choice; //ep text
REJMAP reject_map; //best_choice rejects
BOOL8 tess_failed;
/*
If tess_failed is TRUE, one of the following tests failed when Tess
returned:
- The outword blob list was not the same length as the best_choice string;
- The best_choice string contained ALL blanks;
- The best_choice string was zero length
*/
BOOL8 tess_accepted; //Tess thinks its ok?
BOOL8 tess_would_adapt; //Tess would adapt?
BOOL8 done; //ready for output?
inT8 italic;
inT8 bold;
inT8 font1; //primary font
inT8 font1_count; //no of voters
inT8 font2; //secondary font
inT8 font2_count; //no of voters
CRUNCH_MODE unlv_crunch_mode;
float x_height; //Post match estimate
float caps_height; //Post match estimate
BOOL8 guessed_x_ht;
BOOL8 guessed_caps_ht;
/*
To deal with fuzzy spaces we need to be able to combine "words" to form
combinations when we suspect that the gap is a non-space. The (new) text
ord code generates separate words for EVERY fuzzy gap - flags in the word
indicate whether the gap is below the threshold (fuzzy kern) and is thus
NOT a real word break by default, or above the threshold (fuzzy space) and
this is a real word break by default.
The WERD_RES list contains all these words PLUS "combination" words built
out of (copies of) the words split by fuzzy kerns. The separate parts have
their "part_of_combo" flag set true and should be IGNORED on a default
reading of the list.
Combination words are FOLLOWED by the sequence of part_of_combo words
which they combine.
*/
BOOL8 combination; //of two fuzzy gap wds
BOOL8 part_of_combo; //part of a combo
BOOL8 reject_spaces; //Reject spacing?
WERD_RES() {
} //empty constructor
WERD_RES( //simple constructor
WERD *the_word) { //real word
word = the_word;
outword = NULL;
best_choice = NULL;
raw_choice = NULL;
ep_choice = NULL;
tess_failed = FALSE;
tess_accepted = FALSE;
tess_would_adapt = FALSE;
done = FALSE;
unlv_crunch_mode = CR_NONE;
italic = FALSE;
bold = FALSE;
font1 = -1;
font1_count = 0;
font2 = -1;
font2_count = 0;
x_height = 0.0;
caps_height = 0.0;
guessed_x_ht = TRUE;
guessed_caps_ht = TRUE;
combination = FALSE;
part_of_combo = FALSE;
reject_spaces = FALSE;
}
WERD_RES( //constr from WERD_RES
const WERD_RES &source) {
*this = source; //see operator=
}
~WERD_RES (); //destructor
WERD_RES & operator= ( //assign word res
const WERD_RES & source); //from this
void copy_on( //copy blobs onto word
WERD_RES *word_res) { //from this word
word->set_flag (W_EOL, word_res->word->flag (W_EOL));
word->copy_on (word_res->word);
}
};
/*************************************************************************
* PAGE_RES_IT - Page results iterator
*************************************************************************/
class PAGE_RES_IT
{
public:
PAGE_RES * page_res; //page being iterated
PAGE_RES_IT() {
} //empty contructor
PAGE_RES_IT( //empty contructor
PAGE_RES *the_page_res) { //page result
page_res = the_page_res;
restart_page(); //ready to scan
}
WERD_RES *restart_page(); //get ready
WERD_RES *internal_forward( //get next word
BOOL8 new_block);
WERD_RES *forward() { //get next word
return internal_forward (FALSE);
}
WERD_RES *forward_block(); //get first word in
//next non-empty block
WERD_RES *prev_word() { //previous word
return prev_word_res;
}
ROW_RES *prev_row() { //row of prev word
return prev_row_res;
}
BLOCK_RES *prev_block() { //block of prev word
return prev_block_res;
}
WERD_RES *word() { //current word
return word_res;
}
ROW_RES *row() { //row of current word
return row_res;
}
BLOCK_RES *block() { //block of cur. word
return block_res;
}
WERD_RES *next_word() { //next word
return next_word_res;
}
ROW_RES *next_row() { //row of next word
return next_row_res;
}
BLOCK_RES *next_block() { //block of next word
return next_block_res;
}
void rej_stat_word(); //for page/block/row
private:
WERD_RES * prev_word_res; //previous word
ROW_RES *prev_row_res; //row of prev word
BLOCK_RES *prev_block_res; //block of prev word
WERD_RES *word_res; //current word
ROW_RES *row_res; //row of current word
BLOCK_RES *block_res; //block of cur. word
WERD_RES *next_word_res; //next word
ROW_RES *next_row_res; //row of next word
BLOCK_RES *next_block_res; //block of next word
BLOCK_RES_IT block_res_it; //iterators
ROW_RES_IT row_res_it;
WERD_RES_IT word_res_it;
};
#endif