tesseract::TBLOB Struct Reference

#include <blobs.h>

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, Image 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, std::vector< std::vector< int > > &x_coords, std::vector< std::vector< 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 291 of file blobs.h.

Constructor & Destructor Documentation

TBLOB() [1/2]

tesseract::TBLOB::TBLOB ( )

inline

Definition at line 292 of file blobs.h.

: outlines(nullptr) {}

TBLOB() [2/2]

tesseract::TBLOB::TBLOB ( const TBLOB &  src )

inline

Definition at line 293 of file blobs.h.

                          : outlines(nullptr) {
    CopyFrom(src);
  }

~TBLOB()

tesseract::TBLOB::~TBLOB ( )

inline

Definition at line 296 of file blobs.h.

           {
    Clear();
  }

Member Function Documentation

BBArea()

int tesseract::TBLOB::BBArea ( ) const

inline

Definition at line 376 of file blobs.h.

                     {
    int total_area = 0;
    for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
      total_area += outline->BBArea();
    }
    return total_area;
  }

bounding_box()

TBOX tesseract::TBLOB::bounding_box

(

)

const

Definition at line 466 of file blobs.cpp.

                               {
  if (outlines == nullptr) {
    return TBOX(0, 0, 0, 0);
  }
  TESSLINE *outline = outlines;
  TBOX box = outline->bounding_box();
  for (outline = outline->next; outline != nullptr; outline = outline->next) {
    box += outline->bounding_box();
  }
  return box;
}

ClassifyNormalizeIfNeeded()

TBLOB * tesseract::TBLOB::ClassifyNormalizeIfNeeded

(

)

const

Definition at line 353 of file blobs.cpp.

                                              {
  TBLOB *rotated_blob = nullptr;
  // If necessary, copy the blob and rotate it. The rotation is always
  // +/- 90 degrees, as 180 was already taken care of.
  if (denorm_.block() != nullptr && 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(nullptr, &rotation, &denorm_, x_middle, y_middle, 1.0f, 1.0f, 0.0f,
                            target_y, denorm_.inverse(), denorm_.pix());
  }
  return rotated_blob;
}

Clear()

void tesseract::TBLOB::Clear

(

)

Definition at line 390 of file blobs.cpp.

                  {
  for (TESSLINE *next_outline = nullptr; outlines != nullptr; outlines = next_outline) {
    next_outline = outlines->next;
    delete outlines;
  }
}

ComputeBoundingBoxes()

void tesseract::TBLOB::ComputeBoundingBoxes

(

)

Definition at line 445 of file blobs.cpp.

                                 {
  for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
    outline->ComputeBoundingBox();
  }
}

ComputeMoments()

int tesseract::TBLOB::ComputeMoments	(	FCOORD *	center,
		FCOORD *	second_moments
	)		const

Definition at line 520 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, nullptr, &accumulator, nullptr, nullptr);
  *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();
}

Contains()

bool tesseract::TBLOB::Contains ( const TPOINT &  pt ) const

inline

Definition at line 351 of file blobs.h.

                                        {
    for (const TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
      if (outline->Contains(pt)) {
        return true;
      }
    }
    return false;
  }

CopyFrom()

void tesseract::TBLOB::CopyFrom

(

const TBLOB &

src

)

Definition at line 374 of file blobs.cpp.

                                     {
  Clear();
  TESSLINE *prev_outline = nullptr;
  for (TESSLINE *srcline = src.outlines; srcline != nullptr; srcline = srcline->next) {
    auto *new_outline = new TESSLINE(*srcline);
    if (outlines == nullptr) {
      outlines = new_outline;
    } else {
      prev_outline->next = new_outline;
    }
    prev_outline = new_outline;
  }
  denorm_ = src.denorm_;
}

CorrectBlobOrder()

void tesseract::TBLOB::CorrectBlobOrder

(

TBLOB *

next

)

Definition at line 500 of file blobs.cpp.

                                        {
  TBOX box = bounding_box();
  TBOX next_box = next->bounding_box();
  if (box.x_middle() > next_box.x_middle()) {
    std::swap(outlines, next->outlines);
  }
}

denorm()

const DENORM & tesseract::TBLOB::denorm ( ) const

inline

Definition at line 368 of file blobs.h.

                               {
    return denorm_;
  }

