tesseract::ColPartitionSet Class Reference

#include <colpartitionset.h>

Inheritance diagram for tesseract::ColPartitionSet:

Public Member Functions
	ColPartitionSet ()=default
	ColPartitionSet (ColPartition_LIST *partitions)
	ColPartitionSet (ColPartition *partition)
	~ColPartitionSet ()=default
const TBOX &	bounding_box () const
bool	Empty () const
int	ColumnCount () const
int	GoodColumnCount () const
ColPartition *	GetColumnByIndex (int index)
ColPartition *	ColumnContaining (int x, int y)
void	GetColumnBoxes (int y_bottom, int y_top, ColSegment_LIST *segments)
void	RelinquishParts ()
void	ImproveColumnCandidate (const WidthCallback &cb, PartSetVector *src_sets)
void	AddToColumnSetsIfUnique (PartSetVector *column_sets, const WidthCallback &cb)
bool	CompatibleColumns (bool debug, ColPartitionSet *other, const WidthCallback &cb)
int	UnmatchedWidth (ColPartitionSet *part_set)
bool	LegalColumnCandidate ()
ColPartitionSet *	Copy (bool good_only)
void	DisplayColumnEdges (int y_bottom, int y_top, ScrollView *win)
ColumnSpanningType	SpanningType (int resolution, int left, int right, int height, int y, int left_margin, int right_margin, int *first_col, int *last_col, int *first_spanned_col)
void	ChangeWorkColumns (const ICOORD &bleft, const ICOORD &tright, int resolution, ColPartition_LIST *used_parts, WorkingPartSet_LIST *working_set)
void	AccumulateColumnWidthsAndGaps (int *total_width, int *width_samples, int *total_gap, int *gap_samples)
void	Print ()
Public Member Functions inherited from tesseract::ELIST_LINK
	ELIST_LINK ()
	ELIST_LINK (const ELIST_LINK &)
void	operator= (const ELIST_LINK &)

Detailed Description

Definition at line 38 of file colpartitionset.h.

Constructor & Destructor Documentation

ColPartitionSet() [1/3]

tesseract::ColPartitionSet::ColPartitionSet ( )

default

ColPartitionSet() [2/3]

tesseract::ColPartitionSet::ColPartitionSet ( ColPartition_LIST *  partitions )

explicit

Definition at line 33 of file colpartitionset.cpp.

                                                              {
  ColPartition_IT it(&parts_);
  it.add_list_after(partitions);
  ComputeCoverage();
}

ColPartitionSet() [3/3]

tesseract::ColPartitionSet::ColPartitionSet ( ColPartition *  partition )

explicit

Definition at line 39 of file colpartitionset.cpp.

                                                   {
  ColPartition_IT it(&parts_);
  it.add_after_then_move(part);
  ComputeCoverage();
}

~ColPartitionSet()

tesseract::ColPartitionSet::~ColPartitionSet ( )

default

Member Function Documentation

AccumulateColumnWidthsAndGaps()

void tesseract::ColPartitionSet::AccumulateColumnWidthsAndGaps	(	int *	total_width,
		int *	width_samples,
		int *	total_gap,
		int *	gap_samples
	)

Definition at line 588 of file colpartitionset.cpp.

                                                                      {
  ColPartition_IT it(&parts_);
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    *total_width += part->ColumnWidth();
    ++*width_samples;
    if (!it.at_last()) {
      ColPartition *next_part = it.data_relative(1);
      int part_left = part->right_key();
      int part_right = next_part->left_key();
      int gap = part->KeyWidth(part_left, part_right);
      *total_gap += gap;
      ++*gap_samples;
    }
  }
}

AddToColumnSetsIfUnique()

void tesseract::ColPartitionSet::AddToColumnSetsIfUnique	(	PartSetVector *	column_sets,
		const WidthCallback &	cb
	)

Definition at line 180 of file colpartitionset.cpp.

                                                                       {
  bool debug = TabFind::WithinTestRegion(2, bounding_box_.left(),
                                         bounding_box_.bottom());
  if (debug) {
    tprintf("Considering new column candidate:\n");
    Print();
  }
  if (!LegalColumnCandidate()) {
    if (debug) {
      tprintf("Not a legal column candidate:\n");
      Print();
    }
    delete this;
    return;
  }
  for (unsigned i = 0; i < column_sets->size(); ++i) {
    ColPartitionSet *columns = column_sets->at(i);
    // In ordering the column set candidates, good_coverage_ is king,
    // followed by good_column_count_ and then bad_coverage_.
    bool better = good_coverage_ > columns->good_coverage_;
    if (good_coverage_ == columns->good_coverage_) {
      better = good_column_count_ > columns->good_column_count_;
      if (good_column_count_ == columns->good_column_count_) {
        better = bad_coverage_ > columns->bad_coverage_;
      }
    }
    if (better) {
      // The new one is better so add it.
      if (debug) {
        tprintf("Good one\n");
      }
      column_sets->insert(column_sets->begin() + i, this);
      return;
    }
    if (columns->CompatibleColumns(false, this, cb)) {
      if (debug) {
        tprintf("Duplicate\n");
      }
      delete this;
      return; // It is not unique.
    }
  }
  if (debug) {
    tprintf("Added to end\n");
  }
  column_sets->push_back(this);
}

bounding_box()

const TBOX & tesseract::ColPartitionSet::bounding_box ( ) const

inline

Definition at line 47 of file colpartitionset.h.

                                   {
    return bounding_box_;
  }

ChangeWorkColumns()

void tesseract::ColPartitionSet::ChangeWorkColumns	(	const ICOORD &	bleft,
		const ICOORD &	tright,
		int	resolution,
		ColPartition_LIST *	used_parts,
		WorkingPartSet_LIST *	working_set
	)

Definition at line 517 of file colpartitionset.cpp.

                                                                               {
  // Move the input list to a temporary location so we can delete its elements
  // as we add them to the output working_set.
  WorkingPartSet_LIST work_src;
  WorkingPartSet_IT src_it(&work_src);
  src_it.add_list_after(working_set_list);
  src_it.move_to_first();
  WorkingPartSet_IT dest_it(working_set_list);
  // Completed blocks and to_blocks are accumulated and given to the first new
  // one  whenever we keep a column, or at the end.
  BLOCK_LIST completed_blocks;
  TO_BLOCK_LIST to_blocks;
  WorkingPartSet *first_new_set = nullptr;
  WorkingPartSet *working_set = nullptr;
  ColPartition_IT col_it(&parts_);
  for (col_it.mark_cycle_pt(); !col_it.cycled_list(); col_it.forward()) {
    ColPartition *column = col_it.data();
    // Any existing column to the left of column is completed.
    while (!src_it.empty() &&
           ((working_set = src_it.data())->column() == nullptr ||
            working_set->column()->right_key() <= column->left_key())) {
      src_it.extract();
      working_set->ExtractCompletedBlocks(bleft, tright, resolution, used_parts,
                                          &completed_blocks, &to_blocks);
      delete working_set;
      src_it.forward();
    }
    // Make a new between-column WorkingSet for before the current column.
    working_set = new WorkingPartSet(nullptr);
    dest_it.add_after_then_move(working_set);
    if (first_new_set == nullptr) {
      first_new_set = working_set;
    }
    // A matching column gets to stay, and first_new_set gets all the
    // completed_sets.
    working_set = src_it.empty() ? nullptr : src_it.data();
    if (working_set != nullptr &&
        working_set->column()->MatchingColumns(*column)) {
      working_set->set_column(column);
      dest_it.add_after_then_move(src_it.extract());
      src_it.forward();
      first_new_set->InsertCompletedBlocks(&completed_blocks, &to_blocks);
      first_new_set = nullptr;
    } else {
      // Just make a new working set for the current column.
      working_set = new WorkingPartSet(column);
      dest_it.add_after_then_move(working_set);
    }
  }
  // Complete any remaining src working sets.
  while (!src_it.empty()) {
    working_set = src_it.extract();
    working_set->ExtractCompletedBlocks(bleft, tright, resolution, used_parts,
                                        &completed_blocks, &to_blocks);
    delete working_set;
    src_it.forward();
  }
  // Make a new between-column WorkingSet for after the last column.
  working_set = new WorkingPartSet(nullptr);
  dest_it.add_after_then_move(working_set);
  if (first_new_set == nullptr) {
    first_new_set = working_set;
  }
  // The first_new_set now gets any accumulated completed_parts/blocks.
  first_new_set->InsertCompletedBlocks(&completed_blocks, &to_blocks);
}

ColumnContaining()

ColPartition * tesseract::ColPartitionSet::ColumnContaining	(	int	x,
		int	y
	)

Definition at line 72 of file colpartitionset.cpp.

                                                            {
  ColPartition_IT it(&parts_);
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    if (part->ColumnContains(x, y)) {
      return part;
    }
  }
  return nullptr;
}

ColumnCount()

int tesseract::ColPartitionSet::ColumnCount ( ) const

inline

Definition at line 53 of file colpartitionset.h.

                          {
    return parts_.length();
  }

CompatibleColumns()

bool tesseract::ColPartitionSet::CompatibleColumns	(	bool	debug,
		ColPartitionSet *	other,
		const WidthCallback &	cb
	)

Definition at line 231 of file colpartitionset.cpp.

                                                                 {
  if (debug) {
    tprintf("CompatibleColumns testing compatibility\n");
    Print();
    other->Print();
  }
  if (other->parts_.empty()) {
    if (debug) {
      tprintf("CompatibleColumns true due to empty other\n");
    }
    return true;
  }
  ColPartition_IT it(&other->parts_);
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    if (part->blob_type() < BRT_UNKNOWN) {
      if (debug) {
        tprintf("CompatibleColumns ignoring image partition\n");
        part->Print();
      }
      continue; // Image partitions are irrelevant to column compatibility.
    }
    int y = part->MidY();
    int left = part->bounding_box().left();
    int right = part->bounding_box().right();
    ColPartition *left_col = ColumnContaining(left, y);
    ColPartition *right_col = ColumnContaining(right, y);
    if (right_col == nullptr || left_col == nullptr) {
      if (debug) {
        tprintf("CompatibleColumns false due to partition edge outside\n");
        part->Print();
      }
      return false; // A partition edge lies outside of all columns
    }
    if (right_col != left_col && cb(right - left)) {
      if (debug) {
        tprintf("CompatibleColumns false due to good width in multiple cols\n");
        part->Print();
      }
      return false; // Partition with a good width must be in a single column.
    }
 
    ColPartition_IT it2 = it;
    while (!it2.at_last()) {
      it2.forward();
      ColPartition *next_part = it2.data();
      if (!BLOBNBOX::IsTextType(next_part->blob_type())) {
        continue; // Non-text partitions are irrelevant.
      }
      int next_left = next_part->bounding_box().left();
      if (next_left == right) {
        break; // They share the same edge, so one must be a pull-out.
      }
      // Search to see if right and next_left fall within a single column.
      ColPartition *next_left_col = ColumnContaining(next_left, y);
      if (right_col == next_left_col) {
        // There is a column break in this column.
        // This can be due to a figure caption within a column, a pull-out
        // block, or a simple broken textline that remains to be merged:
        // all allowed, or a change in column layout: not allowed.
        // If both partitions are of good width, then it is likely
        // a change in column layout, otherwise probably an allowed situation.
        if (part->good_width() && next_part->good_width()) {
          if (debug) {
            int next_right = next_part->bounding_box().right();
            tprintf("CompatibleColumns false due to 2 parts of good width\n");
            tprintf("part1 %d-%d, part2 %d-%d\n", left, right, next_left,
                    next_right);
            right_col->Print();
          }
          return false;
        }
      }
      break;
    }
  }
  if (debug) {
    tprintf("CompatibleColumns true!\n");
  }
  return true;
}

Copy()

ColPartitionSet * tesseract::ColPartitionSet::Copy

(

bool

good_only

)

Definition at line 368 of file colpartitionset.cpp.

                                                     {
  ColPartition_LIST copy_parts;
  ColPartition_IT src_it(&parts_);
  ColPartition_IT dest_it(&copy_parts);
  for (src_it.mark_cycle_pt(); !src_it.cycled_list(); src_it.forward()) {
    ColPartition *part = src_it.data();
    if (BLOBNBOX::IsTextType(part->blob_type()) &&
        (!good_only || part->good_width() || part->good_column())) {
      dest_it.add_after_then_move(part->ShallowCopy());
    }
  }
  if (dest_it.empty()) {
    return nullptr;
  }
  return new ColPartitionSet(&copy_parts);
}

DisplayColumnEdges()

void tesseract::ColPartitionSet::DisplayColumnEdges	(	int	y_bottom,
		int	y_top,
		ScrollView *	win
	)

Definition at line 404 of file colpartitionset.cpp.

                                                          {
  ColPartition_IT it(&parts_);
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    win->Line(part->LeftAtY(y_top), y_top, part->LeftAtY(y_bottom), y_bottom);
    win->Line(part->RightAtY(y_top), y_top, part->RightAtY(y_bottom), y_bottom);
  }
}

Empty()

bool tesseract::ColPartitionSet::Empty ( ) const

inline

Definition at line 50 of file colpartitionset.h.

                     {
    return parts_.empty();
  }

GetColumnBoxes()

void tesseract::ColPartitionSet::GetColumnBoxes	(	int	y_bottom,
		int	y_top,
		ColSegment_LIST *	segments
	)

Definition at line 386 of file colpartitionset.cpp.

                                                                {
  ColPartition_IT it(&parts_);
  ColSegment_IT col_it(segments);
  col_it.move_to_last();
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    ICOORD bot_left(part->LeftAtY(y_top), y_bottom);
    ICOORD top_right(part->RightAtY(y_bottom), y_top);
    auto *col_seg = new ColSegment();
    col_seg->InsertBox(TBOX(bot_left, top_right));
    col_it.add_after_then_move(col_seg);
  }
}

GetColumnByIndex()

ColPartition * tesseract::ColPartitionSet::GetColumnByIndex

(

int

index

)

Definition at line 59 of file colpartitionset.cpp.

                                                         {
  ColPartition_IT it(&parts_);
  it.mark_cycle_pt();
  for (int i = 0; i < index && !it.cycled_list(); ++i, it.forward()) {
    ;
  }
  if (it.cycled_list()) {
    return nullptr;
  }
  return it.data();
}

GoodColumnCount()

int tesseract::ColPartitionSet::GoodColumnCount

(

)

const

Definition at line 46 of file colpartitionset.cpp.

                                           {
  int num_good_cols = 0;
  // This is a read-only iteration of the list.
  ColPartition_IT it(const_cast<ColPartition_LIST *>(&parts_));
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    if (it.data()->good_width()) {
      ++num_good_cols;
    }
  }
  return num_good_cols;
}

ImproveColumnCandidate()

void tesseract::ColPartitionSet::ImproveColumnCandidate	(	const WidthCallback &	cb,
		PartSetVector *	src_sets
	)

Definition at line 93 of file colpartitionset.cpp.

                                                                      {
  int set_size = src_sets->size();
  // Iterate over the provided column sets, as each one may have something
  // to improve this.
  for (int i = 0; i < set_size; ++i) {
    ColPartitionSet *column_set = src_sets->at(i);
    if (column_set == nullptr) {
      continue;
    }
    // Iterate over the parts in this and column_set, adding bigger or
    // new parts in column_set to this.
    ColPartition_IT part_it(&parts_);
    ASSERT_HOST(!part_it.empty());
    int prev_right = INT32_MIN;
    part_it.mark_cycle_pt();
    ColPartition_IT col_it(&column_set->parts_);
    for (col_it.mark_cycle_pt(); !col_it.cycled_list(); col_it.forward()) {
      ColPartition *col_part = col_it.data();
      if (col_part->blob_type() < BRT_UNKNOWN) {
        continue; // Ignore image partitions.
      }
      int col_left = col_part->left_key();
      int col_right = col_part->right_key();
      // Sync-up part_it (in this) so it matches the col_part in column_set.
      ColPartition *part = part_it.data();
      while (!part_it.at_last() && part->right_key() < col_left) {
        prev_right = part->right_key();
        part_it.forward();
        part = part_it.data();
      }
      int part_left = part->left_key();
      int part_right = part->right_key();
      if (part_right < col_left || col_right < part_left) {
        // There is no overlap so this is a new partition.
        AddPartition(col_part->ShallowCopy(), &part_it);
        continue;
      }
      // Check the edges of col_part to see if they can improve part.
      bool part_width_ok = cb(part->KeyWidth(part_left, part_right));
      if (col_left < part_left && col_left > prev_right) {
        // The left edge of the column is better and it doesn't overlap,
        // so we can potentially expand it.
        int col_box_left = col_part->BoxLeftKey();
        bool tab_width_ok = cb(part->KeyWidth(col_left, part_right));
        bool box_width_ok = cb(part->KeyWidth(col_box_left, part_right));
        if (tab_width_ok || (!part_width_ok)) {
          // The tab is leaving the good column metric at least as good as
          // it was before, so use the tab.
          part->CopyLeftTab(*col_part, false);
          part->SetColumnGoodness(cb);
        } else if (col_box_left < part_left &&
                   (box_width_ok || !part_width_ok)) {
          // The box is leaving the good column metric at least as good as
          // it was before, so use the box.
          part->CopyLeftTab(*col_part, true);
          part->SetColumnGoodness(cb);
        }
        part_left = part->left_key();
      }
      if (col_right > part_right &&
          (part_it.at_last() ||
           part_it.data_relative(1)->left_key() > col_right)) {
        // The right edge is better, so we can possibly expand it.
        int col_box_right = col_part->BoxRightKey();
        bool tab_width_ok = cb(part->KeyWidth(part_left, col_right));
        bool box_width_ok = cb(part->KeyWidth(part_left, col_box_right));
        if (tab_width_ok || (!part_width_ok)) {
          // The tab is leaving the good column metric at least as good as
          // it was before, so use the tab.
          part->CopyRightTab(*col_part, false);
          part->SetColumnGoodness(cb);
        } else if (col_box_right > part_right &&
                   (box_width_ok || !part_width_ok)) {
          // The box is leaving the good column metric at least as good as
          // it was before, so use the box.
          part->CopyRightTab(*col_part, true);
          part->SetColumnGoodness(cb);
        }
      }
    }
  }
  ComputeCoverage();
}

LegalColumnCandidate()

bool tesseract::ColPartitionSet::LegalColumnCandidate

(

)

Definition at line 343 of file colpartitionset.cpp.

                                           {
  ColPartition_IT it(&parts_);
  if (it.empty()) {
    return false;
  }
  bool any_text_parts = false;
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    if (BLOBNBOX::IsTextType(part->blob_type())) {
      if (!part->IsLegal()) {
        return false; // Individual partition is illegal.
      }
      any_text_parts = true;
    }
    if (!it.at_last()) {
      ColPartition *next_part = it.data_relative(1);
      if (next_part->left_key() < part->right_key()) {
        return false;
      }
    }
  }
  return any_text_parts;
}

Print()

void tesseract::ColPartitionSet::Print

(

)

Definition at line 609 of file colpartitionset.cpp.

                            {
  ColPartition_IT it(&parts_);
  tprintf(
      "Partition set of %d parts, %d good, coverage=%d+%d"
      " (%d,%d)->(%d,%d)\n",
      it.length(), good_column_count_, good_coverage_, bad_coverage_,
      bounding_box_.left(), bounding_box_.bottom(), bounding_box_.right(),
      bounding_box_.top());
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    part->Print();
  }
}

RelinquishParts()

void tesseract::ColPartitionSet::RelinquishParts

(

)

Definition at line 84 of file colpartitionset.cpp.

                                      {
  ColPartition_IT it(&parts_);
  while (!it.empty()) {
    it.extract();
    it.forward();
  }
}

SpanningType()

ColumnSpanningType tesseract::ColPartitionSet::SpanningType	(	int	resolution,
		int	left,
		int	right,
		int	height,
		int	y,
		int	left_margin,
		int	right_margin,
		int *	first_col,
		int *	last_col,
		int *	first_spanned_col
	)

