tesseract::AlignedBlob Class Reference

#include <alignedblob.h>

Inheritance diagram for tesseract::AlignedBlob:

Public Member Functions
	AlignedBlob (int gridsize, const ICOORD &bleft, const ICOORD &tright)
	~AlignedBlob () override
ScrollView *	DisplayTabs (const char *window_name, ScrollView *tab_win)
TabVector *	FindVerticalAlignment (AlignedBlobParams align_params, BLOBNBOX *bbox, int *vertical_x, int *vertical_y)
Public Member Functions inherited from tesseract::BlobGrid
	BlobGrid (int gridsize, const ICOORD &bleft, const ICOORD &tright)
	~BlobGrid () override
void	InsertBlobList (BLOBNBOX_LIST *blobs)
Public Member Functions inherited from tesseract::BBGrid< BLOBNBOX, BLOBNBOX_CLIST, BLOBNBOX_C_IT >
	BBGrid ()
	BBGrid (int gridsize, const ICOORD &bleft, const ICOORD &tright)
	~BBGrid () override
void	Init (int gridsize, const ICOORD &bleft, const ICOORD &tright)
void	Clear ()
void	ClearGridData (void(*free_method)(BLOBNBOX *))
void	InsertBBox (bool h_spread, bool v_spread, BLOBNBOX *bbox)
void	InsertPixPtBBox (int left, int bottom, Image pix, BLOBNBOX *bbox)
void	RemoveBBox (BLOBNBOX *bbox)
bool	RectangleEmpty (const TBOX &rect)
IntGrid *	CountCellElements ()
ScrollView *	MakeWindow (int x, int y, const char *window_name)
void	DisplayBoxes (ScrollView *window)
void	AssertNoDuplicates ()
virtual void	HandleClick (int x, int y)
Public Member Functions inherited from tesseract::GridBase
	GridBase ()=default
	GridBase (int gridsize, const ICOORD &bleft, const ICOORD &tright)
virtual	~GridBase ()
void	Init (int gridsize, const ICOORD &bleft, const ICOORD &tright)
int	gridsize () const
int	gridwidth () const
int	gridheight () const
const ICOORD &	bleft () const
const ICOORD &	tright () const
void	GridCoords (int x, int y, int *grid_x, int *grid_y) const
void	ClipGridCoords (int *x, int *y) const

Static Public Member Functions
static bool	WithinTestRegion (int detail_level, int x, int y)

Additional Inherited Members
Protected Attributes inherited from tesseract::BBGrid< BLOBNBOX, BLOBNBOX_CLIST, BLOBNBOX_C_IT >
BLOBNBOX_CLIST *	grid_
Protected Attributes inherited from tesseract::GridBase
int	gridsize_
int	gridwidth_
int	gridheight_
int	gridbuckets_
ICOORD	bleft_
ICOORD	tright_

Detailed Description

Definition at line 76 of file alignedblob.h.

Constructor & Destructor Documentation

AlignedBlob()

tesseract::AlignedBlob::AlignedBlob	(	int	gridsize,
		const ICOORD &	bleft,
		const ICOORD &	tright
	)

Definition at line 149 of file alignedblob.cpp.

    : BlobGrid(gridsize, bleft, tright) {}

~AlignedBlob()

tesseract::AlignedBlob::~AlignedBlob ( )

overridedefault

Member Function Documentation

DisplayTabs()

ScrollView * tesseract::AlignedBlob::DisplayTabs	(	const char *	window_name,
		ScrollView *	tab_win
	)

Definition at line 165 of file alignedblob.cpp.

                                                                                 {
  if (tab_win == nullptr) {
    tab_win = MakeWindow(0, 50, window_name);
  }
  // For every tab in the grid, display it.
  GridSearch<BLOBNBOX, BLOBNBOX_CLIST, BLOBNBOX_C_IT> gsearch(this);
  gsearch.StartFullSearch();
  BLOBNBOX *bbox;
  while ((bbox = gsearch.NextFullSearch()) != nullptr) {
    const TBOX &box = bbox->bounding_box();
    int left_x = box.left();
    int right_x = box.right();
    int top_y = box.top();
    int bottom_y = box.bottom();
    TabType tabtype = bbox->left_tab_type();
    if (tabtype != TT_NONE) {
      if (tabtype == TT_MAYBE_ALIGNED) {
        tab_win->Pen(ScrollView::BLUE);
      } else if (tabtype == TT_MAYBE_RAGGED) {
        tab_win->Pen(ScrollView::YELLOW);
      } else if (tabtype == TT_CONFIRMED) {
        tab_win->Pen(ScrollView::GREEN);
      } else {
        tab_win->Pen(ScrollView::GREY);
      }
      tab_win->Line(left_x, top_y, left_x, bottom_y);
    }
    tabtype = bbox->right_tab_type();
    if (tabtype != TT_NONE) {
      if (tabtype == TT_MAYBE_ALIGNED) {
        tab_win->Pen(ScrollView::MAGENTA);
      } else if (tabtype == TT_MAYBE_RAGGED) {
        tab_win->Pen(ScrollView::ORANGE);
      } else if (tabtype == TT_CONFIRMED) {
        tab_win->Pen(ScrollView::RED);
      } else {
        tab_win->Pen(ScrollView::GREY);
      }
      tab_win->Line(right_x, top_y, right_x, bottom_y);
    }
  }
  tab_win->Update();
  return tab_win;
}

