tesseract::StructuredTable Class Reference

#include <tablerecog.h>

Inheritance diagram for tesseract::StructuredTable:

Public Member Functions
	StructuredTable ()
	~StructuredTable ()=default
void	Init ()
void	set_text_grid (ColPartitionGrid *text)
void	set_line_grid (ColPartitionGrid *lines)
void	set_max_text_height (int height)
bool	is_lined () const
unsigned	row_count () const
unsigned	column_count () const
unsigned	cell_count () const
void	set_bounding_box (const TBOX &box)
const TBOX &	bounding_box () const
int	median_cell_height ()
int	median_cell_width ()
int	row_height (unsigned row) const
int	column_width (unsigned column) const
int	space_above () const
int	space_below () const
bool	FindLinedStructure ()
bool	FindWhitespacedStructure ()
bool	DoesPartitionFit (const ColPartition &part) const
int	CountFilledCells ()
int	CountFilledCellsInRow (int row)
int	CountFilledCellsInColumn (int column)
int	CountFilledCells (unsigned row_start, unsigned row_end, unsigned column_start, unsigned column_end)
bool	VerifyRowFilled (int row)
double	CalculateCellFilledPercentage (unsigned row, unsigned column)
void	Display (ScrollView *window, ScrollView::Color color)

Protected Member Functions
void	ClearStructure ()
bool	VerifyLinedTableCells ()
bool	VerifyWhitespacedTable ()
void	FindWhitespacedColumns ()
void	FindWhitespacedRows ()
void	CalculateMargins ()
void	UpdateMargins (ColPartitionGrid *grid)
int	FindVerticalMargin (ColPartitionGrid *grid, int start_x, bool decrease) const
int	FindHorizontalMargin (ColPartitionGrid *grid, int start_y, bool decrease) const
void	CalculateStats ()
void	AbsorbNearbyLines ()
int	CountVerticalIntersections (int x)
int	CountHorizontalIntersections (int y)
int	CountPartitions (const TBOX &box)

Static Protected Member Functions
static void	FindCellSplitLocations (const std::vector< int > &min_list, const std::vector< int > &max_list, int max_merged, std::vector< int > *locations)

Protected Attributes
ColPartitionGrid *	text_grid_
ColPartitionGrid *	line_grid_
TBOX	bounding_box_
std::vector< int >	cell_x_
std::vector< int >	cell_y_
bool	is_lined_
int	space_above_
int	space_below_
int	space_left_
int	space_right_
int	median_cell_height_
int	median_cell_width_
int	max_text_height_

Detailed Description

Definition at line 70 of file tablerecog.h.

Constructor & Destructor Documentation

StructuredTable()

tesseract::StructuredTable::StructuredTable

(

)

Definition at line 88 of file tablerecog.cpp.

    : text_grid_(nullptr)
    , line_grid_(nullptr)
    , is_lined_(false)
    , space_above_(0)
    , space_below_(0)
    , space_left_(0)
    , space_right_(0)
    , median_cell_height_(0)
    , median_cell_width_(0)
    , max_text_height_(INT32_MAX) {}

~StructuredTable()

tesseract::StructuredTable::~StructuredTable ( )

default

Member Function Documentation

AbsorbNearbyLines()

void tesseract::StructuredTable::AbsorbNearbyLines ( )

protected

Definition at line 573 of file tablerecog.cpp.

                                        {
  ColPartitionGridSearch gsearch(line_grid_);
  gsearch.SetUniqueMode(true);
 
  // Is the closest line above good? Loop multiple times for tables with
  // multi-line (sometimes 2) borders. Limit the number of lines by
  // making sure they stay within a table cell or so.
  ColPartition *line = nullptr;
  gsearch.StartVerticalSearch(bounding_box_.left(), bounding_box_.right(), bounding_box_.top());
  while ((line = gsearch.NextVerticalSearch(false)) != nullptr) {
    if (!line->IsHorizontalLine()) {
      break;
    }
    TBOX text_search(bounding_box_.left(), bounding_box_.top() + 1, bounding_box_.right(),
                     line->MidY());
    if (text_search.height() > median_cell_height_ * 2) {
      break;
    }
    if (CountPartitions(text_search) > 0) {
      break;
    }
    bounding_box_.set_top(line->MidY());
  }
  // As above, is the closest line below good?
  line = nullptr;
  gsearch.StartVerticalSearch(bounding_box_.left(), bounding_box_.right(), bounding_box_.bottom());
  while ((line = gsearch.NextVerticalSearch(true)) != nullptr) {
    if (!line->IsHorizontalLine()) {
      break;
    }
    TBOX text_search(bounding_box_.left(), line->MidY(), bounding_box_.right(),
                     bounding_box_.bottom() - 1);
    if (text_search.height() > median_cell_height_ * 2) {
      break;
    }
    if (CountPartitions(text_search) > 0) {
      break;
    }
    bounding_box_.set_bottom(line->MidY());
  }
  // TODO(nbeato): vertical lines
}

bounding_box()

const TBOX & tesseract::StructuredTable::bounding_box

(

)

const

Definition at line 126 of file tablerecog.cpp.

                                                {
  return bounding_box_;
}

CalculateCellFilledPercentage()

double tesseract::StructuredTable::CalculateCellFilledPercentage	(	unsigned	row,
		unsigned	column
	)

Definition at line 294 of file tablerecog.cpp.

                                                                                   {
  ASSERT_HOST(row <= row_count());
  ASSERT_HOST(column <= column_count());
  const TBOX kCellBox(cell_x_[column], cell_y_[row], cell_x_[column + 1], cell_y_[row + 1]);
  ASSERT_HOST(!kCellBox.null_box());
 
  ColPartitionGridSearch gsearch(text_grid_);
  gsearch.SetUniqueMode(true);
  gsearch.StartRectSearch(kCellBox);
  double area_covered = 0;
  ColPartition *text = nullptr;
  while ((text = gsearch.NextRectSearch()) != nullptr) {
    if (text->IsTextType()) {
      area_covered += text->bounding_box().intersection(kCellBox).area();
    }
  }
  const int32_t current_area = kCellBox.area();
  if (current_area == 0) {
    return 1.0;
  }
  return std::min(1.0, area_covered / current_area);
}

CalculateMargins()

void tesseract::StructuredTable::CalculateMargins ( )

protected

Definition at line 496 of file tablerecog.cpp.

                                       {
  space_above_ = INT32_MAX;
  space_below_ = INT32_MAX;
  space_right_ = INT32_MAX;
  space_left_ = INT32_MAX;
  UpdateMargins(text_grid_);
  UpdateMargins(line_grid_);
}

CalculateStats()

void tesseract::StructuredTable::CalculateStats ( )

protected

Definition at line 551 of file tablerecog.cpp.

                                     {
  const int kMaxCellHeight = 1000;
  const int kMaxCellWidth = 1000;
  STATS height_stats(0, kMaxCellHeight);
  STATS width_stats(0, kMaxCellWidth);
 
  for (unsigned i = 0; i < row_count(); ++i) {
    height_stats.add(row_height(i), column_count());
  }
  for (unsigned i = 0; i < column_count(); ++i) {
    width_stats.add(column_width(i), row_count());
  }
 
  median_cell_height_ = static_cast<int>(height_stats.median() + 0.5);
  median_cell_width_ = static_cast<int>(width_stats.median() + 0.5);
}

cell_count()

unsigned tesseract::StructuredTable::cell_count

(

)

const

Definition at line 120 of file tablerecog.cpp.

                                           {
  return row_count() * column_count();
}

ClearStructure()

void tesseract::StructuredTable::ClearStructure ( )

protected

Definition at line 336 of file tablerecog.cpp.

                                     {
  cell_x_.clear();
  cell_y_.clear();
  is_lined_ = false;
  space_above_ = 0;
  space_below_ = 0;
  space_left_ = 0;
  space_right_ = 0;
  median_cell_height_ = 0;
  median_cell_width_ = 0;
}

column_count()

unsigned tesseract::StructuredTable::column_count

(

)

const

Definition at line 117 of file tablerecog.cpp.

                                             {
  return cell_x_.empty() ? 0 : cell_x_.size() - 1;
}

column_width()

int tesseract::StructuredTable::column_width

(

unsigned

column

)

const

Definition at line 139 of file tablerecog.cpp.

                                                       {
  ASSERT_HOST(column < column_count());
  return cell_x_[column + 1] - cell_x_[column];
}

CountFilledCells() [1/2]

int tesseract::StructuredTable::CountFilledCells

(

)

Definition at line 250 of file tablerecog.cpp.

                                      {
  return CountFilledCells(0, row_count() - 1, 0, column_count() - 1);
}

CountFilledCells() [2/2]

