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

ConComp()

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;
}

~ConComp()

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

Add()

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 (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;
}

Bottom()

int tesseract::ConComp::Bottom ( ) const

inline

Definition at line 68 of file con_comp.h.

{ return bottom_; }

CreateHistogram()

int * tesseract::ConComp::CreateHistogram

(

int

max_hist_wnd

)

Definition at line 103 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];

  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;
}

Head()

ConCompPt* tesseract::ConComp::Head ( )

inline

Definition at line 64 of file con_comp.h.

{ return head_; }

Height()

int tesseract::ConComp::Height ( ) const

inline

Definition at line 70 of file con_comp.h.

{ return bottom_ - top_ + 1; }

ID()

int tesseract::ConComp::ID ( ) const

inline

Definition at line 94 of file con_comp.h.

{ return id_; }

Left()

int tesseract::ConComp::Left ( ) const

inline

Definition at line 65 of file con_comp.h.

{ return left_; }

Left2RightComparer()

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_;
    }

LeftMost()

bool tesseract::ConComp::LeftMost ( ) const

inline

Definition at line 89 of file con_comp.h.

{ return left_most_; }

Merge()

bool tesseract::ConComp::Merge

(

ConComp *

con_comp

)

Definition at line 80 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;
}

PtCnt()

int tesseract::ConComp::PtCnt ( ) const

inline

Definition at line 96 of file con_comp.h.

{ return pt_cnt_; }

Right()

int tesseract::ConComp::Right ( ) const

inline

Definition at line 67 of file con_comp.h.

{ return right_; }

Right2LeftComparer()

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_;
    }

RightMost()

bool tesseract::ConComp::RightMost ( ) const

inline

Definition at line 90 of file con_comp.h.

{ return right_most_; }

Segment()

ConComp ** tesseract::ConComp::Segment	(	int	max_hist_wnd,
		int *	concomp_cnt
	)

Definition at line 180 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) {
    delete []x_seg_pt;
    return NULL;
  }

  // create concomp array
  ConComp **concomp_array = new ConComp *[seg_pt_cnt + 1];

  for (int concomp = 0; concomp <= seg_pt_cnt; concomp++) {
    concomp_array[concomp] = new ConComp();

    // 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;
}

SegmentHistogram()

int * tesseract::ConComp::SegmentHistogram	(	int *	hist_array,
		int *	seg_pt_cnt
	)

Definition at line 137 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];

  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;
}

SetID()

void tesseract::ConComp::SetID ( int  id )

inline

Definition at line 95 of file con_comp.h.

{ id_ = id; }

SetLeftMost()

void tesseract::ConComp::SetLeftMost ( bool  left_most )

inline

Definition at line 91 of file con_comp.h.

{ left_most_ = left_most; }

SetRightMost()

void tesseract::ConComp::SetRightMost ( bool  right_most )

inline

Definition at line 92 of file con_comp.h.

                                              { right_most_ = right_most;
    }

Shift()

void tesseract::ConComp::Shift	(	int	dx,
		int	dy
	)

Definition at line 254 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;
}

Top()

int tesseract::ConComp::Top ( ) const

inline

Definition at line 66 of file con_comp.h.

{ return top_; }

Width()

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:

• cube/con_comp.h
• cube/con_comp.cpp