tesseract::TableRecognizer Class Reference

#include <tablerecog.h>

Inheritance diagram for tesseract::TableRecognizer:

Public Member Functions
	TableRecognizer ()=default
	~TableRecognizer ()=default
void	Init ()
void	set_text_grid (ColPartitionGrid *text)
void	set_line_grid (ColPartitionGrid *lines)
void	set_min_height (int height)
void	set_min_width (int width)
void	set_max_text_height (int height)
StructuredTable *	RecognizeTable (const TBOX &guess_box)

Protected Member Functions
bool	RecognizeLinedTable (const TBOX &guess_box, StructuredTable *table)
bool	HasSignificantLines (const TBOX &guess)
bool	FindLinesBoundingBox (TBOX *bounding_box)
bool	FindLinesBoundingBoxIteration (TBOX *bounding_box)
bool	RecognizeWhitespacedTable (const TBOX &guess_box, StructuredTable *table)
int	NextHorizontalSplit (int left, int right, int y, bool top_to_bottom)

Protected Attributes
ColPartitionGrid *	text_grid_ = nullptr
ColPartitionGrid *	line_grid_ = nullptr
int	min_height_ = 0
int	min_width_ = 0
int	max_text_height_ = INT32_MAX

Detailed Description

Definition at line 251 of file tablerecog.h.

Constructor & Destructor Documentation

TableRecognizer()

tesseract::TableRecognizer::TableRecognizer ( )

default

~TableRecognizer()

tesseract::TableRecognizer::~TableRecognizer ( )

default

Member Function Documentation

FindLinesBoundingBox()

bool tesseract::TableRecognizer::FindLinesBoundingBox ( TBOX *  bounding_box )

protected

Definition at line 847 of file tablerecog.cpp.

                                                             {
  // The first iteration will tell us if there are lines
  // present and shrink the box to a minimal iterative size.
  if (!FindLinesBoundingBoxIteration(bounding_box)) {
    return false;
  }
 
  // Keep growing until the area of the table stabilizes.
  // The box can only get bigger, increasing area.
  bool changed = true;
  while (changed) {
    changed = false;
    int old_area = bounding_box->area();
    bool check = FindLinesBoundingBoxIteration(bounding_box);
    // At this point, the function will return true.
    ASSERT_HOST(check);
    ASSERT_HOST(bounding_box->area() >= old_area);
    changed = (bounding_box->area() > old_area);
  }
 
  return true;
}

FindLinesBoundingBoxIteration()

bool tesseract::TableRecognizer::FindLinesBoundingBoxIteration ( TBOX *  bounding_box )

protected

Definition at line 870 of file tablerecog.cpp.

                                                                      {
  // Search for all of the lines in the current box, keeping track of extents.
  ColPartitionGridSearch box_search(line_grid_);
  box_search.SetUniqueMode(true);
  box_search.StartRectSearch(*bounding_box);
  ColPartition *line = nullptr;
  bool first_line = true;
 
  while ((line = box_search.NextRectSearch()) != nullptr) {
    if (line->IsLineType()) {
      if (first_line) {
        // The first iteration can shrink the box.
        *bounding_box = line->bounding_box();
        first_line = false;
      } else {
        *bounding_box += line->bounding_box();
      }
    }
  }
  return !first_line;
}

HasSignificantLines()

bool tesseract::TableRecognizer::HasSignificantLines ( const TBOX &  guess )

protected

Definition at line 806 of file tablerecog.cpp.

                                                           {
  ColPartitionGridSearch box_search(line_grid_);
  box_search.SetUniqueMode(true);
  box_search.StartRectSearch(guess);
  ColPartition *line = nullptr;
  int vertical_count = 0;
  int horizontal_count = 0;
 
  while ((line = box_search.NextRectSearch()) != nullptr) {
    if (line->IsHorizontalLine()) {
      ++horizontal_count;
    }
    if (line->IsVerticalLine()) {
      ++vertical_count;
    }
  }
 
  return vertical_count >= kLinedTableMinVerticalLines &&
         horizontal_count >= kLinedTableMinHorizontalLines;
}

Init()

void tesseract::TableRecognizer::Init

(

)

Definition at line 745 of file tablerecog.cpp.

{}

NextHorizontalSplit()

int tesseract::TableRecognizer::NextHorizontalSplit ( int  left, int  right, int  y, bool  top_to_bottom  )

protected

Definition at line 1053 of file tablerecog.cpp.

                                                                                       {
  ColPartitionGridSearch gsearch(text_grid_);
  gsearch.SetUniqueMode(true);
  gsearch.StartVerticalSearch(left, right, y);
  ColPartition *text = nullptr;
  int last_y = y;
  while ((text = gsearch.NextVerticalSearch(top_to_bottom)) != nullptr) {
    if (!text->IsTextType() || !text->IsHorizontalType()) {
      continue;
    }
    if (text->bounding_box().height() > max_text_height_) {
      continue;
    }
 
    const TBOX &text_box = text->bounding_box();
    if (top_to_bottom && (last_y >= y || last_y <= text_box.top())) {
      last_y = std::min(last_y, static_cast<int>(text_box.bottom()));
      continue;
    }
    if (!top_to_bottom && (last_y <= y || last_y >= text_box.bottom())) {
      last_y = std::max(last_y, static_cast<int>(text_box.top()));
      continue;
    }
 
    return last_y;
  }
  // If none is found, we at least want to preserve the min/max,
  // which defines the overlap of y with the last partition in the grid.
  return last_y;
}

RecognizeLinedTable()

bool tesseract::TableRecognizer::RecognizeLinedTable ( const TBOX &  guess_box, StructuredTable *  table  )

protected

Definition at line 788 of file tablerecog.cpp.

                                                                                       {
  if (!HasSignificantLines(guess_box)) {
    return false;
  }
  TBOX line_bound = guess_box;
  if (!FindLinesBoundingBox(&line_bound)) {
    return false;
  }
  table->set_bounding_box(line_bound);
  return table->FindLinedStructure();
}

RecognizeTable()

StructuredTable * tesseract::TableRecognizer::RecognizeTable

(

const TBOX &

guess_box

)

Definition at line 763 of file tablerecog.cpp.

                                                                  {
  auto *table = new StructuredTable();
  table->Init();
  table->set_text_grid(text_grid_);
  table->set_line_grid(line_grid_);
  table->set_max_text_height(max_text_height_);
 
  // Try to solve this simple case, a table with *both*
  // vertical and horizontal lines.
  if (RecognizeLinedTable(guess, table)) {
    return table;
  }
 
  // Fallback to whitespace if that failed.
  // TODO(nbeato): Break this apart to take advantage of horizontal
  // lines or vertical lines when present.
  if (RecognizeWhitespacedTable(guess, table)) {
    return table;
  }
 
  // No table found...
  delete table;
  return nullptr;
}

RecognizeWhitespacedTable()

bool tesseract::TableRecognizer::RecognizeWhitespacedTable ( const TBOX &  guess_box, StructuredTable *  table  )

protected

