tesseract 3.04.01
Public Member Functions | Static Public Member Functions | Public Attributes

TBLOB Struct Reference

#include <blobs.h>

List of all members.

Public Member Functions

 TBLOB ()
 TBLOB (const TBLOB &src)
 ~TBLOB ()
TBLOB & operator= (const TBLOB &src)
TBLOB * ClassifyNormalizeIfNeeded () const
void CopyFrom (const TBLOB &src)
void Clear ()
void Normalize (const BLOCK *block, const FCOORD *rotation, const DENORM *predecessor, float x_origin, float y_origin, float x_scale, float y_scale, float final_xshift, float final_yshift, bool inverse, Pix *pix)
void Rotate (const FCOORD rotation)
void Move (const ICOORD vec)
void Scale (float factor)
void ComputeBoundingBoxes ()
int NumOutlines () const
TBOX bounding_box () const
bool SegmentCrossesOutline (const TPOINT &pt1, const TPOINT &pt2) const
bool Contains (const TPOINT &pt) const
void EliminateDuplicateOutlines ()
void CorrectBlobOrder (TBLOB *next)
const DENORM & denorm () const
void plot (ScrollView *window, ScrollView::Color color, ScrollView::Color child_color)
int BBArea () const
int ComputeMoments (FCOORD *center, FCOORD *second_moments) const
void GetPreciseBoundingBox (TBOX *precise_box) const
void GetEdgeCoords (const TBOX &box, GenericVector< GenericVector< int > > *x_coords, GenericVector< GenericVector< int > > *y_coords) const

Static Public Member Functions

static TBLOB * PolygonalCopy (bool allow_detailed_fx, C_BLOB *src)
static TBLOB * ShallowCopy (const TBLOB &src)

Public Attributes

TESSLINE * outlines

Detailed Description

Definition at line 261 of file blobs.h.

Constructor & Destructor Documentation

TBLOB::TBLOB ( ) [inline]

Definition at line 262 of file blobs.h.

: outlines(NULL) {}
TBLOB::TBLOB ( const TBLOB &  src) [inline]

Definition at line 263 of file blobs.h.

                          : outlines(NULL) {
    CopyFrom(src);
  }
TBLOB::~TBLOB ( ) [inline]

Definition at line 266 of file blobs.h.

           {
    Clear();
  }

Member Function Documentation

int TBLOB::BBArea ( ) const [inline]

Definition at line 349 of file blobs.h.

                     {
    int total_area = 0;
    for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next)
      total_area += outline->BBArea();
    return total_area;
  }
TBOX TBLOB::bounding_box ( ) const

Definition at line 482 of file blobs.cpp.

                               {
  if (outlines == NULL)
    return TBOX(0, 0, 0, 0);
  TESSLINE *outline = outlines;
  TBOX box = outline->bounding_box();
  for (outline = outline->next; outline != NULL; outline = outline->next) {
    box += outline->bounding_box();
  }
  return box;
}
TBLOB * TBLOB::ClassifyNormalizeIfNeeded ( ) const

Definition at line 363 of file blobs.cpp.

                                              {
  TBLOB* rotated_blob = NULL;
  // If necessary, copy the blob and rotate it. The rotation is always
  // +/- 90 degrees, as 180 was already taken care of.
  if (denorm_.block() != NULL &&
      denorm_.block()->classify_rotation().y() != 0.0) {
    TBOX box = bounding_box();
    int x_middle = (box.left() + box.right()) / 2;
    int y_middle = (box.top() + box.bottom()) / 2;
    rotated_blob = new TBLOB(*this);
    const FCOORD& rotation = denorm_.block()->classify_rotation();
    // Move the rotated blob back to the same y-position so that we
    // can still distinguish similar glyphs with differeny y-position.
    float target_y = kBlnBaselineOffset +
        (rotation.y() > 0 ? x_middle - box.left() : box.right() - x_middle);
    rotated_blob->Normalize(NULL, &rotation, &denorm_, x_middle, y_middle,
                            1.0f, 1.0f, 0.0f, target_y,
                            denorm_.inverse(), denorm_.pix());
  }
  return rotated_blob;
}
void TBLOB::Clear ( )

