Inheritance diagram for tesseract::TestableTableFinder:

Public Member Functions
void	ExpectPartition (const TBOX &box)

void	ExpectPartitionCount (int expected_count)

bool	GapInXProjection (int *xprojection, int length)

bool	HasLeaderAdjacent (const ColPartition &part)

void	InsertLeaderPartition (ColPartition *part)

void	InsertTextPartition (ColPartition *part)

void	set_global_median_blob_width (int width)

void	set_global_median_ledding (int ledding)

void	set_global_median_xheight (int xheight)

void	SplitAndInsertFragmentedTextPartition (ColPartition *part)

Public Member Functions inherited from tesseract::TableFinder
	TableFinder ()

	~TableFinder ()

void	set_resolution (int resolution)

void	set_left_to_right_language (bool order)

void	Init (int grid_size, const ICOORD &bottom_left, const ICOORD &top_right)

void	InsertCleanPartitions (ColPartitionGrid grid, TO_BLOCK block)

void	LocateTables (ColPartitionGrid grid, ColPartitionSet *columns, WidthCallback width_cb, const FCOORD &reskew)

Additional Inherited Members
Protected Member Functions inherited from tesseract::TableFinder
int	gridsize () const

int	gridwidth () const

int	gridheight () const

const ICOORD &	bleft () const

const ICOORD &	tright () const

ScrollView *	MakeWindow (int x, int y, const char *window_name)

void	InsertTextPartition (ColPartition *part)

void	InsertFragmentedTextPartition (ColPartition *part)

void	InsertLeaderPartition (ColPartition *part)

void	InsertRulingPartition (ColPartition *part)

void	InsertImagePartition (ColPartition *part)

void	SplitAndInsertFragmentedTextPartition (ColPartition *part)

bool	AllowTextPartition (const ColPartition &part) const

bool	AllowBlob (const BLOBNBOX &blob) const

void	MoveColSegmentsToGrid (ColSegment_LIST segments, ColSegmentGrid col_seg_grid)

void	InitializePartitions (ColPartitionSet **all_columns)

void	SetVerticalSpacing (ColPartition *part)

void	SetGlobalSpacings (ColPartitionGrid *grid)

void	set_global_median_xheight (int xheight)

void	set_global_median_blob_width (int width)

void	set_global_median_ledding (int ledding)

void	FindNeighbors ()

void	MarkTablePartitions ()

void	MarkPartitionsUsingLocalInformation ()

bool	HasWideOrNoInterWordGap (ColPartition *part) const

bool	HasLeaderAdjacent (const ColPartition &part)

void	FilterFalseAlarms ()

void	FilterParagraphEndings ()

void	FilterHeaderAndFooter ()

void	SmoothTablePartitionRuns ()

void	GetColumnBlocks (ColPartitionSet *columns, ColSegment_LIST col_segments)

void	GroupColumnBlocks (ColSegment_LIST current_segments, ColSegment_LIST col_segments)

bool	ConsecutiveBoxes (const TBOX &b1, const TBOX &b2)

void	SetColumnsType (ColSegment_LIST *col_segments)

void	GridMergeColumnBlocks ()

void	GetTableColumns (ColSegment_LIST *table_columns)

void	GetTableRegions (ColSegment_LIST table_columns, ColSegment_LIST table_regions)

void	GridMergeTableRegions ()

bool	BelongToOneTable (const TBOX &box1, const TBOX &box2)

void	AdjustTableBoundaries ()

void	GrowTableBox (const TBOX &table_box, TBOX *result_box)

void	GrowTableToIncludePartials (const TBOX &table_box, const TBOX &search_range, TBOX *result_box)

void	GrowTableToIncludeLines (const TBOX &table_box, const TBOX &search_range, TBOX *result_box)

bool	HLineBelongsToTable (const ColPartition &part, const TBOX &table_box)

void	IncludeLeftOutColumnHeaders (TBOX *table_box)

void	DeleteSingleColumnTables ()

bool	GapInXProjection (int *xprojection, int length)

void	RecognizeTables ()

void	DisplayColSegments (ScrollView win, ColSegment_LIST cols, ScrollView::Color color)

void	DisplayColPartitions (ScrollView win, ColPartitionGrid grid, ScrollView::Color text_color, ScrollView::Color table_color)

void	DisplayColPartitions (ScrollView win, ColPartitionGrid grid, ScrollView::Color default_color)

void	DisplayColPartitionConnections (ScrollView win, ColPartitionGrid grid, ScrollView::Color default_color)