FindVerticalAlignment()

TabVector * tesseract::AlignedBlob::FindVerticalAlignment	(	AlignedBlobParams	align_params,
		BLOBNBOX *	bbox,
		int *	vertical_x,
		int *	vertical_y
	)

Definition at line 234 of file alignedblob.cpp.

                                                                                {
  int ext_start_y, ext_end_y;
  BLOBNBOX_CLIST good_points;
  // Search up and then down from the starting bbox.
  TBOX box = bbox->bounding_box();
  bool debug = WithinTestRegion(2, box.left(), box.bottom());
  int pt_count = AlignTabs(align_params, false, bbox, &good_points, &ext_end_y);
  pt_count += AlignTabs(align_params, true, bbox, &good_points, &ext_start_y);
  BLOBNBOX_C_IT it(&good_points);
  it.move_to_last();
  box = it.data()->bounding_box();
  int end_y = box.top();
  int end_x = align_params.right_tab ? box.right() : box.left();
  it.move_to_first();
  box = it.data()->bounding_box();
  int start_x = align_params.right_tab ? box.right() : box.left();
  int start_y = box.bottom();
  // Acceptable tab vectors must have a minimum number of points,
  // have a minimum acceptable length, and have a minimum gradient.
  // The gradient corresponds to the skew angle.
  // Ragged tabs don't need to satisfy the gradient condition, as they
  // will always end up parallel to the vertical direction.
  bool at_least_2_crossings = AtLeast2LineCrossings(&good_points);
  if ((pt_count >= align_params.min_points && end_y - start_y >= align_params.min_length &&
       (align_params.ragged || end_y - start_y >= abs(end_x - start_x) * kMinTabGradient)) ||
      at_least_2_crossings) {
    int confirmed_points = 0;
    // Count existing confirmed points to see if vector is acceptable.
    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
      bbox = it.data();
      if (align_params.right_tab) {
        if (bbox->right_tab_type() == align_params.confirmed_type) {
          ++confirmed_points;
        }
      } else {
        if (bbox->left_tab_type() == align_params.confirmed_type) {
          ++confirmed_points;
        }
      }
    }
    // Ragged vectors are not allowed to use too many already used points.
    if (!align_params.ragged || confirmed_points + confirmed_points < pt_count) {
      const TBOX &box = bbox->bounding_box();
      if (debug) {
        tprintf("Confirming tab vector of %d pts starting at %d,%d\n", pt_count, box.left(),
                box.bottom());
      }
      // Flag all the aligned neighbours as confirmed .
      for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
        bbox = it.data();
        if (align_params.right_tab) {
          bbox->set_right_tab_type(align_params.confirmed_type);
        } else {
          bbox->set_left_tab_type(align_params.confirmed_type);
        }
        if (debug) {
          bbox->bounding_box().print();
        }
      }
      // Now make the vector and return it.
      TabVector *result =
          TabVector::FitVector(align_params.alignment, align_params.vertical, ext_start_y,
                               ext_end_y, &good_points, vertical_x, vertical_y);
      result->set_intersects_other_lines(at_least_2_crossings);
      if (debug) {
        tprintf("Box was %d, %d\n", box.left(), box.bottom());
        result->Print("After fitting");
      }
      return result;
    } else if (debug) {
      tprintf("Ragged tab used too many used points: %d out of %d\n", confirmed_points, pt_count);
    }
  } else if (debug) {
    tprintf(
        "Tab vector failed basic tests: pt count %d vs min %d, "
        "length %d vs min %d, min grad %g\n",
        pt_count, align_params.min_points, end_y - start_y, align_params.min_length,
        abs(end_x - start_x) * kMinTabGradient);
  }
  return nullptr;
}

WithinTestRegion()

bool tesseract::AlignedBlob::WithinTestRegion ( int  detail_level, int  x, int  y  )

static

Definition at line 154 of file alignedblob.cpp.

                                                                 {
  if (textord_debug_tabfind < detail_level) {
    return false;
  }
  return x >= textord_testregion_left && x <= textord_testregion_right &&
         y <= textord_testregion_top && y >= textord_testregion_bottom;
}

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/textord/alignedblob.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/textord/alignedblob.cpp