Definition at line 402 of file blobs.cpp.

                  {
  for (TESSLINE* next_outline = NULL; outlines != NULL;
       outlines = next_outline) {
    next_outline = outlines->next;
    delete outlines;
  }
}
void TBLOB::ComputeBoundingBoxes ( )

Definition at line 462 of file blobs.cpp.

                                 {
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next) {
    outline->ComputeBoundingBox();
  }
}
int TBLOB::ComputeMoments ( FCOORD *  center,
FCOORD *  second_moments 
) const

Definition at line 535 of file blobs.cpp.

                                                                      {
  // Compute 1st and 2nd moments of the original outline.
  LLSQ accumulator;
  TBOX box = bounding_box();
  // Iterate the outlines, accumulating edges relative the box.botleft().
  CollectEdges(box, NULL, &accumulator, NULL, NULL);
  *center = accumulator.mean_point() + box.botleft();
  // The 2nd moments are just the standard deviation of the point positions.
  double x2nd = sqrt(accumulator.x_variance());
  double y2nd = sqrt(accumulator.y_variance());
  if (x2nd < 1.0) x2nd = 1.0;
  if (y2nd < 1.0) y2nd = 1.0;
  second_moments->set_x(x2nd);
  second_moments->set_y(y2nd);
  return accumulator.count();
}
bool TBLOB::Contains ( const TPOINT &  pt) const [inline]

Definition at line 324 of file blobs.h.

                                        {
    for (const TESSLINE* outline = outlines; outline != NULL;
         outline = outline->next) {
      if (outline->Contains(pt)) return true;
    }
    return false;
  }
void TBLOB::CopyFrom ( const TBLOB &  src)

Definition at line 386 of file blobs.cpp.

                                     {
  Clear();
  TESSLINE* prev_outline = NULL;
  for (TESSLINE* srcline = src.outlines; srcline != NULL;
       srcline = srcline->next) {
    TESSLINE* new_outline = new TESSLINE(*srcline);
    if (outlines == NULL)
      outlines = new_outline;
    else
      prev_outline->next = new_outline;
    prev_outline = new_outline;
  }
  denorm_ = src.denorm_;
}
void TBLOB::CorrectBlobOrder ( TBLOB *  next)

Definition at line 515 of file blobs.cpp.

                                        {
  TBOX box = bounding_box();
  TBOX next_box = next->bounding_box();
  if (box.x_middle() > next_box.x_middle()) {
    Swap(&outlines, &next->outlines);
  }
}
const DENORM& TBLOB::denorm ( ) const [inline]

Definition at line 340 of file blobs.h.

                               {
    return denorm_;
  }
void TBLOB::EliminateDuplicateOutlines ( )

Definition at line 495 of file blobs.cpp.

                                       {
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next) {
    TESSLINE* last_outline = outline;
    for (TESSLINE* other_outline = outline->next; other_outline != NULL;
         last_outline = other_outline, other_outline = other_outline->next) {
      if (outline->SameBox(*other_outline)) {
        last_outline->next = other_outline->next;
        // This doesn't leak - the outlines share the EDGEPTs.
        other_outline->loop = NULL;
        delete other_outline;
        other_outline = last_outline;
        // If it is part of a cut, then it can't be a hole any more.
        outline->is_hole = false;
      }
    }
  }
}
void TBLOB::GetEdgeCoords ( const TBOX &  box,
GenericVector< GenericVector< int > > *  x_coords,
GenericVector< GenericVector< int > > *  y_coords 
) const

Definition at line 570 of file blobs.cpp.

                                                                              {
  GenericVector<int> empty;
  x_coords->init_to_size(box.height(), empty);
  y_coords->init_to_size(box.width(), empty);
  CollectEdges(box, NULL, NULL, x_coords, y_coords);
  // Sort the output vectors.
  for (int i = 0; i < x_coords->size(); ++i)
    (*x_coords)[i].sort();
  for (int i = 0; i < y_coords->size(); ++i)
    (*y_coords)[i].sort();
}
void TBLOB::GetPreciseBoundingBox ( TBOX *  precise_box) const

