edgblob.cpp File Reference

#include "scanedg.h"
#include "edgloop.h"
#include "edgblob.h"

Go to the source code of this file.

Functions
extract_edges
Run the edge detector over the block and return a list of blobs.
void	extract_edges (Pix *pix, BLOCK *block)
outlines_to_blobs
Gather together outlines into blobs using the usual bucket sort.
void	outlines_to_blobs (BLOCK *block, ICOORD bleft, ICOORD tright, C_OUTLINE_LIST *outlines)
fill_buckets
Run the edge detector over the block and return a list of blobs.
void	fill_buckets (C_OUTLINE_LIST *outlines, OL_BUCKETS *buckets)
empty_buckets
Run the edge detector over the block and return a list of blobs.
void	empty_buckets (BLOCK *block, OL_BUCKETS *buckets)
capture_children
Find all neighbouring outlines that are children of this outline and either move them to the output list or declare this outline illegal and return false.
bool	capture_children (OL_BUCKETS *buckets, C_BLOB_IT *reject_it, C_OUTLINE_IT *blob_it)

Function Documentation

capture_children()

bool capture_children	(	OL_BUCKETS *	buckets,
		C_BLOB_IT *	reject_it,
		C_OUTLINE_IT *	blob_it
	)

Definition at line 435 of file edgblob.cpp.

  {
  C_OUTLINE *outline;            // master outline
  int32_t child_count;             // no of children
 
  outline = blob_it->data();
  if (edges_use_new_outline_complexity)
    child_count = buckets->outline_complexity(outline,
                                               edges_children_count_limit,
                                               0);
  else
    child_count = buckets->count_children(outline,
                                           edges_children_count_limit);
  if (child_count > edges_children_count_limit)
    return false;
 
  if (child_count > 0)
    buckets->extract_children(outline, blob_it);
  return true;
}

empty_buckets()

void empty_buckets	(	BLOCK *	block,
		OL_BUCKETS *	buckets
	)

Definition at line 393 of file edgblob.cpp.

                    {
  bool good_blob;               // healthy blob
  C_OUTLINE_LIST outlines;       // outlines in block
                                 // iterator
  C_OUTLINE_IT out_it = &outlines;
  C_OUTLINE_IT bucket_it = buckets->start_scan();
  C_OUTLINE_IT parent_it;        // parent outline
  C_BLOB_IT good_blobs = block->blob_list();
  C_BLOB_IT junk_blobs = block->reject_blobs();
 
  while (!bucket_it.empty()) {
    out_it.set_to_list(&outlines);
    do {
      parent_it = bucket_it;     // find outermost
      do {
        bucket_it.forward();
      } while (!bucket_it.at_first() &&
               !(*parent_it.data() < *bucket_it.data()));
    } while (!bucket_it.at_first());
 
                                 // move to new list
    out_it.add_after_then_move(parent_it.extract());
    good_blob = capture_children(buckets, &junk_blobs, &out_it);
    C_BLOB::ConstructBlobsFromOutlines(good_blob, &outlines, &good_blobs,
                                       &junk_blobs);
 
    bucket_it.set_to_list(buckets->scan_next());
  }
}

extract_edges()

void extract_edges	(	Pix *	pix,
		BLOCK *	block
	)

Definition at line 329 of file edgblob.cpp.

                                 {  // block to scan
  C_OUTLINE_LIST outlines;       // outlines in block
  C_OUTLINE_IT out_it = &outlines;
 
  block_edges(pix, &(block->pdblk), &out_it);
  ICOORD bleft;                  // block box
  ICOORD tright;
  block->pdblk.bounding_box(bleft, tright);
                                 // make blobs
  outlines_to_blobs(block, bleft, tright, &outlines);
}

fill_buckets()

void fill_buckets	(	C_OUTLINE_LIST *	outlines,
		OL_BUCKETS *	buckets
	)

Definition at line 368 of file edgblob.cpp.

                   {
  TBOX ol_box;                     // outline box
  C_OUTLINE_IT out_it = outlines;  // iterator
  C_OUTLINE_IT bucket_it;          // iterator in bucket
  C_OUTLINE *outline;              // current outline
 
  for (out_it.mark_cycle_pt(); !out_it.cycled_list(); out_it.forward()) {
    outline = out_it.extract();  // take off list
                                 // get box
    ol_box = outline->bounding_box();
    bucket_it.set_to_list((*buckets) (ol_box.left(), ol_box.bottom()));
    bucket_it.add_to_end(outline);
  }
}

outlines_to_blobs()

void outlines_to_blobs	(	BLOCK *	block,
		ICOORD	bleft,
		ICOORD	tright,
		C_OUTLINE_LIST *	outlines
	)

Definition at line 349 of file edgblob.cpp.

                                                 {
                                 // make buckets
  OL_BUCKETS buckets(bleft, tright);
 
  fill_buckets(outlines, &buckets);
  empty_buckets(block, &buckets);
}