int tesseract::StructuredTable::CountFilledCells	(	unsigned	row_start,
		unsigned	row_end,
		unsigned	column_start,
		unsigned	column_end
	)

Definition at line 259 of file tablerecog.cpp.

                                                           {
  ASSERT_HOST(row_start <= row_end && row_end < row_count());
  ASSERT_HOST(column_start <= column_end && column_end < column_count());
  int cell_count = 0;
  TBOX cell_box;
  for (unsigned row = row_start; row <= row_end; ++row) {
    cell_box.set_bottom(cell_y_[row]);
    cell_box.set_top(cell_y_[row + 1]);
    for (unsigned col = column_start; col <= column_end; ++col) {
      cell_box.set_left(cell_x_[col]);
      cell_box.set_right(cell_x_[col + 1]);
      if (CountPartitions(cell_box) > 0) {
        ++cell_count;
      }
    }
  }
  return cell_count;
}

CountFilledCellsInColumn()

int tesseract::StructuredTable::CountFilledCellsInColumn

(

int

column

)

Definition at line 256 of file tablerecog.cpp.

                                                        {
  return CountFilledCells(0, row_count() - 1, column, column);
}

CountFilledCellsInRow()

int tesseract::StructuredTable::CountFilledCellsInRow

(

int

row

)

Definition at line 253 of file tablerecog.cpp.

                                                  {
  return CountFilledCells(row, row, 0, column_count() - 1);
}

CountHorizontalIntersections()

int tesseract::StructuredTable::CountHorizontalIntersections ( int  y )

protected

Definition at line 699 of file tablerecog.cpp.

                                                       {
  int count = 0;
  // Make a small box to keep the search time down.
  const int kGridSize = text_grid_->gridsize();
  TBOX horizontal_box = bounding_box_;
  horizontal_box.set_bottom(y - kGridSize);
  horizontal_box.set_top(y + kGridSize);
 
  ColPartitionGridSearch gsearch(text_grid_);
  gsearch.SetUniqueMode(true);
  gsearch.StartRectSearch(horizontal_box);
  ColPartition *text = nullptr;
  while ((text = gsearch.NextRectSearch()) != nullptr) {
    if (!text->IsTextType()) {
      continue;
    }
 
    const TBOX &box = text->bounding_box();
    if (box.bottom() < y && y < box.top()) {
      ++count;
    }
  }
  return count;
}

CountPartitions()

int tesseract::StructuredTable::CountPartitions ( const TBOX &  box )

protected

Definition at line 727 of file tablerecog.cpp.

                                                    {
  ColPartitionGridSearch gsearch(text_grid_);
  gsearch.SetUniqueMode(true);
  gsearch.StartRectSearch(box);
  int count = 0;
  ColPartition *text = nullptr;
  while ((text = gsearch.NextRectSearch()) != nullptr) {
    if (text->IsTextType()) {
      ++count;
    }
  }
  return count;
}

CountVerticalIntersections()

int tesseract::StructuredTable::CountVerticalIntersections ( int  x )

protected

Definition at line 673 of file tablerecog.cpp.

                                                     {
  int count = 0;
  // Make a small box to keep the search time down.
  const int kGridSize = text_grid_->gridsize();
  TBOX vertical_box = bounding_box_;
  vertical_box.set_left(x - kGridSize);
  vertical_box.set_right(x + kGridSize);
 
  ColPartitionGridSearch gsearch(text_grid_);
  gsearch.SetUniqueMode(true);
  gsearch.StartRectSearch(vertical_box);
  ColPartition *text = nullptr;
  while ((text = gsearch.NextRectSearch()) != nullptr) {
    if (!text->IsTextType()) {
      continue;
    }
    const TBOX &box = text->bounding_box();
    if (box.left() < x && x < box.right()) {
      ++count;
    }
  }
  return count;
}

Display()

void tesseract::StructuredTable::Display	(	ScrollView *	window,
		ScrollView::Color	color
	)

Definition at line 319 of file tablerecog.cpp.

                                                                       {
  window->Brush(ScrollView::NONE);
  window->Pen(color);
  window->Rectangle(bounding_box_.left(), bounding_box_.bottom(), bounding_box_.right(),
                    bounding_box_.top());
  for (int i : cell_x_) {
    window->Line(i, bounding_box_.bottom(), i, bounding_box_.top());
  }
  for (int i : cell_y_) {
    window->Line(bounding_box_.left(), i, bounding_box_.right(), i);
  }
  window->UpdateWindow();
}

