Tesseract  3.02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
tesseract::ConComp Class Reference

#include <con_comp.h>

List of all members.

Public Member Functions

 ConComp ()
virtual ~ConComp ()
ConCompPtHead ()
int Left () const
int Top () const
int Right () const
int Bottom () const
int Width () const
int Height () const
bool LeftMost () const
bool RightMost () const
void SetLeftMost (bool left_most)
void SetRightMost (bool right_most)
int ID () const
void SetID (int id)
int PtCnt () const
bool Add (int x, int y)
bool Merge (ConComp *con_comp)
void Shift (int dx, int dy)
ConComp ** Segment (int max_hist_wnd, int *concomp_cnt)
int * CreateHistogram (int max_hist_wnd)
int * SegmentHistogram (int *hist_array, int *seg_pt_cnt)

Static Public Member Functions

static int Left2RightComparer (const void *comp1, const void *comp2)
static int Right2LeftComparer (const void *comp1, const void *comp2)

Detailed Description

Definition at line 59 of file con_comp.h.


Constructor & Destructor Documentation

tesseract::ConComp::ConComp ( )

Definition at line 27 of file con_comp.cpp.

{
head_ = NULL;
tail_ = NULL;
left_ = 0;
top_ = 0;
right_ = 0;
bottom_ = 0;
left_most_ = false;
right_most_ = false;
id_ = -1;
pt_cnt_ = 0;
}
tesseract::ConComp::~ConComp ( )
virtual

Definition at line 40 of file con_comp.cpp.

{
if (head_ != NULL) {
ConCompPt *pt_ptr = head_;
while (pt_ptr != NULL) {
ConCompPt *pptNext = pt_ptr->Next();
delete pt_ptr;
pt_ptr = pptNext;
}
head_ = NULL;
}
}

Member Function Documentation

bool tesseract::ConComp::Add ( int  x,
int  y 
)

Definition at line 53 of file con_comp.cpp.

{
ConCompPt *pt_ptr = new ConCompPt(x, y);
if (pt_ptr == NULL) {
return false;
}
if (head_ == NULL) {
left_ = x;
right_ = x;
top_ = y;
bottom_ = y;
head_ = pt_ptr;
} else {
left_ = left_ <= x ? left_ : x;
top_ = top_ <= y ? top_ : y;
right_ = right_ >= x ? right_ : x;
bottom_ = bottom_ >= y ? bottom_ : y;
}
if (tail_ != NULL) {
tail_->SetNext(pt_ptr);
}
tail_ = pt_ptr;
pt_cnt_++;
return true;
}
int tesseract::ConComp::Bottom ( ) const
inline

Definition at line 68 of file con_comp.h.

{ return bottom_; }
int * tesseract::ConComp::CreateHistogram ( int  max_hist_wnd)

Definition at line 106 of file con_comp.cpp.

{
int wid = right_ - left_ + 1,
hgt = bottom_ - top_ + 1,
hist_wnd = static_cast<int>(hgt * HIST_WND_RATIO);
if (hist_wnd > max_hist_wnd) {
hist_wnd = max_hist_wnd;
}
// alloc memo for histogram
int *hist_array = new int[wid];
if (hist_array == NULL) {
return NULL;
}
memset(hist_array, 0, wid * sizeof(*hist_array));
// compute windowed histogram
ConCompPt *pt_ptr = head_;
while (pt_ptr != NULL) {
int x = pt_ptr->x() - left_,
xw = x - hist_wnd;
for (int xdel = -hist_wnd; xdel <= hist_wnd; xdel++, xw++) {
if (xw >= 0 && xw < wid) {
hist_array[xw]++;
}
}
pt_ptr = pt_ptr->Next();
}
return hist_array;
}
ConCompPt* tesseract::ConComp::Head ( )
inline

Definition at line 64 of file con_comp.h.

{ return head_; }
int tesseract::ConComp::Height ( ) const
inline

Definition at line 70 of file con_comp.h.

{ return bottom_ - top_ + 1; }
int tesseract::ConComp::ID ( ) const
inline

Definition at line 94 of file con_comp.h.

{ return id_; }
int tesseract::ConComp::Left ( ) const
inline

Definition at line 65 of file con_comp.h.

{ return left_; }
static int tesseract::ConComp::Left2RightComparer ( const void *  comp1,
const void *  comp2 
)
inlinestatic

Definition at line 73 of file con_comp.h.

{
return (*(reinterpret_cast<ConComp * const *>(comp1)))->left_ +
(*(reinterpret_cast<ConComp * const *>(comp1)))->right_ -
(*(reinterpret_cast<ConComp * const *>(comp2)))->left_ -
(*(reinterpret_cast<ConComp * const *>(comp2)))->right_;
}
bool tesseract::ConComp::LeftMost ( ) const
inline

Definition at line 89 of file con_comp.h.

{ return left_most_; }
bool tesseract::ConComp::Merge ( ConComp con_comp)

Definition at line 83 of file con_comp.cpp.

{
if (head_ == NULL || tail_ == NULL ||
concomp->head_ == NULL || concomp->tail_ == NULL) {
return false;
}
tail_->SetNext(concomp->head_);
tail_ = concomp->tail_;
left_ = left_ <= concomp->left_ ? left_ : concomp->left_;
top_ = top_ <= concomp->top_ ? top_ : concomp->top_;
right_ = right_ >= concomp->right_ ? right_ : concomp->right_;
bottom_ = bottom_ >= concomp->bottom_ ? bottom_ : concomp->bottom_;
pt_cnt_ += concomp->pt_cnt_;
concomp->head_ = NULL;
concomp->tail_ = NULL;
return true;
}
int tesseract::ConComp::PtCnt ( ) const
inline

Definition at line 96 of file con_comp.h.

{ return pt_cnt_; }
int tesseract::ConComp::Right ( ) const
inline

Definition at line 67 of file con_comp.h.

{ return right_; }
static int tesseract::ConComp::Right2LeftComparer ( const void *  comp1,
const void *  comp2 
)
inlinestatic

Definition at line 82 of file con_comp.h.

{
return (*(reinterpret_cast<ConComp * const *>(comp2)))->right_ -
(*(reinterpret_cast<ConComp * const *>(comp1)))->right_;
}
bool tesseract::ConComp::RightMost ( ) const
inline

Definition at line 90 of file con_comp.h.

{ return right_most_; }
ConComp ** tesseract::ConComp::Segment ( int  max_hist_wnd,
int *  concomp_cnt 
)

Definition at line 189 of file con_comp.cpp.

{
// init
(*concomp_cnt) = 0;
// No pts
if (head_ == NULL) {
return NULL;
}
int seg_pt_cnt = 0;
// create the histogram
int *hist_array = CreateHistogram(max_hist_wnd);
if (hist_array == NULL) {
return NULL;
}
int *x_seg_pt = SegmentHistogram(hist_array, &seg_pt_cnt);
// free histogram
delete []hist_array;
// no segments, nothing to do
if (seg_pt_cnt == 0) {
return NULL;
}
// create concomp array
ConComp **concomp_array = new ConComp *[seg_pt_cnt + 1];
if (concomp_array == NULL) {
delete []x_seg_pt;
return NULL;
}
for (int concomp = 0; concomp <= seg_pt_cnt; concomp++) {
concomp_array[concomp] = new ConComp();
if (concomp_array[concomp] == NULL) {
delete []x_seg_pt;
delete []concomp_array;
return NULL;
}
// split concomps inherit the ID this concomp
concomp_array[concomp]->SetID(id_);
}
// set the left and right most attributes of the
// appropriate concomps
concomp_array[0]->left_most_ = true;
concomp_array[seg_pt_cnt]->right_most_ = true;
// assign pts to concomps
ConCompPt *pt_ptr = head_;
while (pt_ptr != NULL) {
int seg_pt;
// find the first seg-pt that exceeds the x value
// of the pt
for (seg_pt = 0; seg_pt < seg_pt_cnt; seg_pt++) {
if ((x_seg_pt[seg_pt] + left_) > pt_ptr->x()) {
break;
}
}
// add the pt to the proper concomp
if (concomp_array[seg_pt]->Add(pt_ptr->x(), pt_ptr->y()) == false) {
delete []x_seg_pt;
delete []concomp_array;
return NULL;
}
pt_ptr = pt_ptr->Next();
}
delete []x_seg_pt;
(*concomp_cnt) = (seg_pt_cnt + 1);
return concomp_array;
}
int * tesseract::ConComp::SegmentHistogram ( int *  hist_array,
int *  seg_pt_cnt 
)

Definition at line 143 of file con_comp.cpp.

{
// init
(*seg_pt_cnt) = 0;
int wid = right_ - left_ + 1,
hgt = bottom_ - top_ + 1;
int *x_seg_pt = new int[wid];
if (x_seg_pt == NULL) {
return NULL;
}
int seg_pt_wnd = static_cast<int>(hgt * SEG_PT_WND_RATIO);
if (seg_pt_wnd > 1) {
seg_pt_wnd = 1;
}
for (int x = 2; x < (wid - 2); x++) {
if (hist_array[x] < hist_array[x - 1] &&
hist_array[x] < hist_array[x - 2] &&
hist_array[x] <= hist_array[x + 1] &&
hist_array[x] <= hist_array[x + 2]) {
x_seg_pt[(*seg_pt_cnt)++] = x;
x += seg_pt_wnd;
} else if (hist_array[x] <= hist_array[x - 1] &&
hist_array[x] <= hist_array[x - 2] &&
hist_array[x] < hist_array[x + 1] &&
hist_array[x] < hist_array[x + 2]) {
x_seg_pt[(*seg_pt_cnt)++] = x;
x += seg_pt_wnd;
}
}
// no segments, nothing to do
if ((*seg_pt_cnt) == 0) {
delete []x_seg_pt;
return NULL;
}
return x_seg_pt;
}
void tesseract::ConComp::SetID ( int  id)
inline

Definition at line 95 of file con_comp.h.

{ id_ = id; }
void tesseract::ConComp::SetLeftMost ( bool  left_most)
inline

Definition at line 91 of file con_comp.h.

{ left_most_ = left_most; }
void tesseract::ConComp::SetRightMost ( bool  right_most)
inline

Definition at line 92 of file con_comp.h.

{ right_most_ = right_most;
}
void tesseract::ConComp::Shift ( int  dx,
int  dy 
)

Definition at line 271 of file con_comp.cpp.

{
ConCompPt *pt_ptr = head_;
while (pt_ptr != NULL) {
pt_ptr->Shift(dx, dy);
pt_ptr = pt_ptr->Next();
}
left_ += dx;
right_ += dx;
top_ += dy;
bottom_ += dy;
}
int tesseract::ConComp::Top ( ) const
inline

Definition at line 66 of file con_comp.h.

{ return top_; }
int tesseract::ConComp::Width ( ) const
inline

Definition at line 69 of file con_comp.h.

{ return right_ - left_ + 1; }

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