EliminateDuplicateOutlines()

void tesseract::TBLOB::EliminateDuplicateOutlines

(

)

Definition at line 480 of file blobs.cpp.

                                       {
  for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
    TESSLINE *last_outline = outline;
    for (TESSLINE *other_outline = outline->next; other_outline != nullptr;
         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 = nullptr;
        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;
      }
    }
  }
}

GetEdgeCoords()

void tesseract::TBLOB::GetEdgeCoords	(	const TBOX &	box,
		std::vector< std::vector< int > > &	x_coords,
		std::vector< std::vector< int > > &	y_coords
	)		const

Definition at line 559 of file blobs.cpp.

                                                                     {
  x_coords.clear();
  x_coords.resize(box.height());
  y_coords.clear();
  y_coords.resize(box.width());
  CollectEdges(box, nullptr, nullptr, &x_coords, &y_coords);
  // Sort the output vectors.
  for (auto &coord : x_coords) {
    std::sort(coord.begin(), coord.end());
  }
  for (auto &coord : y_coords) {
    std::sort(coord.begin(), coord.end());
  }
}

GetPreciseBoundingBox()

void tesseract::TBLOB::GetPreciseBoundingBox

(

TBOX *

precise_box

)

const

Definition at line 543 of file blobs.cpp.

                                                         {
  TBOX box = bounding_box();
  *precise_box = TBOX();
  CollectEdges(box, precise_box, nullptr, nullptr, nullptr);
  precise_box->move(box.botleft());
}

Move()

void tesseract::TBLOB::Move

(

const ICOORD

vec

)

Definition at line 431 of file blobs.cpp.

                                 {
  for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
    outline->Move(vec);
  }
}

Normalize()

void tesseract::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,
		Image	pix
	)

Definition at line 400 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 != nullptr; outline = outline->next) {
    outline->Normalize(denorm_);
  }
#else
  denorm_.LocalNormBlob(this);
#endif
}

NumOutlines()

int tesseract::TBLOB::NumOutlines

(

)

const

Definition at line 452 of file blobs.cpp.

                             {
  int result = 0;
  for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
    ++result;
  }
  return result;
}

operator=()

TBLOB & tesseract::TBLOB::operator= ( const TBLOB &  src )

inline

Definition at line 299 of file blobs.h.

                                     {
    CopyFrom(src);
    return *this;
  }

plot()

void tesseract::TBLOB::plot	(	ScrollView *	window,
		ScrollView::Color	color,
		ScrollView::Color	child_color
	)

Definition at line 509 of file blobs.cpp.

                                                                                       {
  for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
    outline->plot(window, color, child_color);
  }
}

PolygonalCopy()

TBLOB * tesseract::TBLOB::PolygonalCopy ( bool  allow_detailed_fx, C_BLOB *  src  )

static

Definition at line 335 of file blobs.cpp.

                                                               {
  auto *tblob = new TBLOB;
  ApproximateOutlineList(allow_detailed_fx, src->out_list(), false, &tblob->outlines);
  return tblob;
}

Rotate()

void tesseract::TBLOB::Rotate

(

const FCOORD

rotation

)

Definition at line 424 of file blobs.cpp.

                                        {
  for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
    outline->Rotate(rotation);
  }
}

Scale()

void tesseract::TBLOB::Scale

(

float

factor

)

Definition at line 438 of file blobs.cpp.

                              {
  for (TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
    outline->Scale(factor);
  }
}

SegmentCrossesOutline()

bool tesseract::TBLOB::SegmentCrossesOutline ( const TPOINT &  pt1, const TPOINT &  pt2  ) const

inline

Definition at line 342 of file blobs.h.

                                                                         {
    for (const TESSLINE *outline = outlines; outline != nullptr; outline = outline->next) {
      if (outline->SegmentCrosses(pt1, pt2)) {
        return true;
      }
    }
    return false;
  }

ShallowCopy()

TBLOB * tesseract::TBLOB::ShallowCopy ( const TBLOB &  src )

static

Definition at line 342 of file blobs.cpp.

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

Member Data Documentation

outlines

TESSLINE* tesseract::TBLOB::outlines

Definition at line 404 of file blobs.h.

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/blobs.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/blobs.cpp