DoesPartitionFit()

bool tesseract::StructuredTable::DoesPartitionFit

(

const ColPartition &

part

)

const

Definition at line 234 of file tablerecog.cpp.

                                                                     {
  const TBOX &box = part.bounding_box();
  for (int i : cell_x_) {
    if (box.left() < i && i < box.right()) {
      return false;
    }
  }
  for (int i : cell_y_) {
    if (box.bottom() < i && i < box.top()) {
      return false;
    }
  }
  return true;
}

FindCellSplitLocations()

void tesseract::StructuredTable::FindCellSplitLocations ( const std::vector< int > &  min_list, const std::vector< int > &  max_list, int  max_merged, std::vector< int > *  locations  )

staticprotected

Definition at line 630 of file tablerecog.cpp.

                                                                        {
  locations->clear();
  ASSERT_HOST(min_list.size() == max_list.size());
  if (min_list.empty()) {
    return;
  }
  ASSERT_HOST(min_list.at(0) < max_list.at(0));
  ASSERT_HOST(min_list.at(min_list.size() - 1) < max_list.at(max_list.size() - 1));
 
  locations->push_back(min_list.at(0));
  unsigned min_index = 0;
  unsigned max_index = 0;
  int stacked_partitions = 0;
  int last_cross_position = INT32_MAX;
  // max_index will expire after min_index.
  // However, we can't "increase" the hill size if min_index expired.
  // So finish processing when min_index expires.
  while (min_index < min_list.size()) {
    // Increase the hill count.
    if (min_list[min_index] < max_list[max_index]) {
      ++stacked_partitions;
      if (last_cross_position != INT32_MAX && stacked_partitions > max_merged) {
        int mid = (last_cross_position + min_list[min_index]) / 2;
        locations->push_back(mid);
        last_cross_position = INT32_MAX;
      }
      ++min_index;
    } else {
      // Decrease the hill count.
      --stacked_partitions;
      if (last_cross_position == INT32_MAX && stacked_partitions <= max_merged) {
        last_cross_position = max_list[max_index];
      }
      ++max_index;
    }
  }
  locations->push_back(max_list.at(max_list.size() - 1));
}

FindHorizontalMargin()

int tesseract::StructuredTable::FindHorizontalMargin ( ColPartitionGrid *  grid, int  start_y, bool  decrease  ) const

protected

Definition at line 533 of file tablerecog.cpp.

                                                                                                 {
  ColPartitionGridSearch gsearch(grid);
  gsearch.SetUniqueMode(true);
  gsearch.StartSideSearch(border, bounding_box_.bottom(), bounding_box_.top());
  ColPartition *part = nullptr;
  while ((part = gsearch.NextSideSearch(decrease)) != nullptr) {
    if (!part->IsTextType() && !part->IsVerticalLine()) {
      continue;
    }
    int distance =
        decrease ? border - part->bounding_box().right() : part->bounding_box().left() - border;
    if (distance >= 0) {
      return distance;
    }
  }
  return INT32_MAX;
}

FindLinedStructure()

bool tesseract::StructuredTable::FindLinedStructure

(

)

Definition at line 157 of file tablerecog.cpp.

                                         {
  ClearStructure();
 
  // Search for all of the lines in the current box.
  // Update the cellular structure with the exact lines.
  ColPartitionGridSearch box_search(line_grid_);
  box_search.SetUniqueMode(true);
  box_search.StartRectSearch(bounding_box_);
  ColPartition *line = nullptr;
 
  while ((line = box_search.NextRectSearch()) != nullptr) {
    if (line->IsHorizontalLine()) {
      cell_y_.push_back(line->MidY());
    }
    if (line->IsVerticalLine()) {
      cell_x_.push_back(line->MidX());
    }
  }
 
  // HasSignificantLines should guarantee cells.
  // Because that code is a different class, just gracefully
  // return false. This could be an assert.
  if (cell_x_.size() < 3 || cell_y_.size() < 3) {
    return false;
  }
 
  // Sort and remove duplicates that may have occurred due to split lines.
  std::sort(cell_x_.begin(), cell_x_.end());
  auto last_x = std::unique(cell_x_.begin(), cell_x_.end());
  cell_x_.erase(last_x, cell_x_.end());
  std::sort(cell_y_.begin(), cell_y_.end());
  auto last_y = std::unique(cell_y_.begin(), cell_y_.end());
  cell_y_.erase(last_y, cell_y_.end());
 
  // The border should be the extents of line boxes, not middle.
  cell_x_[0] = bounding_box_.left();
  cell_x_[cell_x_.size() - 1] = bounding_box_.right();
  cell_y_[0] = bounding_box_.bottom();
  cell_y_[cell_y_.size() - 1] = bounding_box_.top();
 
  // Remove duplicates that may have occurred due to moving the borders.
  last_x = std::unique(cell_x_.begin(), cell_x_.end());
  cell_x_.erase(last_x, cell_x_.end());
  last_y = std::unique(cell_y_.begin(), cell_y_.end());
  cell_y_.erase(last_y, cell_y_.end());
 
  CalculateMargins();
  CalculateStats();
  is_lined_ = VerifyLinedTableCells();
  return is_lined_;
}