void	MakeTableBlocks (ColPartitionGrid grid, ColPartitionSet *columns, const WidthCallback &width_cb)

Static Protected Member Functions inherited from tesseract::TableFinder
static void	SetPartitionSpacings (ColPartitionGrid grid, ColPartitionSet *all_columns)

Protected Attributes inherited from tesseract::TableFinder
int	resolution_

int	global_median_xheight_

int	global_median_blob_width_

int	global_median_ledding_

ColPartitionGrid	clean_part_grid_

ColPartitionGrid	leader_and_ruling_grid_

ColPartitionGrid	fragmented_text_grid_

ColSegmentGrid	col_seg_grid_

ColSegmentGrid	table_grid_

bool	left_to_right_language_

Detailed Description

Definition at line 22 of file tablefind_test.cc.

Member Function Documentation

◆ ExpectPartition()

void tesseract::TestableTableFinder::ExpectPartition ( const TBOX & box )

inline

Definition at line 33 of file tablefind_test.cc.

                                        {
    tesseract::ColPartitionGridSearch gsearch(&fragmented_text_grid_);
    gsearch.SetUniqueMode(true);
    gsearch.StartFullSearch();
    ColPartition *part = nullptr;
    bool found = false;
    while ((part = gsearch.NextFullSearch()) != nullptr) {
      if (part->bounding_box().left() == box.left() &&
          part->bounding_box().bottom() == box.bottom() &&
          part->bounding_box().right() == box.right() && part->bounding_box().top() == box.top()) {
        found = true;
      }
    }
    EXPECT_TRUE(found);
  }

◆ ExpectPartitionCount()

void tesseract::TestableTableFinder::ExpectPartitionCount ( int expected_count )

inline

Definition at line 48 of file tablefind_test.cc.

                                                {
    tesseract::ColPartitionGridSearch gsearch(&fragmented_text_grid_);
    gsearch.SetUniqueMode(true);
    gsearch.StartFullSearch();
    ColPartition *part = nullptr;
    int count = 0;
    while ((part = gsearch.NextFullSearch()) != nullptr) {
      ++count;
    }
    EXPECT_EQ(expected_count, count);
  }

◆ GapInXProjection()

bool tesseract::TableFinder::GapInXProjection	(	int *	xprojection,
		int	length
	)

Definition at line 345 of file tablefind.cpp.

                                                               {
  // Find peak value of the histogram
  int peak_value = 0;
  for (int i = 0; i < length; i++) {
    if (xprojection[i] > peak_value) {
      peak_value = xprojection[i];
    }
  }
  // Peak value represents the maximum number of horizontally
  // overlapping colpartitions, so this can be considered as the
  // number of rows in the table
  if (peak_value < kMinRowsInTable) {
    return false;
  }
  double projection_threshold = kSmallTableProjectionThreshold * peak_value;
  if (peak_value >= kLargeTableRowCount) {
    projection_threshold = kLargeTableProjectionThreshold * peak_value;
  }
  // Threshold the histogram
  for (int i = 0; i < length; i++) {
    xprojection[i] = (xprojection[i] >= projection_threshold) ? 1 : 0;
  }
  // Find the largest run of zeros between two ones
  int largest_gap = 0;
  int run_start = -1;
  for (int i = 1; i < length; i++) {
    // detect start of a run of zeros
    if (xprojection[i - 1] && !xprojection[i]) {
      run_start = i;
    }
    // detect end of a run of zeros and update the value of largest gap
    if (run_start != -1 && !xprojection[i - 1] && xprojection[i]) {
      int gap = i - run_start;
      if (gap > largest_gap) {
        largest_gap = gap;
      }
      run_start = -1;
    }
  }
  return largest_gap > kMaxXProjectionGapFactor * global_median_xheight_;
}

◆ HasLeaderAdjacent()

bool tesseract::TableFinder::HasLeaderAdjacent ( const ColPartition & part )

