#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.

                 {
  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
	)		`[inline, static]`

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
	)		`[inline, static]`

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:

tesseract-ocr/cube/con_comp.h
tesseract-ocr/cube/con_comp.cpp

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation