tesseract::FPRow Class Reference

Public Member Functions
	FPRow ()
	~FPRow ()=default
void	Init (TO_ROW *row)
void	EstimatePitch (bool pass1)
void	Pass1Analyze ()
bool	Pass2Analyze ()
void	MergeFragments ()
void	FinalizeLargeChars ()
void	OutputEstimations ()
void	DebugOutputResult (int row_index)
int	good_pitches ()
float	pitch ()
float	estimated_pitch ()
void	set_estimated_pitch (float v)
float	height ()
float	height_pitch_ratio ()
float	gap ()
size_t	num_chars ()
FPChar *	character (int i)
const TBOX &	box (int i)
const TBOX &	real_body (int i)
bool	is_box_modified (int i)
float	center_x (int i)
bool	is_final (int i)
void	finalize (int i)
bool	is_good (int i)
void	mark_good (int i)
void	mark_bad (int i)
void	clear_alignment (int i)

Detailed Description

Definition at line 288 of file cjkpitch.cpp.

Constructor & Destructor Documentation

FPRow()

tesseract::FPRow::FPRow ( )

inline

Definition at line 290 of file cjkpitch.cpp.

: all_pitches_(), all_gaps_(), good_pitches_(), good_gaps_(), heights_(), characters_() {}

~FPRow()

tesseract::FPRow::~FPRow ( )

default

Member Function Documentation

box()

const TBOX & tesseract::FPRow::box ( int  i )

inline

Definition at line 366 of file cjkpitch.cpp.

                         {
    return characters_[i].box();
  }

center_x()

float tesseract::FPRow::center_x ( int  i )

inline

Definition at line 378 of file cjkpitch.cpp.

                        {
    return (characters_[i].box().left() + characters_[i].box().right()) / 2.0;
  }

character()

FPChar * tesseract::FPRow::character ( int  i )

inline

Definition at line 362 of file cjkpitch.cpp.

                           {
    return &characters_[i];
  }

clear_alignment()

void tesseract::FPRow::clear_alignment ( int  i )

inline

Definition at line 402 of file cjkpitch.cpp.

                              {
    characters_[i].set_alignment(FPChar::ALIGN_UNKNOWN);
  }

DebugOutputResult()

void tesseract::FPRow::DebugOutputResult

(

int

row_index

)

Definition at line 686 of file cjkpitch.cpp.

                                           {
  if (num_chars() > 0) {
    tprintf(
        "Row %d: pitch_decision=%d, fixed_pitch=%f, max_nonspace=%d, "
        "space_size=%f, space_threshold=%d, xheight=%f\n",
        row_index, static_cast<int>(real_row_->pitch_decision), real_row_->fixed_pitch,
        real_row_->max_nonspace, real_row_->space_size, real_row_->space_threshold,
        real_row_->xheight);
 
    for (unsigned i = 0; i < num_chars(); i++) {
      tprintf("Char %u: is_final=%d is_good=%d num_blobs=%d: ", i, is_final(i), is_good(i),
              character(i)->num_blobs());
      box(i).print();
    }
  }
}

estimated_pitch()

float tesseract::FPRow::estimated_pitch ( )

inline

Definition at line 336 of file cjkpitch.cpp.

                          {
    return estimated_pitch_;
  }

EstimatePitch()

void tesseract::FPRow::EstimatePitch

(

bool

pass1

)

Definition at line 615 of file cjkpitch.cpp.

                                    {
  good_pitches_.Clear();
  all_pitches_.Clear();
  good_gaps_.Clear();
  all_gaps_.Clear();
  heights_.Clear();
  if (num_chars() == 0) {
    return;
  }
 
  int32_t cx0, cx1;
  bool prev_was_good = is_good(0);
  cx0 = center_x(0);
 
  heights_.Add(box(0).height());
  for (size_t i = 1; i < num_chars(); i++) {
    cx1 = center_x(i);
    int32_t pitch = cx1 - cx0;
    int32_t gap = std::max(0, real_body(i - 1).x_gap(real_body(i)));
 
    heights_.Add(box(i).height());
    // Ignore if the pitch is too close.  But don't ignore wide pitch
    // may be the result of large tracking.
    if (pitch > height_ * 0.5) {
      all_pitches_.Add(pitch);
      all_gaps_.Add(gap);
      if (is_good(i)) {
        // In pass1 (after Pass1Analyze()), all characters marked as
        // "good" have a good consistent pitch with their previous
        // characters.  However, it's not true in pass2 and a good
        // character may have a good pitch only between its successor.
        // So we collect only pitch values between two good
        // characters. and within tolerance in pass2.
        if (pass1 ||
            (prev_was_good && std::fabs(estimated_pitch_ - pitch) < kFPTolerance * estimated_pitch_)) {
          good_pitches_.Add(pitch);
          if (!is_box_modified(i - 1) && !is_box_modified(i)) {
            good_gaps_.Add(gap);
          }
        }
        prev_was_good = true;
      } else {
        prev_was_good = false;
      }
    }
    cx0 = cx1;
  }
 
  good_pitches_.Finish();
  all_pitches_.Finish();
  good_gaps_.Finish();
  all_gaps_.Finish();
  heights_.Finish();
 
  height_ = heights_.ile(0.875);
  if (all_pitches_.empty()) {
    pitch_ = 0.0f;
    gap_ = 0.0f;
  } else if (good_pitches_.size() < 2) {
    // We don't have enough data to estimate the pitch of this row yet.
    // Use median of all pitches as the initial guess.
    pitch_ = all_pitches_.median();
    ASSERT_HOST(pitch_ > 0.0f);
    gap_ = all_gaps_.ile(0.125);
  } else {
    pitch_ = good_pitches_.median();
    ASSERT_HOST(pitch_ > 0.0f);
    gap_ = good_gaps_.ile(0.125);
  }
}

finalize()

void tesseract::FPRow::finalize ( int  i )

inline

Definition at line 386 of file cjkpitch.cpp.

                       {
    characters_[i].set_final(true);
  }

FinalizeLargeChars()

void tesseract::FPRow::FinalizeLargeChars

(

)

Definition at line 870 of file cjkpitch.cpp.

                               {
  float row_pitch = estimated_pitch();
  for (size_t i = 0; i < num_chars(); i++) {
    if (is_final(i)) {
      continue;
    }
 
    // Finalize if both neighbors are finalized. We have no other choice.
    if (i > 0 && is_final(i - 1) && i < num_chars() - 1 && is_final(i + 1)) {
      finalize(i);
      continue;
    }
 
    float cx = center_x(i);
    TBOX ibody(cx - 0.5 * row_pitch, 0, cx + 0.5 * row_pitch, 1);
    if (i > 0) {
      // The preceding character significantly intersects with the
      // imaginary body of this character. Let Pass2Analyze() handle
      // this case.
      if (x_overlap_fraction(ibody, box(i - 1)) > 0.1) {
        continue;
      }
      if (!is_final(i - 1)) {
        TBOX merged = box(i);
        merged += box(i - 1);
        if (merged.width() < row_pitch) {
          continue;
        }
        // This character cannot be finalized yet because it can be
        // merged with the previous one.  Again, let Pass2Analyze()
        // handle this case.
      }
    }
    if (i < num_chars() - 1) {
      if (x_overlap_fraction(ibody, box(i + 1)) > 0.1) {
        continue;
      }
      if (!is_final(i + 1)) {
        TBOX merged = box(i);
        merged += box(i + 1);
        if (merged.width() < row_pitch) {
          continue;
        }
      }
    }
    finalize(i);
  }
 
  // Update alignment decision.  We only consider finalized characters
  // in pass2.  E.g. if a finalized character C has another finalized
  // character L on its left and a not-finalized character R on its
  // right, we mark C as good if the pitch between C and L is good,
  // regardless of the pitch between C and R.
  for (size_t i = 0; i < num_chars(); i++) {
    if (!is_final(i)) {
      continue;
    }
    bool good_pitch = false;
    bool bad_pitch = false;
    if (i > 0 && is_final(i - 1)) {
      if (is_good_pitch(row_pitch, box(i - 1), box(i))) {
        good_pitch = true;
      } else {
        bad_pitch = true;
      }
    }
    if (i < num_chars() - 1 && is_final(i + 1)) {
      if (is_good_pitch(row_pitch, box(i), box(i + 1))) {
        good_pitch = true;
      } else {
        bad_pitch = true;
      }
    }
    if (good_pitch && !bad_pitch) {
      mark_good(i);
    } else if (!good_pitch && bad_pitch) {
      mark_bad(i);
    }
  }
}

gap()

float tesseract::FPRow::gap ( )

inline

Definition at line 355 of file cjkpitch.cpp.

              {
    return gap_;
  }

good_pitches()

int tesseract::FPRow::good_pitches ( )

inline

Definition at line 328 of file cjkpitch.cpp.

                     {
    return good_pitches_.size();
  }

height()

float tesseract::FPRow::height ( )

inline

Definition at line 344 of file cjkpitch.cpp.

                 {
    return height_;
  }

height_pitch_ratio()

float tesseract::FPRow::height_pitch_ratio ( )

inline

Definition at line 348 of file cjkpitch.cpp.

                             {
    if (good_pitches_.size() < 2) {
      return -1.0;
    }
    return height_ / good_pitches_.median();
  }

Init()

void tesseract::FPRow::Init

(

TO_ROW *

row

)

Definition at line 496 of file cjkpitch.cpp.

                            {
  ASSERT_HOST(row != nullptr);
  ASSERT_HOST(row->xheight > 0);
  real_row_ = row;
  real_row_->pitch_decision = PITCH_CORR_PROP; // Default decision.
 
  BLOBNBOX_IT blob_it = row->blob_list();
  // Initialize characters_ and compute the initial estimation of
  // character height.
  for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
    if (is_interesting_blob(blob_it.data())) {
      FPChar fp_char;
      fp_char.Init(blob_it.data());
      // Merge unconditionally if two blobs overlap.
      if (!characters_.empty() && significant_overlap(fp_char.box(), characters_.back().box())) {
        characters_.back().Merge(fp_char);
      } else {
        characters_.push_back(fp_char);
      }
      TBOX bound = blob_it.data()->bounding_box();
      if (bound.height() * 3.0 > bound.width()) {
        heights_.Add(bound.height());
      }
    }
  }
  heights_.Finish();
  height_ = heights_.ile(0.875);
}

is_box_modified()

bool tesseract::FPRow::is_box_modified ( int  i )

inline

Definition at line 374 of file cjkpitch.cpp.

                              {
    return !(characters_[i].box() == characters_[i].real_body());
  }

is_final()

bool tesseract::FPRow::is_final ( int  i )

inline

Definition at line 382 of file cjkpitch.cpp.

                       {
    return characters_[i].is_final();
  }

is_good()

bool tesseract::FPRow::is_good ( int  i )

inline

Definition at line 390 of file cjkpitch.cpp.

                      {
    return characters_[i].alignment() == FPChar::ALIGN_GOOD;
  }

mark_bad()

void tesseract::FPRow::mark_bad ( int  i )

inline

Definition at line 398 of file cjkpitch.cpp.

                       {
    characters_[i].set_alignment(FPChar::ALIGN_BAD);
  }

mark_good()

void tesseract::FPRow::mark_good ( int  i )

inline

Definition at line 394 of file cjkpitch.cpp.

                        {
    characters_[i].set_alignment(FPChar::ALIGN_GOOD);
  }

MergeFragments()

void tesseract::FPRow::MergeFragments

(

)

Definition at line 854 of file cjkpitch.cpp.

                           {
  int last_char = 0;
 
  for (size_t j = 0; j < num_chars(); ++j) {
    if (character(j)->merge_to_prev()) {
      character(last_char)->Merge(*character(j));
      character(j)->set_delete_flag(true);
      clear_alignment(last_char);
      character(j - 1)->set_merge_to_prev(false);
    } else {
      last_char = j;
    }
  }
  DeleteChars();
}

num_chars()

size_t tesseract::FPRow::num_chars ( )

inline

Definition at line 359 of file cjkpitch.cpp.

                     {
    return characters_.size();
  }

OutputEstimations()

void tesseract::FPRow::OutputEstimations

(

)

Definition at line 525 of file cjkpitch.cpp.

                              {
  if (good_pitches_.empty()) {
    pitch_ = 0.0f;
    real_row_->pitch_decision = PITCH_CORR_PROP;
    return;
  }
 
  pitch_ = good_pitches_.median();
  real_row_->fixed_pitch = pitch_;
  // good_gaps_.ile(0.125) can be large if most characters on the row
  // are skinny. Use pitch_ - height_ instead if it's smaller, but
  // positive.
  real_row_->kern_size = real_row_->pr_nonsp =
      std::min(good_gaps_.ile(0.125), std::max(pitch_ - height_, 0.0f));
  real_row_->body_size = pitch_ - real_row_->kern_size;
 
  if (good_pitches_.size() < all_pitches_.size() * kFixedPitchThreshold) {
    // If more than half of the characters of a line don't fit to the
    // fixed pitch model, consider the line to be proportional. 50%
    // seems to be a good threshold in practice as well.
    // Anyway we store estimated values (fixed_pitch, kern_size, etc.) in
    // real_row_ as a partial estimation result and try to use them in the
    // normalization process.
    real_row_->pitch_decision = PITCH_CORR_PROP;
    return;
  } else if (good_pitches_.size() > all_pitches_.size() * 0.75) {
    real_row_->pitch_decision = PITCH_DEF_FIXED;
  } else {
    real_row_->pitch_decision = PITCH_CORR_FIXED;
  }
 
  real_row_->space_size = real_row_->pr_space = pitch_;
  // Set min_space to 50% of character pitch so that we can break CJK
  // text at a half-width space after punctuation.
  real_row_->min_space = (pitch_ + good_gaps_.minimum()) * 0.5;
 
  // Don't consider a quarter space as a real space, because it's used
  // for line justification in traditional Japanese books.
  real_row_->max_nonspace =
      std::max(pitch_ * 0.25 + good_gaps_.minimum(), static_cast<double>(good_gaps_.ile(0.875)));
 
  int space_threshold = std::min((real_row_->max_nonspace + real_row_->min_space) / 2,
                                 static_cast<int>(real_row_->xheight));
 
  // Make max_nonspace larger than any intra-character gap so that
  // make_prop_words() won't break a row at the middle of a character.
  for (size_t i = 0; i < num_chars(); ++i) {
    if (characters_[i].max_gap() > real_row_->max_nonspace) {
      real_row_->max_nonspace = characters_[i].max_gap();
    }
  }
  real_row_->space_threshold = std::min((real_row_->max_nonspace + real_row_->min_space) / 2,
                                        static_cast<int>(real_row_->xheight));
  real_row_->used_dm_model = false;
 
  // Setup char_cells.
  ICOORDELT_IT cell_it = &real_row_->char_cells;
  auto *cell = new ICOORDELT(real_body(0).left(), 0);
  cell_it.add_after_then_move(cell);
 
  int right = real_body(0).right();
  for (size_t i = 1; i < num_chars(); ++i) {
    // Put a word break if gap between two characters is bigger than
    // space_threshold.  Don't break if none of two characters
    // couldn't be "finalized", because maybe they need to be merged
    // to one character.
    if ((is_final(i - 1) || is_final(i)) &&
        real_body(i - 1).x_gap(real_body(i)) > space_threshold) {
      cell = new ICOORDELT(right + 1, 0);
      cell_it.add_after_then_move(cell);
      while (right + pitch_ < box(i).left()) {
        right += pitch_;
        cell = new ICOORDELT(right + 1, 0);
        cell_it.add_after_then_move(cell);
      }
      right = box(i).left();
    }
    cell = new ICOORDELT((right + real_body(i).left()) / 2, 0);
    cell_it.add_after_then_move(cell);
    right = real_body(i).right();
  }
 
  cell = new ICOORDELT(right + 1, 0);
  cell_it.add_after_then_move(cell);
 
  // TODO(takenaka): add code to store alignment/fragmentation
  // information to blobs so that it can be reused later, e.g. in
  // recognition phase.
}

Pass1Analyze()

void tesseract::FPRow::Pass1Analyze

(

)

Definition at line 703 of file cjkpitch.cpp.

                         {
  if (num_chars() < 2) {
    return;
  }
 
  if (estimated_pitch_ > 0.0f) {
    for (size_t i = 2; i < num_chars(); i++) {
      if (is_good_pitch(estimated_pitch_, box(i - 2), box(i - 1)) &&
          is_good_pitch(estimated_pitch_, box(i - 1), box(i))) {
        mark_good(i - 1);
      }
    }
  } else {
    for (size_t i = 2; i < num_chars(); i++) {
      if (is_good_pitch(box_pitch(box(i - 2), box(i - 1)), box(i - 1), box(i))) {
        mark_good(i - 1);
      }
    }
  }
  character(0)->set_alignment(character(1)->alignment());
  character(num_chars() - 1)->set_alignment(character(num_chars() - 2)->alignment());
}

Pass2Analyze()

bool tesseract::FPRow::Pass2Analyze

(

)