Definition at line 908 of file tablerecog.cpp.

                                                                                             {
  TBOX best_box = guess_box; // Best borders known.
  int best_below = 0;        // Margin size above best table.
  int best_above = 0;        // Margin size below best table.
  TBOX adjusted = guess_box; // The search box.
 
  // We assume that the guess box is somewhat accurate, so we don't allow
  // the adjusted border to pass half of the guessed area. This prevents
  // "negative" tables from forming.
  const int kMidGuessY = (guess_box.bottom() + guess_box.top()) / 2;
  // Keeps track of the most columns in an accepted table. The resulting table
  // may be less than the max, but we don't want to stray too far.
  unsigned best_cols = 0;
  // Make sure we find a good border.
  bool found_good_border = false;
 
  // Find the bottom of the table by trying a few different locations. For
  // each location, the top, left, and right are fixed. We start the search
  // in a smaller table to favor best_cols getting a good estimate sooner.
  int last_bottom = INT32_MAX;
  int bottom =
      NextHorizontalSplit(guess_box.left(), guess_box.right(), kMidGuessY - min_height_ / 2, true);
  int top =
      NextHorizontalSplit(guess_box.left(), guess_box.right(), kMidGuessY + min_height_ / 2, false);
  adjusted.set_top(top);
 
  // Headers/footers can be spaced far from everything.
  // Make sure that the space below is greater than the space above
  // the lowest row.
  int previous_below = 0;
  const int kMaxChances = 10;
  int chances = kMaxChances;
  while (bottom != last_bottom) {
    adjusted.set_bottom(bottom);
 
    if (adjusted.height() >= min_height_) {
      // Try to fit the grid on the current box. We give it a chance
      // if the number of columns didn't significantly drop.
      table->set_bounding_box(adjusted);
      if (table->FindWhitespacedStructure() &&
          table->column_count() >= best_cols * kRequiredColumns) {
        if (false && IsWeakTableRow(table, 0)) {
          // Currently buggy, but was looking promising so disabled.
          --chances;
        } else {
          // We favor 2 things,
          //   1- Adding rows that have partitioned data.
          //   2- Better margins (to find header/footer).
          // For better tables, we just look for multiple cells in the
          // bottom row with data in them.
          // For margins, the space below the last row should
          // be better than a table with the last row removed.
          chances = kMaxChances;
          double max_row_height = kMaxRowSize * table->median_cell_height();
          if ((table->space_below() * kMarginFactor >= best_below &&
               table->space_below() >= previous_below) ||
              (table->CountFilledCellsInRow(0) > 1 && table->row_height(0) < max_row_height)) {
            best_box.set_bottom(bottom);
            best_below = table->space_below();
            best_cols = std::max(table->column_count(), best_cols);
            found_good_border = true;
          }
        }
        previous_below = table->space_below();
      } else {
        --chances;
      }
    }
    if (chances <= 0) {
      break;
    }
 
    last_bottom = bottom;
    bottom = NextHorizontalSplit(guess_box.left(), guess_box.right(), last_bottom, true);
  }
  if (!found_good_border) {
    return false;
  }
 
  // TODO(nbeato) comments: follow modified code above... put it in a function!
  found_good_border = false;
  int last_top = INT32_MIN;
  top =
      NextHorizontalSplit(guess_box.left(), guess_box.right(), kMidGuessY + min_height_ / 2, false);
  int previous_above = 0;
  chances = kMaxChances;
 
  adjusted.set_bottom(best_box.bottom());
  while (last_top != top) {
    adjusted.set_top(top);
    if (adjusted.height() >= min_height_) {
      table->set_bounding_box(adjusted);
      if (table->FindWhitespacedStructure() &&
          table->column_count() >= best_cols * kRequiredColumns) {
        int last_row = table->row_count() - 1;
        if (false && IsWeakTableRow(table, last_row)) {
          // Currently buggy, but was looking promising so disabled.
          --chances;
        } else {
          chances = kMaxChances;
          double max_row_height = kMaxRowSize * table->median_cell_height();
          if ((table->space_above() * kMarginFactor >= best_above &&
               table->space_above() >= previous_above) ||
              (table->CountFilledCellsInRow(last_row) > 1 &&
               table->row_height(last_row) < max_row_height)) {
            best_box.set_top(top);
            best_above = table->space_above();
            best_cols = std::max(table->column_count(), best_cols);
            found_good_border = true;
          }
        }
        previous_above = table->space_above();
      } else {
        --chances;
      }
    }
    if (chances <= 0) {
      break;
    }
 
    last_top = top;
    top = NextHorizontalSplit(guess_box.left(), guess_box.right(), last_top, false);
  }
 
  if (!found_good_border) {
    return false;
  }
 
  // If we get here, this shouldn't happen. It can be an assert, but
  // I haven't tested it enough to make it crash things.
  if (best_box.null_box()) {
    return false;
  }
 
  // Given the best locations, fit the box to those locations.
  table->set_bounding_box(best_box);
  return table->FindWhitespacedStructure();
}

set_line_grid()

void tesseract::TableRecognizer::set_line_grid

(

ColPartitionGrid *

lines

)

Definition at line 750 of file tablerecog.cpp.

                                                               {
  line_grid_ = line_grid;
}

set_max_text_height()

void tesseract::TableRecognizer::set_max_text_height

(

int

height

)

Definition at line 759 of file tablerecog.cpp.

                                                    {
  max_text_height_ = height;
}

set_min_height()

void tesseract::TableRecognizer::set_min_height

(

int

height

)

Definition at line 753 of file tablerecog.cpp.

                                               {
  min_height_ = height;
}

set_min_width()

void tesseract::TableRecognizer::set_min_width

(

int

width

)

Definition at line 756 of file tablerecog.cpp.

                                             {
  min_width_ = width;
}

set_text_grid()

void tesseract::TableRecognizer::set_text_grid

(

ColPartitionGrid *

text

)

Definition at line 747 of file tablerecog.cpp.

                                                               {
  text_grid_ = text_grid;
}

Member Data Documentation

line_grid_

ColPartitionGrid* tesseract::TableRecognizer::line_grid_ = nullptr

protected

Definition at line 357 of file tablerecog.h.

max_text_height_

int tesseract::TableRecognizer::max_text_height_ = INT32_MAX

protected

Definition at line 362 of file tablerecog.h.

min_height_

int tesseract::TableRecognizer::min_height_ = 0

protected

Definition at line 359 of file tablerecog.h.

min_width_

int tesseract::TableRecognizer::min_width_ = 0

protected

Definition at line 360 of file tablerecog.h.

text_grid_

ColPartitionGrid* tesseract::TableRecognizer::text_grid_ = nullptr

protected

Definition at line 356 of file tablerecog.h.

---

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

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