tesseract::TestableStructuredTable Class Reference

Inheritance diagram for tesseract::TestableStructuredTable:

Public Member Functions
void	InjectCellY (int y)
void	InjectCellX (int x)
void	ExpectCellX (int x_min, int second, int add, int almost_done, int x_max)
void	ExpectSortedX ()
int	CountHorizontalIntersections (int y)
int	CountVerticalIntersections (int x)
bool	FindLinedStructure ()
void	FindWhitespacedColumns ()
bool	FindWhitespacedStructure ()
bool	VerifyLinedTableCells ()
Public Member Functions inherited from tesseract::StructuredTable
	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)

Additional Inherited Members
Protected Member Functions inherited from tesseract::StructuredTable
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 inherited from tesseract::StructuredTable
static void	FindCellSplitLocations (const std::vector< int > &min_list, const std::vector< int > &max_list, int max_merged, std::vector< int > *locations)
Protected Attributes inherited from tesseract::StructuredTable
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 31 of file tablerecog_test.cc.

Member Function Documentation

CountHorizontalIntersections()

int tesseract::StructuredTable::CountHorizontalIntersections

(

int

y

)

Definition at line 221 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;
}

CountVerticalIntersections()

int tesseract::StructuredTable::CountVerticalIntersections

(

int

x

)

Definition at line 220 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;
}

ExpectCellX()

void tesseract::TestableStructuredTable::ExpectCellX ( int  x_min, int  second, int  add, int  almost_done, int  x_max  )

inline

Definition at line 49 of file tablerecog_test.cc.

                                                                               {
    ASSERT_EQ(0, (almost_done - second) % add);
    EXPECT_EQ(3 + (almost_done - second) / add, cell_x_.size());
    EXPECT_EQ(x_min, cell_x_.at(0));
    EXPECT_EQ(x_max, cell_x_.at(cell_x_.size() - 1));
    for (unsigned i = 1; i < cell_x_.size() - 1; ++i) {
      EXPECT_EQ(second + add * (i - 1), cell_x_.at(i));
    }
  }

ExpectSortedX()

void tesseract::TestableStructuredTable::ExpectSortedX ( )

inline

Definition at line 59 of file tablerecog_test.cc.

                       {
    EXPECT_GT(cell_x_.size(), 0);
    for (unsigned i = 1; i < cell_x_.size(); ++i) {
      EXPECT_LT(cell_x_.at(i - 1), cell_x_.at(i));
    }
  }

FindLinedStructure()

bool tesseract::StructuredTable::FindLinedStructure

(

)

Definition at line 105 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_;
}

FindWhitespacedColumns()

void tesseract::StructuredTable::FindWhitespacedColumns

(

)

Definition at line 160 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_);
}

FindWhitespacedStructure()

bool tesseract::StructuredTable::FindWhitespacedStructure

(

)

Definition at line 110 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;
  }
}

InjectCellX()

void tesseract::TestableStructuredTable::InjectCellX ( int  x )

inline

Definition at line 44 of file tablerecog_test.cc.

                          {
    cell_x_.push_back(x);
    std::sort(cell_x_.begin(), cell_x_.end());
  }

InjectCellY()

void tesseract::TestableStructuredTable::InjectCellY ( int  y )

inline

Definition at line 40 of file tablerecog_test.cc.

                          {
    cell_y_.push_back(y);
    std::sort(cell_y_.begin(), cell_y_.end());
  }

VerifyLinedTableCells()

bool tesseract::StructuredTable::VerifyLinedTableCells

(

)

Definition at line 148 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;
}

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/unittest/tablerecog_test.cc