Definition at line 726 of file cjkpitch.cpp.

                         {
  bool changed = false;
  if (num_chars() <= 1 || estimated_pitch_ == 0.0f) {
    return false;
  }
  for (size_t i = 0; i < num_chars(); i++) {
    if (is_final(i)) {
      continue;
    }
 
    FPChar::Alignment alignment = character(i)->alignment();
    bool intersecting = false;
    bool not_intersecting = false;
 
    if (i < num_chars() - 1 && is_final(i + 1)) {
      // Next character is already finalized. Estimate the imaginary
      // body including this character based on the character. Skip
      // whitespace if necessary.
      bool skipped_whitespaces = false;
      float c1 = center_x(i + 1) - 1.5 * estimated_pitch_;
      while (c1 > box(i).right()) {
        skipped_whitespaces = true;
        c1 -= estimated_pitch_;
      }
      TBOX ibody(c1, box(i).bottom(), c1 + estimated_pitch_, box(i).top());
 
      // Collect all characters that mostly fit in the region.
      // Also, their union height shouldn't be too big.
      int j = i;
      TBOX merged;
      while (j >= 0 && !is_final(j) && mostly_overlap(ibody, box(j)) &&
             merged.bounding_union(box(j)).height() < estimated_pitch_ * (1 + kFPTolerance)) {
        merged += box(j);
        j--;
      }
 
      if (j >= 0 && significant_overlap(ibody, box(j))) {
        // character(j) lies on the character boundary and doesn't fit
        // well into the imaginary body.
        if (!is_final(j)) {
          intersecting = true;
        }
      } else {
        not_intersecting = true;
        if (i - j > 0) {
          // Merge character(j+1) ... character(i) because they fit
          // into the body nicely.
          if (i - j == 1) {
            // Only one char in the imaginary body.
            if (!skipped_whitespaces) {
              mark_good(i);
            }
            // set ibody as bounding box of this character to get
            // better pitch analysis result for halfwidth glyphs
            // followed by a halfwidth space.
            if (box(i).width() <= estimated_pitch_ * 0.5) {
              ibody += box(i);
              character(i)->set_box(ibody);
            }
            character(i)->set_merge_to_prev(false);
            finalize(i);
          } else {
            for (int k = i; k > j + 1; k--) {
              character(k)->set_merge_to_prev(true);
            }
          }
        }
      }
    }
    if (i > 0 && is_final(i - 1)) {
      // Now we repeat everything from the opposite side.  Previous
      // character is already finalized. Estimate the imaginary body
      // including this character based on the character.
      bool skipped_whitespaces = false;
      float c1 = center_x(i - 1) + 1.5 * estimated_pitch_;
      while (c1 < box(i).left()) {
        skipped_whitespaces = true;
        c1 += estimated_pitch_;
      }
      TBOX ibody(c1 - estimated_pitch_, box(i).bottom(), c1, box(i).top());
 
      size_t j = i;
      TBOX merged;
      while (j < num_chars() && !is_final(j) && mostly_overlap(ibody, box(j)) &&
             merged.bounding_union(box(j)).height() < estimated_pitch_ * (1 + kFPTolerance)) {
        merged += box(j);
        j++;
      }
 
      if (j < num_chars() && significant_overlap(ibody, box(j))) {
        if (!is_final(j)) {
          intersecting = true;
        }
      } else {
        not_intersecting = true;
        if (j - i > 0) {
          if (j - i == 1) {
            if (!skipped_whitespaces) {
              mark_good(i);
            }
            if (box(i).width() <= estimated_pitch_ * 0.5) {
              ibody += box(i);
              character(i)->set_box(ibody);
            }
            character(i)->set_merge_to_prev(false);
            finalize(i);
          } else {
            for (size_t k = i + 1; k < j; k++) {
              character(k)->set_merge_to_prev(true);
            }
          }
        }
      }
    }
 
    // This character doesn't fit well into the estimated imaginary
    // bodies. Mark it as bad.
    if (intersecting && !not_intersecting) {
      mark_bad(i);
    }
    if (character(i)->alignment() != alignment || character(i)->merge_to_prev()) {
      changed = true;
    }
  }
 
  return changed;
}

pitch()

float tesseract::FPRow::pitch ( )

inline

Definition at line 332 of file cjkpitch.cpp.

                {
    return pitch_;
  }

real_body()

const TBOX & tesseract::FPRow::real_body ( int  i )

inline

Definition at line 370 of file cjkpitch.cpp.

                               {
    return characters_[i].real_body();
  }

set_estimated_pitch()

void tesseract::FPRow::set_estimated_pitch ( float  v )

inline

Definition at line 340 of file cjkpitch.cpp.

                                    {
    estimated_pitch_ = v;
  }

---

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

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