Tesseract  3.02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Static Public Member Functions | List of all members
tesseract::ConComp Class Reference

#include <con_comp.h>

Public Member Functions

 ConComp ()
 
virtual ~ConComp ()
 
ConCompPt * Head ()
 
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.

27  {
28  head_ = NULL;
29  tail_ = NULL;
30  left_ = 0;
31  top_ = 0;
32  right_ = 0;
33  bottom_ = 0;
34  left_most_ = false;
35  right_most_ = false;
36  id_ = -1;
37  pt_cnt_ = 0;
38 }
NULL
#define NULL
Definition: host.h:144
tesseract::ConComp::~ConComp ( )
virtual

Definition at line 40 of file con_comp.cpp.

40  {
41  if (head_ != NULL) {
42  ConCompPt *pt_ptr = head_;
43  while (pt_ptr != NULL) {
44  ConCompPt *pptNext = pt_ptr->Next();
45  delete pt_ptr;
46  pt_ptr = pptNext;
47  }
48  head_ = NULL;
49  }
50 }
NULL
#define NULL
Definition: host.h:144
tesseract::ConCompPt::Next
ConCompPt * Next()
Definition: con_comp.h:50

Member Function Documentation

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

Definition at line 53 of file con_comp.cpp.

53  {
54  ConCompPt *pt_ptr = new ConCompPt(x, y);
55  if (pt_ptr == NULL) {
56  return false;
57  }
58 
59  if (head_ == NULL) {
60  left_ = x;
61  right_ = x;
62  top_ = y;
63  bottom_ = y;
64 
65  head_ = pt_ptr;
66  } else {
67  left_ = left_ <= x ? left_ : x;
68  top_ = top_ <= y ? top_ : y;
69  right_ = right_ >= x ? right_ : x;
70  bottom_ = bottom_ >= y ? bottom_ : y;
71  }
72 
73  if (tail_ != NULL) {
74  tail_->SetNext(pt_ptr);
75  }
76 
77  tail_ = pt_ptr;
78  pt_cnt_++;
79  return true;
80 }
tesseract::ConCompPt::SetNext
void SetNext(ConCompPt *pt)
Definition: con_comp.h:51
NULL
#define NULL
Definition: host.h:144
int tesseract::ConComp::Bottom ( ) const
inline

Definition at line 68 of file con_comp.h.

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

Definition at line 106 of file con_comp.cpp.

106  {
107  int wid = right_ - left_ + 1,
108  hgt = bottom_ - top_ + 1,
109  hist_wnd = static_cast<int>(hgt * HIST_WND_RATIO);
110 
111  if (hist_wnd > max_hist_wnd) {
112  hist_wnd = max_hist_wnd;
113  }
114 
115  // alloc memo for histogram
116  int *hist_array = new int[wid];
117  if (hist_array == NULL) {
118  return NULL;
119  }
120 
121  memset(hist_array, 0, wid * sizeof(*hist_array));
122 
123  // compute windowed histogram
124  ConCompPt *pt_ptr = head_;
125 
126  while (pt_ptr != NULL) {
127  int x = pt_ptr->x() - left_,
128  xw = x - hist_wnd;
129 
130  for (int xdel = -hist_wnd; xdel <= hist_wnd; xdel++, xw++) {
131  if (xw >= 0 && xw < wid) {
132  hist_array[xw]++;
133  }
134  }
135 
136  pt_ptr = pt_ptr->Next();
137  }
138 
139  return hist_array;
140 }
NULL
#define NULL
Definition: host.h:144
HIST_WND_RATIO
#define HIST_WND_RATIO
Definition: cube_const.h:32
ConCompPt* tesseract::ConComp::Head ( )
inline

Definition at line 64 of file con_comp.h.

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

Definition at line 70 of file con_comp.h.

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

Definition at line 94 of file con_comp.h.

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

Definition at line 65 of file con_comp.h.

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

Definition at line 73 of file con_comp.h.

74  {
75  return (*(reinterpret_cast<ConComp * const *>(comp1)))->left_ +
76  (*(reinterpret_cast<ConComp * const *>(comp1)))->right_ -
77  (*(reinterpret_cast<ConComp * const *>(comp2)))->left_ -
78  (*(reinterpret_cast<ConComp * const *>(comp2)))->right_;
79  }
bool tesseract::ConComp::LeftMost ( ) const
inline

Definition at line 89 of file con_comp.h.

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

Definition at line 83 of file con_comp.cpp.

83  {
84  if (head_ == NULL || tail_ == NULL ||
85  concomp->head_ == NULL || concomp->tail_ == NULL) {
86  return false;
87  }
88 
89  tail_->SetNext(concomp->head_);
90  tail_ = concomp->tail_;
91  left_ = left_ <= concomp->left_ ? left_ : concomp->left_;
92  top_ = top_ <= concomp->top_ ? top_ : concomp->top_;
93  right_ = right_ >= concomp->right_ ? right_ : concomp->right_;
94  bottom_ = bottom_ >= concomp->bottom_ ? bottom_ : concomp->bottom_;
95  pt_cnt_ += concomp->pt_cnt_;
96 
97  concomp->head_ = NULL;
98  concomp->tail_ = NULL;
99 
100  return true;
101 }
tesseract::ConCompPt::SetNext
void SetNext(ConCompPt *pt)
Definition: con_comp.h:51
NULL
#define NULL
Definition: host.h:144
int tesseract::ConComp::PtCnt ( ) const
inline

Definition at line 96 of file con_comp.h.

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

Definition at line 67 of file con_comp.h.

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

Definition at line 82 of file con_comp.h.

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

Definition at line 90 of file con_comp.h.

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

Definition at line 189 of file con_comp.cpp.