Definition at line 244 of file tablefind.cpp.

                                                            {
  if (part.flow() == BTFT_LEADER) {
    return true;
  }
  // Search range is left and right bounded by an offset of the
  // median xheight. This offset is to allow some tolerance to the
  // the leaders on the page in the event that the alignment is still
  // a bit off.
  const TBOX &box = part.bounding_box();
  const int search_size = kAdjacentLeaderSearchPadding * global_median_xheight_;
  const int top = box.top() + search_size;
  const int bottom = box.bottom() - search_size;
  ColPartitionGridSearch hsearch(&leader_and_ruling_grid_);
  for (int direction = 0; direction < 2; ++direction) {
    bool right_to_left = (direction == 0);
    int x = right_to_left ? box.right() : box.left();
    hsearch.StartSideSearch(x, bottom, top);
    ColPartition *leader = nullptr;
    while ((leader = hsearch.NextSideSearch(right_to_left)) != nullptr) {
      // The leader could be a horizontal ruling in the grid.
      // Make sure it is actually a leader.
      if (leader->flow() != BTFT_LEADER) {
        continue;
      }
      // This should not happen, they are in different grids.
      ASSERT_HOST(&part != leader);
      // Make sure the leader shares a page column with the partition,
      // otherwise we are spreading across columns.
      if (!part.IsInSameColumnAs(*leader)) {
        break;
      }
      // There should be a significant vertical overlap
      if (!leader->VSignificantCoreOverlap(part)) {
        continue;
      }
      // Leader passed all tests, so it is adjacent.
      return true;
    }
  }
  // No leaders are adjacent to the given partition.
  return false;
}

◆ InsertLeaderPartition()

void tesseract::TableFinder::InsertLeaderPartition ( ColPartition * part )

Definition at line 169 of file tablefind.cpp.

                                                          {
  ASSERT_HOST(part != nullptr);
  if (!part->IsEmpty() && part->bounding_box().area() > 0) {
    leader_and_ruling_grid_.InsertBBox(true, true, part);
  } else {
    delete part;
  }
}

◆ InsertTextPartition()

void tesseract::TableFinder::InsertTextPartition ( ColPartition * part )

Definition at line 167 of file tablefind.cpp.

                                                        {
  ASSERT_HOST(part != nullptr);
  if (AllowTextPartition(*part)) {
    clean_part_grid_.InsertBBox(true, true, part);
  } else {
    delete part;
  }
}

◆ set_global_median_blob_width()

void tesseract::TableFinder::set_global_median_blob_width ( int width )

Definition at line 214 of file tablefind.cpp.

                                                        {
  global_median_blob_width_ = width;
}

◆ set_global_median_ledding()

void tesseract::TableFinder::set_global_median_ledding ( int ledding )

Definition at line 219 of file tablefind.cpp.

                                                       {
  global_median_ledding_ = ledding;
}

◆ set_global_median_xheight()

void tesseract::TableFinder::set_global_median_xheight ( int xheight )

Definition at line 211 of file tablefind.cpp.

                                                       {
  global_median_xheight_ = xheight;
}

◆ SplitAndInsertFragmentedTextPartition()

void tesseract::TableFinder::SplitAndInsertFragmentedTextPartition ( ColPartition * part )

Definition at line 172 of file tablefind.cpp.

                                                                          {
  ASSERT_HOST(part != nullptr);
  // Bye bye empty partitions!
  if (part->boxes()->empty()) {
    delete part;
    return;
  }
 
  // The AllowBlob function prevents this.
  ASSERT_HOST(part->median_width() > 0);
  const double kThreshold = part->median_width() * kSplitPartitionSize;
 
  ColPartition *right_part = part;
  bool found_split = true;
  while (found_split) {
    found_split = false;
    BLOBNBOX_C_IT box_it(right_part->boxes());
    // Blobs are sorted left side first. If blobs overlap,
    // the previous blob may have a "more right" right side.
    // Account for this by always keeping the largest "right"
    // so far.
    int previous_right = INT32_MIN;
 
    // Look for the next split in the partition.
    for (box_it.mark_cycle_pt(); !box_it.cycled_list(); box_it.forward()) {
      const TBOX &box = box_it.data()->bounding_box();
      if (previous_right != INT32_MIN &&
          box.left() - previous_right > kThreshold) {
        // We have a split position. Split the partition in two pieces.
        // Insert the left piece in the grid and keep processing the right.
        int mid_x = (box.left() + previous_right) / 2;
        ColPartition *left_part = right_part;
        right_part = left_part->SplitAt(mid_x);
 
        InsertFragmentedTextPartition(left_part);
        found_split = true;
        break;
      }
 
      // The right side of the previous blobs.
      previous_right = std::max(previous_right, static_cast<int>(box.right()));
    }
  }
  // When a split is not found, the right part is minimized
  // as much as possible, so process it.
  InsertFragmentedTextPartition(right_part);
}

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

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

Public Member Functions

Additional Inherited Members