FindVerticalMargin()

int tesseract::StructuredTable::FindVerticalMargin ( ColPartitionGrid *  grid, int  start_x, bool  decrease  ) const

protected

Definition at line 516 of file tablerecog.cpp.

                                                                                               {
  ColPartitionGridSearch gsearch(grid);
  gsearch.SetUniqueMode(true);
  gsearch.StartVerticalSearch(bounding_box_.left(), bounding_box_.right(), border);
  ColPartition *part = nullptr;
  while ((part = gsearch.NextVerticalSearch(decrease)) != nullptr) {
    if (!part->IsTextType() && !part->IsHorizontalLine()) {
      continue;
    }
    int distance =
        decrease ? border - part->bounding_box().top() : part->bounding_box().bottom() - border;
    if (distance >= 0) {
      return distance;
    }
  }
  return INT32_MAX;
}

FindWhitespacedColumns()

void tesseract::StructuredTable::FindWhitespacedColumns ( )

protected

Definition at line 384 of file tablerecog.cpp.

                                             {
  // Set of the extents of all partitions on the page.
  std::vector<int> left_sides;
  std::vector<int> right_sides;
 
  // Look at each text partition. We want to find the partitions
  // that have extremal left/right sides. These will give us a basis
  // for the table columns.
  ColPartitionGridSearch gsearch(text_grid_);
  gsearch.SetUniqueMode(true);
  gsearch.StartRectSearch(bounding_box_);
  ColPartition *text = nullptr;
  while ((text = gsearch.NextRectSearch()) != nullptr) {
    if (!text->IsTextType()) {
      continue;
    }
 
    ASSERT_HOST(text->bounding_box().left() < text->bounding_box().right());
    int spacing = static_cast<int>(text->median_width() * kHorizontalSpacing / 2.0 + 0.5);
    left_sides.push_back(text->bounding_box().left() - spacing);
    right_sides.push_back(text->bounding_box().right() + spacing);
  }
  // It causes disaster below, so avoid it!
  if (left_sides.empty() || right_sides.empty()) {
    return;
  }
 
  // Since data may be inserted in grid order, we sort the left/right sides.
  std::sort(left_sides.begin(), left_sides.end());
  std::sort(right_sides.begin(), right_sides.end());
 
  // At this point, in the "merged list", we expect to have a left side,
  // followed by either more left sides or a right side. The last number
  // should be a right side. We find places where the splits occur by looking
  // for "valleys". If we want to force gap sizes or allow overlap, change
  // the spacing above. If you want to let lines "slice" partitions as long
  // as it is infrequent, change the following function.
  FindCellSplitLocations(left_sides, right_sides, kCellSplitColumnThreshold, &cell_x_);
}

FindWhitespacedRows()

void tesseract::StructuredTable::FindWhitespacedRows ( )

protected

Definition at line 429 of file tablerecog.cpp.

                                          {
  // Set of the extents of all partitions on the page.
  std::vector<int> bottom_sides;
  std::vector<int> top_sides;
  // We will be "shrinking" partitions, so keep the min/max around to
  // make sure the bottom/top lines do not intersect text.
  int min_bottom = INT32_MAX;
  int max_top = INT32_MIN;
 
  // Look at each text partition. We want to find the partitions
  // that have extremal bottom/top sides. These will give us a basis
  // for the table rows. Because the textlines can be skewed and close due
  // to warping, the height of the partitions is toned down a little bit.
  ColPartitionGridSearch gsearch(text_grid_);
  gsearch.SetUniqueMode(true);
  gsearch.StartRectSearch(bounding_box_);
  ColPartition *text = nullptr;
  while ((text = gsearch.NextRectSearch()) != nullptr) {
    if (!text->IsTextType()) {
      continue;
    }
 
    ASSERT_HOST(text->bounding_box().bottom() < text->bounding_box().top());
    min_bottom = std::min(min_bottom, static_cast<int>(text->bounding_box().bottom()));
    max_top = std::max(max_top, static_cast<int>(text->bounding_box().top()));
 
    // Ignore "tall" text partitions, as these are usually false positive
    // vertical text or multiple lines pulled together.
    if (text->bounding_box().height() > max_text_height_) {
      continue;
    }
 
    int spacing = static_cast<int>(text->bounding_box().height() * kVerticalSpacing / 2.0 + 0.5);
    int bottom = text->bounding_box().bottom() - spacing;
    int top = text->bounding_box().top() + spacing;
    // For horizontal text, the factor can be negative. This should
    // probably cause a warning or failure. I haven't actually checked if
    // it happens.
    if (bottom >= top) {
      continue;
    }
 
    bottom_sides.push_back(bottom);
    top_sides.push_back(top);
  }
  // It causes disaster below, so avoid it!
  if (bottom_sides.empty() || top_sides.empty()) {
    return;
  }
 
  // Since data may be inserted in grid order, we sort the bottom/top sides.
  std::sort(bottom_sides.begin(), bottom_sides.end());
  std::sort(top_sides.begin(), top_sides.end());
 
  // At this point, in the "merged list", we expect to have a bottom side,
  // followed by either more bottom sides or a top side. The last number
  // should be a top side. We find places where the splits occur by looking
  // for "valleys". If we want to force gap sizes or allow overlap, change
  // the spacing above. If you want to let lines "slice" partitions as long
  // as it is infrequent, change the following function.
  FindCellSplitLocations(bottom_sides, top_sides, kCellSplitRowThreshold, &cell_y_);
 
  // Recover the min/max correctly since it was shifted.
  cell_y_[0] = min_bottom;
  cell_y_[cell_y_.size() - 1] = max_top;
}

FindWhitespacedStructure()

bool tesseract::StructuredTable::FindWhitespacedStructure

(

)

Definition at line 210 of file tablerecog.cpp.

                                               {
  ClearStructure();
  FindWhitespacedColumns();
  FindWhitespacedRows();
 
  if (!VerifyWhitespacedTable()) {
    return false;
  } else {
    bounding_box_.set_left(cell_x_[0]);
    bounding_box_.set_right(cell_x_[cell_x_.size() - 1]);
    bounding_box_.set_bottom(cell_y_[0]);
    bounding_box_.set_top(cell_y_[cell_y_.size() - 1]);
    AbsorbNearbyLines();
    CalculateMargins();
    CalculateStats();
    return true;
  }
}

Init()

void tesseract::StructuredTable::Init

(

)

Definition at line 100 of file tablerecog.cpp.

{}

is_lined()

bool tesseract::StructuredTable::is_lined

(

)

const

Definition at line 111 of file tablerecog.cpp.

                                     {
  return is_lined_;
}

median_cell_height()

int tesseract::StructuredTable::median_cell_height

(

)

Definition at line 129 of file tablerecog.cpp.

                                        {
  return median_cell_height_;
}

median_cell_width()

int tesseract::StructuredTable::median_cell_width

(

)

Definition at line 132 of file tablerecog.cpp.

                                       {
  return median_cell_width_;
}

row_count()

unsigned tesseract::StructuredTable::row_count

(

)

const

Definition at line 114 of file tablerecog.cpp.

                                          {
  return cell_y_.empty() ? 0 : cell_y_.size() - 1;
}

row_height()

int tesseract::StructuredTable::row_height

(

unsigned

row

)

const

Definition at line 135 of file tablerecog.cpp.

                                                  {
  ASSERT_HOST(row < row_count());
  return cell_y_[row + 1] - cell_y_[row];
}

set_bounding_box()

void tesseract::StructuredTable::set_bounding_box

(

const TBOX &

box

)

Definition at line 123 of file tablerecog.cpp.

                                                      {
  bounding_box_ = box;
}

set_line_grid()

void tesseract::StructuredTable::set_line_grid

(

ColPartitionGrid *

lines

)

Definition at line 105 of file tablerecog.cpp.

                                                               {
  line_grid_ = line_grid;
}

set_max_text_height()

void tesseract::StructuredTable::set_max_text_height

(

int

height

)

Definition at line 108 of file tablerecog.cpp.

                                                    {
  max_text_height_ = height;
}

set_text_grid()

void tesseract::StructuredTable::set_text_grid

(

ColPartitionGrid *

text

)

Definition at line 102 of file tablerecog.cpp.

                                                               {
  text_grid_ = text_grid;
}

space_above()

int tesseract::StructuredTable::space_above

(

)

const

Definition at line 143 of file tablerecog.cpp.

                                       {
  return space_above_;
}

space_below()

int tesseract::StructuredTable::space_below

(

)

const

Definition at line 146 of file tablerecog.cpp.

                                       {
  return space_below_;
}

UpdateMargins()

void tesseract::StructuredTable::UpdateMargins ( ColPartitionGrid *  grid )

protected

Definition at line 506 of file tablerecog.cpp.

                                                          {
  int below = FindVerticalMargin(grid, bounding_box_.bottom(), true);
  space_below_ = std::min(space_below_, below);
  int above = FindVerticalMargin(grid, bounding_box_.top(), false);
  space_above_ = std::min(space_above_, above);
  int left = FindHorizontalMargin(grid, bounding_box_.left(), true);
  space_left_ = std::min(space_left_, left);
  int right = FindHorizontalMargin(grid, bounding_box_.right(), false);
  space_right_ = std::min(space_right_, right);
}

VerifyLinedTableCells()

bool tesseract::StructuredTable::VerifyLinedTableCells ( )

protected

Definition at line 350 of file tablerecog.cpp.

                                            {
  // Function only called when lines exist.
  ASSERT_HOST(cell_y_.size() >= 2 && cell_x_.size() >= 2);
  for (int i : cell_y_) {
    if (CountHorizontalIntersections(i) > 0) {
      return false;
    }
  }
  for (int i : cell_x_) {
    if (CountVerticalIntersections(i) > 0) {
      return false;
    }
  }
  return true;
}

VerifyRowFilled()

bool tesseract::StructuredTable::VerifyRowFilled

(

int

row

)

Definition at line 282 of file tablerecog.cpp.

                                             {
  for (unsigned i = 0; i < column_count(); ++i) {
    auto area_filled = CalculateCellFilledPercentage(row, i);
    if (area_filled >= kMinFilledArea) {
      return true;
    }
  }
  return false;
}

VerifyWhitespacedTable()

bool tesseract::StructuredTable::VerifyWhitespacedTable ( )

protected

Definition at line 374 of file tablerecog.cpp.

                                             {
  // criteria for a table, must be at least 2x3 or 3x2
  return row_count() >= 2 && column_count() >= 2 && cell_count() >= 6;
}

Member Data Documentation

bounding_box_

TBOX tesseract::StructuredTable::bounding_box_

protected

Definition at line 236 of file tablerecog.h.

cell_x_

std::vector<int> tesseract::StructuredTable::cell_x_

protected

Definition at line 237 of file tablerecog.h.

cell_y_

std::vector<int> tesseract::StructuredTable::cell_y_

protected

Definition at line 238 of file tablerecog.h.

is_lined_

bool tesseract::StructuredTable::is_lined_

protected

Definition at line 239 of file tablerecog.h.

line_grid_

ColPartitionGrid* tesseract::StructuredTable::line_grid_

protected

Definition at line 232 of file tablerecog.h.

max_text_height_

int tesseract::StructuredTable::max_text_height_

protected

Definition at line 248 of file tablerecog.h.

median_cell_height_

int tesseract::StructuredTable::median_cell_height_

protected

Definition at line 245 of file tablerecog.h.

median_cell_width_

int tesseract::StructuredTable::median_cell_width_

protected

Definition at line 246 of file tablerecog.h.

space_above_

int tesseract::StructuredTable::space_above_

protected

Definition at line 241 of file tablerecog.h.

space_below_

int tesseract::StructuredTable::space_below_

protected

Definition at line 242 of file tablerecog.h.

space_left_

int tesseract::StructuredTable::space_left_

protected

Definition at line 243 of file tablerecog.h.

space_right_

int tesseract::StructuredTable::space_right_

protected

Definition at line 244 of file tablerecog.h.

text_grid_

ColPartitionGrid* tesseract::StructuredTable::text_grid_

protected

Definition at line 231 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