Definition at line 554 of file blobs.cpp.

                                                         {
  TBOX box = bounding_box();
  *precise_box = TBOX();
  CollectEdges(box, precise_box, NULL, NULL, NULL);
  precise_box->move(box.botleft());
}
void TBLOB::Move ( const ICOORD  vec)

Definition at line 448 of file blobs.cpp.

                                 {
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next) {
    outline->Move(vec);
  }
}
void TBLOB::Normalize ( const BLOCK *  block,
const FCOORD *  rotation,
const DENORM *  predecessor,
float  x_origin,
float  y_origin,
float  x_scale,
float  y_scale,
float  final_xshift,
float  final_yshift,
bool  inverse,
Pix *  pix 
)

Definition at line 413 of file blobs.cpp.

                                              {
  denorm_.SetupNormalization(block, rotation, predecessor, x_origin, y_origin,
                             x_scale, y_scale, final_xshift, final_yshift);
  denorm_.set_inverse(inverse);
  denorm_.set_pix(pix);
  // TODO(rays) outline->Normalize is more accurate, but breaks tests due
  // the changes it makes. Reinstate this code with a retraining.
  // The reason this change is troublesome is that it normalizes for the
  // baseline value computed independently at each x-coord. If the baseline
  // is not horizontal, this introduces shear into the normalized blob, which
  // is useful on the rare occasions that the baseline is really curved, but
  // the baselines need to be stabilized the rest of the time.
#if 0
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next) {
    outline->Normalize(denorm_);
  }
#else
  denorm_.LocalNormBlob(this);
#endif
}
int TBLOB::NumOutlines ( ) const

Definition at line 469 of file blobs.cpp.

                             {
  int result = 0;
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next)
    ++result;
  return result;
}
TBLOB& TBLOB::operator= ( const TBLOB &  src) [inline]

Definition at line 269 of file blobs.h.

                                     {
    CopyFrom(src);
    return *this;
  }
void TBLOB::plot ( ScrollView *  window,
ScrollView::Color  color,
ScrollView::Color  child_color 
)

Definition at line 524 of file blobs.cpp.

                                              {
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next)
    outline->plot(window, color, child_color);
}
TBLOB * TBLOB::PolygonalCopy ( bool  allow_detailed_fx,
C_BLOB *  src 
) [static]

Definition at line 344 of file blobs.cpp.

                                                               {
  TBLOB* tblob = new TBLOB;
  ApproximateOutlineList(allow_detailed_fx, src->out_list(), false,
                         &tblob->outlines);
  return tblob;
}
void TBLOB::Rotate ( const FCOORD  rotation)

Definition at line 441 of file blobs.cpp.

                                        {
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next) {
    outline->Rotate(rotation);
  }
}
void TBLOB::Scale ( float  factor)

Definition at line 455 of file blobs.cpp.

                              {
  for (TESSLINE* outline = outlines; outline != NULL; outline = outline->next) {
    outline->Scale(factor);
  }
}
bool TBLOB::SegmentCrossesOutline ( const TPOINT &  pt1,
const TPOINT &  pt2 
) const [inline]

Definition at line 316 of file blobs.h.

                                                                         {
    for (const TESSLINE* outline = outlines; outline != NULL;
         outline = outline->next) {
      if (outline->SegmentCrosses(pt1, pt2)) return true;
    }
    return false;
  }
TBLOB * TBLOB::ShallowCopy ( const TBLOB &  src) [static]

Definition at line 352 of file blobs.cpp.

                                          {
  TBLOB* blob = new TBLOB;
  blob->denorm_ = src.denorm_;
  return blob;
}

Member Data Documentation

TESSLINE* TBLOB::outlines

Definition at line 377 of file blobs.h.

The documentation for this struct was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines