#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, 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 263 of file blobs.h.

Constructor & Destructor Documentation

TBLOB::TBLOB ( )

inline

Definition at line 264 of file blobs.h.

264 : outlines(nullptr) {}

TBLOB::outlines

TESSLINE * outlines

Definition: blobs.h:379

TBLOB::TBLOB ( const TBLOB & src )

inline

Definition at line 265 of file blobs.h.

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

TBLOB::~TBLOB ( )

inline

Definition at line 268 of file blobs.h.

            {
     Clear();
   }

Member Function Documentation

int TBLOB::BBArea ( ) const

inline

Definition at line 351 of file blobs.h.

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

TBOX TBLOB::bounding_box ( ) const

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

TBLOB * TBLOB::ClassifyNormalizeIfNeeded ( ) const

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

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

void TBLOB::ComputeBoundingBoxes ( )

Definition at line 450 of file blobs.cpp.

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

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

Definition at line 526 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();
 }

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

inline

Definition at line 326 of file blobs.h.

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

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

void TBLOB::CorrectBlobOrder ( TBLOB * next )

Definition at line 505 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 342 of file blobs.h.

                                {
     return denorm_;
   }

void TBLOB::EliminateDuplicateOutlines ( )

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

void TBLOB::GetEdgeCoords	(	const TBOX &	box,
		GenericVector< GenericVector< int > > *	x_coords,
		GenericVector< GenericVector< int > > *	y_coords
	)		const

Definition at line 561 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, nullptr, nullptr, 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 545 of file blobs.cpp.

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

void TBLOB::Move ( const ICOORD vec )

Definition at line 434 of file blobs.cpp.

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

int TBLOB::NumOutlines ( ) const

Definition at line 458 of file blobs.cpp.

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

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

inline

Definition at line 271 of file blobs.h.

                                      {
     CopyFrom(src);
     return *this;
   }

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

Definition at line 514 of file blobs.cpp.

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

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

static

Definition at line 331 of file blobs.cpp.

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

void TBLOB::Rotate ( const FCOORD rotation )

Definition at line 426 of file blobs.cpp.

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

void TBLOB::Scale ( float factor )

Definition at line 442 of file blobs.cpp.

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

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

inline

Definition at line 318 of file blobs.h.

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

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

static

Definition at line 339 of file blobs.cpp.

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

Member Data Documentation

TESSLINE* TBLOB::outlines

Definition at line 379 of file blobs.h.

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

src/ccstruct/blobs.h
src/ccstruct/blobs.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation