#include <stepblob.h>

Inheritance diagram for C_BLOB:

Public Member Functions
	C_BLOB ()=default

	C_BLOB (C_OUTLINE_LIST *outline_list)

	C_BLOB (C_OUTLINE *outline)

void	CheckInverseFlagAndDirection ()

C_OUTLINE_LIST *	out_list ()

TBOX	bounding_box () const

int32_t	area ()

int32_t	perimeter ()

int32_t	outer_area ()

int32_t	count_transitions (int32_t threshold)

void	move (const ICOORD vec)

void	rotate (const FCOORD &rotation)

void	ComputeEdgeOffsets (int threshold, Pix *pix)

int16_t	EstimateBaselinePosition ()

Pix *	render ()

Pix *	render_outline ()

void	plot (ScrollView *window, ScrollView::Color blob_colour, ScrollView::Color child_colour)

void	plot_normed (const DENORM &denorm, ScrollView::Color blob_colour, ScrollView::Color child_colour, ScrollView *window)

C_BLOB &	operator= (const C_BLOB &source)

Public Member Functions inherited from ELIST_LINK
	ELIST_LINK ()

	ELIST_LINK (const ELIST_LINK &)

void	operator= (const ELIST_LINK &)

Static Public Member Functions
static void	ConstructBlobsFromOutlines (bool good_blob, C_OUTLINE_LIST outline_list, C_BLOB_IT good_blobs_it, C_BLOB_IT *bad_blobs_it)

static C_BLOB *	FakeBlob (const TBOX &box)

static C_BLOB *	deep_copy (const C_BLOB *src)

static int	SortByXMiddle (const void v1, const void v2)

Detailed Description

Definition at line 37 of file stepblob.h.

Constructor & Destructor Documentation

◆ C_BLOB() [1/3]

C_BLOB::C_BLOB ( )

default

◆ C_BLOB() [2/3]

C_BLOB::C_BLOB ( C_OUTLINE_LIST * outline_list )

explicit

Definition at line 165 of file stepblob.cpp.

                                            {
   for (C_OUTLINE_IT ol_it(outline_list); !ol_it.empty(); ol_it.forward()) {
     C_OUTLINE* outline = ol_it.extract();
     // Position this outline in appropriate position in the hierarchy.
     position_outline(outline, &outlines);
   }
   CheckInverseFlagAndDirection();
 }

◆ C_BLOB() [3/3]

C_BLOB::C_BLOB ( C_OUTLINE * outline )

explicit

Definition at line 176 of file stepblob.cpp.

                                  {
   C_OUTLINE_IT it(&outlines);
   it.add_to_end(outline);
 }

Member Function Documentation

◆ area()

int32_t C_BLOB::area ( )

Definition at line 275 of file stepblob.cpp.

                      {  //area
   C_OUTLINE *outline;            //current outline
   C_OUTLINE_IT it = &outlines;   //outlines of blob
   int32_t total;                   //total area
 
   total = 0;
   for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
     outline = it.data ();
     total += outline->area ();
   }
   return total;
 }

◆ bounding_box()

TBOX C_BLOB::bounding_box ( ) const

Definition at line 255 of file stepblob.cpp.

                                 {  // bounding box
   C_OUTLINE *outline;                // current outline
   // This is a read-only iteration of the outlines.
   C_OUTLINE_IT it = const_cast<C_OUTLINE_LIST*>(&outlines);
   TBOX box;                          // bounding box
 
   for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
     outline = it.data ();
     box += outline->bounding_box ();
   }
   return box;
 }

◆ CheckInverseFlagAndDirection()

void C_BLOB::CheckInverseFlagAndDirection ( )

Definition at line 226 of file stepblob.cpp.

                                           {
   C_OUTLINE_IT ol_it(&outlines);
   for (ol_it.mark_cycle_pt(); !ol_it.cycled_list(); ol_it.forward()) {
     C_OUTLINE* outline = ol_it.data();
     if (outline->turn_direction() < 0) {
       outline->reverse();
       reverse_outline_list(outline->child());
       outline->set_flag(COUT_INVERSE, TRUE);
     } else {
       outline->set_flag(COUT_INVERSE, FALSE);
     }
   }
 }

◆ ComputeEdgeOffsets()

void C_BLOB::ComputeEdgeOffsets	(	int	threshold,
		Pix *	pix
	)

Definition at line 415 of file stepblob.cpp.

                                                        {
   ComputeEdgeOffsetsOutlineList(threshold, pix, &outlines);
 }

◆ ConstructBlobsFromOutlines()

void C_BLOB::ConstructBlobsFromOutlines	(	bool	good_blob,
		C_OUTLINE_LIST *	outline_list,
		C_BLOB_IT *	good_blobs_it,
		C_BLOB_IT *	bad_blobs_it
	)

static

Definition at line 191 of file stepblob.cpp.

                                                                  {
   // List of top-level outlines with correctly nested children.
   C_OUTLINE_LIST nested_outlines;
   for (C_OUTLINE_IT ol_it(outline_list); !ol_it.empty(); ol_it.forward()) {
     C_OUTLINE* outline = ol_it.extract();
     // Position this outline in appropriate position in the hierarchy.
     position_outline(outline, &nested_outlines);
   }
   // Check for legal nesting and reassign as required.
   for (C_OUTLINE_IT ol_it(&nested_outlines); !ol_it.empty(); ol_it.forward()) {
     C_OUTLINE* outline = ol_it.extract();
     bool blob_is_good = good_blob;
     if (!outline->IsLegallyNested()) {
       // The blob is illegally nested.
       // Mark it bad, and add all its children to the top-level list.
       blob_is_good = false;
       ol_it.add_list_after(outline->child());
     }
     C_BLOB* blob = new C_BLOB(outline);
     // Set inverse flag and reverse if needed.
     blob->CheckInverseFlagAndDirection();
     // Put on appropriate list.
     if (!blob_is_good && bad_blobs_it != nullptr)
       bad_blobs_it->add_after_then_move(blob);
     else
       good_blobs_it->add_after_then_move(blob);
   }
 }

◆ count_transitions()

int32_t C_BLOB::count_transitions ( int32_t threshold )

Definition at line 335 of file stepblob.cpp.

                                  {
   C_OUTLINE *outline;            //current outline
   C_OUTLINE_IT it = &outlines;   //outlines of blob
   int32_t total;                   //total area
 
   total = 0;
   for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
     outline = it.data ();
     total += outline->count_transitions (threshold);
   }
   return total;
 }

◆ deep_copy()

static C_BLOB* C_BLOB::deep_copy ( const C_BLOB * src )

inlinestatic

Definition at line 119 of file stepblob.h.

                                                 {
       C_BLOB* blob = new C_BLOB;
       *blob = *src;
       return blob;
     }

◆ EstimateBaselinePosition()

int16_t C_BLOB::EstimateBaselinePosition ( )

Definition at line 433 of file stepblob.cpp.

                                          {
   TBOX box = bounding_box();
   int left = box.left();
   int width = box.width();
   int bottom = box.bottom();
   if (outlines.empty() || perimeter() > width * kMaxPerimeterWidthRatio)
     return bottom;  // This is only for non-CJK blobs.
   // Get the minimum y coordinate at each x-coordinate.
   GenericVector<int> y_mins;
   y_mins.init_to_size(width + 1, box.top());
   C_OUTLINE_IT it(&outlines);
   for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
     C_OUTLINE* outline = it.data();
     ICOORD pos = outline->start_pos();
     for (int s = 0; s < outline->pathlength(); ++s) {
       if (pos.y() < y_mins[pos.x() - left])
         y_mins[pos.x() - left] = pos.y();
       pos += outline->step(s);
     }
   }
   // Find the total extent of the bottom or bottom + 1.
   int bottom_extent = 0;
   for (int x = 0; x <= width; ++x) {
     if (y_mins[x] == bottom || y_mins[x] == bottom + 1)
       ++bottom_extent;
   }
   // Find the lowest run longer than the bottom extent that is not the bottom.
   int best_min = box.top();
   int prev_run = 0;
   int prev_y = box.top();
   int prev_prev_y = box.top();
   for (int x = 0; x < width; x += prev_run) {
     // Find the length of the current run.
     int y_at_x = y_mins[x];
     int run = 1;
     while (x + run <= width && y_mins[x + run] == y_at_x) ++run;
     if (y_at_x > bottom + 1) {
       // Possible contender.
       int total_run = run;
       // Find extent of current value or +1 to the right of x.
       while (x + total_run <= width &&
           (y_mins[x + total_run] == y_at_x ||
               y_mins[x + total_run] == y_at_x + 1)) ++total_run;
       // At least one end has to be higher so it is not a local max.
       if (prev_prev_y > y_at_x + 1 || x + total_run > width ||
           y_mins[x + total_run] > y_at_x + 1) {
         // If the prev_run is at y + 1, then we can add that too. There cannot
         // be a suitable run at y before that or we would have found it already.
         if (prev_run > 0 && prev_y == y_at_x + 1) total_run += prev_run;
         if (total_run > bottom_extent && y_at_x < best_min) {
           best_min = y_at_x;
         }
       }
     }
     prev_run = run;
     prev_prev_y = prev_y;
     prev_y = y_at_x;
   }
   return best_min == box.top() ? bottom : best_min;
 }

◆ FakeBlob()

C_BLOB * C_BLOB::FakeBlob ( const TBOX & box )

static

Definition at line 243 of file stepblob.cpp.

                                         {
   C_OUTLINE_LIST outlines;
   C_OUTLINE::FakeOutline(box, &outlines);
   return new C_BLOB(&outlines);
 }

◆ move()

void C_BLOB::move ( const ICOORD vec )

Definition at line 357 of file stepblob.cpp.

                    {
   C_OUTLINE_IT it(&outlines);  // iterator
 
   for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
     it.data ()->move (vec);      // move each outline
 }

◆ operator=()

C_BLOB& C_BLOB::operator= ( const C_BLOB & source )

inline

Definition at line 112 of file stepblob.h.

                                               {
       if (!outlines.empty ())
         outlines.clear();
       outlines.deep_copy(&source.outlines, &C_OUTLINE::deep_copy);
       return *this;
     }

◆ out_list()

C_OUTLINE_LIST* C_BLOB::out_list ( )

inline

Definition at line 70 of file stepblob.h.

                                {  //get outline list
       return &outlines;
     }

◆ outer_area()

int32_t C_BLOB::outer_area ( )

Definition at line 314 of file stepblob.cpp.

                            {  //area
   C_OUTLINE *outline;            //current outline
   C_OUTLINE_IT it = &outlines;   //outlines of blob
   int32_t total;                   //total area
 
   total = 0;
   for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
     outline = it.data ();
     total += outline->outer_area ();
   }
   return total;
 }

◆ perimeter()

int32_t C_BLOB::perimeter ( )

Definition at line 294 of file stepblob.cpp.

                           {
   C_OUTLINE *outline;            // current outline
   C_OUTLINE_IT it = &outlines;   // outlines of blob
   int32_t total;                   // total perimeter
 
   total = 0;
   for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
     outline = it.data();
     total += outline->perimeter();
   }
   return total;
 }

◆ plot()

void C_BLOB::plot	(	ScrollView *	window,
		ScrollView::Color	blob_colour,
		ScrollView::Color	child_colour
	)

Definition at line 538 of file stepblob.cpp.

                                                 {  // for holes
   plot_outline_list(&outlines, window, blob_colour, child_colour);
 }

◆ plot_normed()

void C_BLOB::plot_normed	(	const DENORM &	denorm,
		ScrollView::Color	blob_colour,
		ScrollView::Color	child_colour,
		ScrollView *	window
	)

Definition at line 546 of file stepblob.cpp.

                                              {
   plot_normed_outline_list(denorm, &outlines, blob_colour, child_colour,
                            window);
 }

◆ render()

Pix * C_BLOB::render ( )

Definition at line 515 of file stepblob.cpp.

                     {
   TBOX box = bounding_box();
   Pix* pix = pixCreate(box.width(), box.height(), 1);
   render_outline_list(&outlines, box.left(), box.top(), pix);
   return pix;
 }

◆ render_outline()

Pix * C_BLOB::render_outline ( )

Definition at line 524 of file stepblob.cpp.

                             {
   TBOX box = bounding_box();
   Pix* pix = pixCreate(box.width(), box.height(), 1);
   render_outline_list_outline(&outlines, box.left(), box.top(), pix);
   return pix;
 }

◆ rotate()

void C_BLOB::rotate ( const FCOORD & rotation )

Definition at line 393 of file stepblob.cpp.

                                           {
   RotateOutlineList(rotation, &outlines);
 }

◆ SortByXMiddle()

static int C_BLOB::SortByXMiddle	(	const void *	v1,
		const void *	v2
	)