Definition at line 423 of file colpartitionset.cpp.

                                                                             {
  *first_col = -1;
  *last_col = -1;
  *first_spanned_col = -1;
  int margin_columns = 0;
  ColPartition_IT it(&parts_);
  int col_index = 1;
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward(), col_index += 2) {
    ColPartition *part = it.data();
    if (part->ColumnContains(left, y) ||
        (it.at_first() && part->ColumnContains(left + height, y))) {
      // In the default case, first_col is set, but columns_spanned remains
      // zero, so first_col will get reset in the first column genuinely
      // spanned, but we can tell the difference from a noise partition
      // that touches no column.
      *first_col = col_index;
      if (part->ColumnContains(right, y) ||
          (it.at_last() && part->ColumnContains(right - height, y))) {
        // Both within a single column.
        *last_col = col_index;
        return CST_FLOWING;
      }
      if (left_margin <= part->LeftAtY(y)) {
        // It completely spans this column.
        *first_spanned_col = col_index;
        margin_columns = 1;
      }
    } else if (part->ColumnContains(right, y) ||
               (it.at_last() && part->ColumnContains(right - height, y))) {
      if (*first_col < 0) {
        // It started in-between.
        *first_col = col_index - 1;
      }
      if (right_margin >= part->RightAtY(y)) {
        // It completely spans this column.
        if (margin_columns == 0) {
          *first_spanned_col = col_index;
        }
        ++margin_columns;
      }
      *last_col = col_index;
      break;
    } else if (left < part->LeftAtY(y) && right > part->RightAtY(y)) {
      // Neither left nor right are contained within, so it spans this
      // column.
      if (*first_col < 0) {
        // It started in between the previous column and the current column.
        *first_col = col_index - 1;
      }
      if (margin_columns == 0) {
        *first_spanned_col = col_index;
      }
      *last_col = col_index;
    } else if (right < part->LeftAtY(y)) {
      // We have gone past the end.
      *last_col = col_index - 1;
      if (*first_col < 0) {
        // It must lie completely between columns =>noise.
        *first_col = col_index - 1;
      }
      break;
    }
  }
  if (*first_col < 0) {
    *first_col = col_index - 1; // The last in-between.
  }
  if (*last_col < 0) {
    *last_col = col_index - 1; // The last in-between.
  }
  ASSERT_HOST(*first_col >= 0 && *last_col >= 0);
  ASSERT_HOST(*first_col <= *last_col);
  if (*first_col == *last_col && right - left < kMinColumnWidth * resolution) {
    // Neither end was in a column, and it didn't span any, so it lies
    // entirely between columns, therefore noise.
    return CST_NOISE;
  } else if (margin_columns <= 1) {
    // An exception for headings that stick outside of single-column text.
    if (margin_columns == 1 && parts_.singleton()) {
      return CST_HEADING;
    }
    // It is a pullout, as left and right were not in the same column, but
    // it doesn't go to the edge of its start and end.
    return CST_PULLOUT;
  }
  // Its margins went to the edges of first and last columns => heading.
  return CST_HEADING;
}

UnmatchedWidth()

int tesseract::ColPartitionSet::UnmatchedWidth

(

ColPartitionSet *

part_set

)

Definition at line 317 of file colpartitionset.cpp.

                                                             {
  int total_width = 0;
  ColPartition_IT it(&part_set->parts_);
  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
    ColPartition *part = it.data();
    if (!BLOBNBOX::IsTextType(part->blob_type())) {
      continue; // Non-text partitions are irrelevant to column compatibility.
    }
    int y = part->MidY();
    BLOBNBOX_C_IT box_it(part->boxes());
    for (box_it.mark_cycle_pt(); !box_it.cycled_list(); box_it.forward()) {
      const TBOX &box = it.data()->bounding_box();
      // Assume that the whole blob is outside any column iff its x-middle
      // is outside.
      int x = (box.left() + box.right()) / 2;
      ColPartition *col = ColumnContaining(x, y);
      if (col == nullptr) {
        total_width += box.width();
      }
    }
  }
  return total_width;
}

---

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

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