189  {
190  // init
191  (*concomp_cnt) = 0;
192 
193  // No pts
194  if (head_ == NULL) {
195  return NULL;
196  }
197 
198  int seg_pt_cnt = 0;
199 
200  // create the histogram
201  int *hist_array = CreateHistogram(max_hist_wnd);
202  if (hist_array == NULL) {
203  return NULL;
204  }
205 
206  int *x_seg_pt = SegmentHistogram(hist_array, &seg_pt_cnt);
207 
208  // free histogram
209  delete []hist_array;
210 
211  // no segments, nothing to do
212  if (seg_pt_cnt == 0) {
213  return NULL;
214  }
215 
216  // create concomp array
217  ConComp **concomp_array = new ConComp *[seg_pt_cnt + 1];
218  if (concomp_array == NULL) {
219  delete []x_seg_pt;
220  return NULL;
221  }
222 
223  for (int concomp = 0; concomp <= seg_pt_cnt; concomp++) {
224  concomp_array[concomp] = new ConComp();
225  if (concomp_array[concomp] == NULL) {
226  delete []x_seg_pt;
227  delete []concomp_array;
228  return NULL;
229  }
230 
231  // split concomps inherit the ID this concomp
232  concomp_array[concomp]->SetID(id_);
233  }
234 
235  // set the left and right most attributes of the
236  // appropriate concomps
237  concomp_array[0]->left_most_ = true;
238  concomp_array[seg_pt_cnt]->right_most_ = true;
239 
240  // assign pts to concomps
241  ConCompPt *pt_ptr = head_;
242  while (pt_ptr != NULL) {
243  int seg_pt;
244 
245  // find the first seg-pt that exceeds the x value
246  // of the pt
247  for (seg_pt = 0; seg_pt < seg_pt_cnt; seg_pt++) {
248  if ((x_seg_pt[seg_pt] + left_) > pt_ptr->x()) {
249  break;
250  }
251  }
252 
253  // add the pt to the proper concomp
254  if (concomp_array[seg_pt]->Add(pt_ptr->x(), pt_ptr->y()) == false) {
255  delete []x_seg_pt;
256  delete []concomp_array;
257  return NULL;
258  }
259 
260  pt_ptr = pt_ptr->Next();
261  }
262 
263  delete []x_seg_pt;
264 
265  (*concomp_cnt) = (seg_pt_cnt + 1);
266 
267  return concomp_array;
268 }
NULL
#define NULL
Definition: host.h:144
tesseract::ConComp::Add
bool Add(int x, int y)
Definition: con_comp.cpp:53
tesseract::ConComp::CreateHistogram
int * CreateHistogram(int max_hist_wnd)
Definition: con_comp.cpp:106
tesseract::ConComp::SegmentHistogram
int * SegmentHistogram(int *hist_array, int *seg_pt_cnt)
Definition: con_comp.cpp:143
int * tesseract::ConComp::SegmentHistogram ( int *  hist_array,
int *  seg_pt_cnt 
)

Definition at line 143 of file con_comp.cpp.

143  {
144  // init
145  (*seg_pt_cnt) = 0;
146 
147  int wid = right_ - left_ + 1,
148  hgt = bottom_ - top_ + 1;
149 
150  int *x_seg_pt = new int[wid];
151  if (x_seg_pt == NULL) {
152  return NULL;
153  }
154 
155  int seg_pt_wnd = static_cast<int>(hgt * SEG_PT_WND_RATIO);
156 
157  if (seg_pt_wnd > 1) {
158  seg_pt_wnd = 1;
159  }
160 
161  for (int x = 2; x < (wid - 2); x++) {
162  if (hist_array[x] < hist_array[x - 1] &&
163  hist_array[x] < hist_array[x - 2] &&
164  hist_array[x] <= hist_array[x + 1] &&
165  hist_array[x] <= hist_array[x + 2]) {
166  x_seg_pt[(*seg_pt_cnt)++] = x;
167  x += seg_pt_wnd;
168  } else if (hist_array[x] <= hist_array[x - 1] &&
169  hist_array[x] <= hist_array[x - 2] &&
170  hist_array[x] < hist_array[x + 1] &&
171  hist_array[x] < hist_array[x + 2]) {
172  x_seg_pt[(*seg_pt_cnt)++] = x;
173  x += seg_pt_wnd;
174  }
175  }
176 
177  // no segments, nothing to do
178  if ((*seg_pt_cnt) == 0) {
179  delete []x_seg_pt;
180  return NULL;
181  }
182 
183  return x_seg_pt;
184 }
SEG_PT_WND_RATIO
#define SEG_PT_WND_RATIO
Definition: cube_const.h:33
NULL
#define NULL
Definition: host.h:144
void tesseract::ConComp::SetID ( int  id)
inline

Definition at line 95 of file con_comp.h.

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

Definition at line 91 of file con_comp.h.

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

Definition at line 92 of file con_comp.h.

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

Definition at line 271 of file con_comp.cpp.

271  {
272  ConCompPt *pt_ptr = head_;
273 
274  while (pt_ptr != NULL) {
275  pt_ptr->Shift(dx, dy);
276  pt_ptr = pt_ptr->Next();
277  }
278 
279  left_ += dx;
280  right_ += dx;
281  top_ += dy;
282  bottom_ += dy;
283 }
NULL
#define NULL
Definition: host.h:144
tesseract::ConCompPt::Shift
void Shift(int dx, int dy)
Definition: con_comp.h:46
int tesseract::ConComp::Top ( ) const
inline

Definition at line 66 of file con_comp.h.

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

Definition at line 69 of file con_comp.h.

69 { return right_ - left_ + 1; }
The documentation for this class was generated from the following files: