///////////////////////////////////////////////////////////////////////
// File:        textord.cpp
// Description: The top-level text line and word finding functionality.
// Author:      Ray Smith
// Created:     Fri Mar 13 14:43:01 PDT 2009
//
// (C) Copyright 2009, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////

// Include automatically generated configuration file if running autoconf.
#ifdef HAVE_CONFIG_H
#  include "config_auto.h"
#endif

#include "baselinedetect.h"
#include "drawtord.h"
#include "makerow.h"
#include "pageres.h"
#include "textord.h"
#include "tordmain.h"
#include "wordseg.h"

namespace tesseract {

Textord::Textord(CCStruct *ccstruct)
    : ccstruct_(ccstruct)
    , use_cjk_fp_model_(false)
    ,
    // makerow.cpp ///////////////////////////////////////////
    BOOL_MEMBER(textord_single_height_mode, false, "Script has no xheight, so use a single mode",
                ccstruct_->params())
    ,
    // tospace.cpp ///////////////////////////////////////////
    BOOL_MEMBER(tosp_old_to_method, false, "Space stats use prechopping?", ccstruct_->params())
    , BOOL_MEMBER(tosp_old_to_constrain_sp_kn, false,
                  "Constrain relative values of inter and intra-word gaps for "
                  "old_to_method.",
                  ccstruct_->params())
    , BOOL_MEMBER(tosp_only_use_prop_rows, true, "Block stats to use fixed pitch rows?",
                  ccstruct_->params())
    , BOOL_MEMBER(tosp_force_wordbreak_on_punct, false,
                  "Force word breaks on punct to break long lines in non-space "
                  "delimited langs",
                  ccstruct_->params())
    , BOOL_MEMBER(tosp_use_pre_chopping, false, "Space stats use prechopping?", ccstruct_->params())
    , BOOL_MEMBER(tosp_old_to_bug_fix, false, "Fix suspected bug in old code", ccstruct_->params())
    , BOOL_MEMBER(tosp_block_use_cert_spaces, true, "Only stat OBVIOUS spaces", ccstruct_->params())
    , BOOL_MEMBER(tosp_row_use_cert_spaces, true, "Only stat OBVIOUS spaces", ccstruct_->params())
    , BOOL_MEMBER(tosp_narrow_blobs_not_cert, true, "Only stat OBVIOUS spaces", ccstruct_->params())
    , BOOL_MEMBER(tosp_row_use_cert_spaces1, true, "Only stat OBVIOUS spaces", ccstruct_->params())
    , BOOL_MEMBER(tosp_recovery_isolated_row_stats, true,
                  "Use row alone when inadequate cert spaces", ccstruct_->params())
    , BOOL_MEMBER(tosp_only_small_gaps_for_kern, false, "Better guess", ccstruct_->params())
    , BOOL_MEMBER(tosp_all_flips_fuzzy, false, "Pass ANY flip to context?", ccstruct_->params())
    , BOOL_MEMBER(tosp_fuzzy_limit_all, true, "Don't restrict kn->sp fuzzy limit to tables",
                  ccstruct_->params())
    , BOOL_MEMBER(tosp_stats_use_xht_gaps, true, "Use within xht gap for wd breaks",
                  ccstruct_->params())
    , BOOL_MEMBER(tosp_use_xht_gaps, true, "Use within xht gap for wd breaks", ccstruct_->params())
    , BOOL_MEMBER(tosp_only_use_xht_gaps, false, "Only use within xht gap for wd breaks",
                  ccstruct_->params())
    , BOOL_MEMBER(tosp_rule_9_test_punct, false, "Don't chng kn to space next to punct",
                  ccstruct_->params())
    , BOOL_MEMBER(tosp_flip_fuzz_kn_to_sp, true, "Default flip", ccstruct_->params())
    , BOOL_MEMBER(tosp_flip_fuzz_sp_to_kn, true, "Default flip", ccstruct_->params())
    , BOOL_MEMBER(tosp_improve_thresh, false, "Enable improvement heuristic", ccstruct_->params())
    , INT_MEMBER(tosp_debug_level, 0, "Debug data", ccstruct_->params())
    , INT_MEMBER(tosp_enough_space_samples_for_median, 3, "or should we use mean",
                 ccstruct_->params())
    , INT_MEMBER(tosp_redo_kern_limit, 10, "No.samples reqd to reestimate for row",
                 ccstruct_->params())
    , INT_MEMBER(tosp_few_samples, 40, "No.gaps reqd with 1 large gap to treat as a table",
                 ccstruct_->params())
    , INT_MEMBER(tosp_short_row, 20, "No.gaps reqd with few cert spaces to use certs",
                 ccstruct_->params())
    , INT_MEMBER(tosp_sanity_method, 1, "How to avoid being silly", ccstruct_->params())
    , double_MEMBER(tosp_old_sp_kn_th_factor, 2.0,
                    "Factor for defining space threshold in terms of space and "
                    "kern sizes",
                    ccstruct_->params())
    , double_MEMBER(tosp_threshold_bias1, 0, "how far between kern and space?", ccstruct_->params())
    , double_MEMBER(tosp_threshold_bias2, 0, "how far between kern and space?", ccstruct_->params())
    , double_MEMBER(tosp_narrow_fraction, 0.3, "Fract of xheight for narrow", ccstruct_->params())
    , double_MEMBER(tosp_narrow_aspect_ratio, 0.48, "narrow if w/h less than this",
                    ccstruct_->params())
    , double_MEMBER(tosp_wide_fraction, 0.52, "Fract of xheight for wide", ccstruct_->params())
    , double_MEMBER(tosp_wide_aspect_ratio, 0.0, "wide if w/h less than this", ccstruct_->params())
    , double_MEMBER(tosp_fuzzy_space_factor, 0.6, "Fract of xheight for fuzz sp",
                    ccstruct_->params())
    , double_MEMBER(tosp_fuzzy_space_factor1, 0.5, "Fract of xheight for fuzz sp",
                    ccstruct_->params())
    , double_MEMBER(tosp_fuzzy_space_factor2, 0.72, "Fract of xheight for fuzz sp",
                    ccstruct_->params())
    , double_MEMBER(tosp_gap_factor, 0.83, "gap ratio to flip sp->kern", ccstruct_->params())
    , double_MEMBER(tosp_kern_gap_factor1, 2.0, "gap ratio to flip kern->sp", ccstruct_->params())
    , double_MEMBER(tosp_kern_gap_factor2, 1.3, "gap ratio to flip kern->sp", ccstruct_->params())
    , double_MEMBER(tosp_kern_gap_factor3, 2.5, "gap ratio to flip kern->sp", ccstruct_->params())
    , double_MEMBER(tosp_ignore_big_gaps, -1, "xht multiplier", ccstruct_->params())
    , double_MEMBER(tosp_ignore_very_big_gaps, 3.5, "xht multiplier", ccstruct_->params())
    , double_MEMBER(tosp_rep_space, 1.6, "rep gap multiplier for space", ccstruct_->params())
    , double_MEMBER(tosp_enough_small_gaps, 0.65, "Fract of kerns reqd for isolated row stats",
                    ccstruct_->params())
    , double_MEMBER(tosp_table_kn_sp_ratio, 2.25, "Min difference of kn & sp in table",
                    ccstruct_->params())
    , double_MEMBER(tosp_table_xht_sp_ratio, 0.33, "Expect spaces bigger than this",
                    ccstruct_->params())
    , double_MEMBER(tosp_table_fuzzy_kn_sp_ratio, 3.0, "Fuzzy if less than this",
                    ccstruct_->params())
    , double_MEMBER(tosp_fuzzy_kn_fraction, 0.5, "New fuzzy kn alg", ccstruct_->params())
    , double_MEMBER(tosp_fuzzy_sp_fraction, 0.5, "New fuzzy sp alg", ccstruct_->params())
    , double_MEMBER(tosp_min_sane_kn_sp, 1.5, "Don't trust spaces less than this time kn",
                    ccstruct_->params())
    , double_MEMBER(tosp_init_guess_kn_mult, 2.2, "Thresh guess - mult kn by this",
                    ccstruct_->params())
    , double_MEMBER(tosp_init_guess_xht_mult, 0.28, "Thresh guess - mult xht by this",
                    ccstruct_->params())
    , double_MEMBER(tosp_max_sane_kn_thresh, 5.0, "Multiplier on kn to limit thresh",
                    ccstruct_->params())
    , double_MEMBER(tosp_flip_caution, 0.0, "Don't autoflip kn to sp when large separation",
                    ccstruct_->params())
    , double_MEMBER(tosp_large_kerning, 0.19, "Limit use of xht gap with large kns",
                    ccstruct_->params())
    , double_MEMBER(tosp_dont_fool_with_small_kerns, -1, "Limit use of xht gap with odd small kns",
                    ccstruct_->params())
    , double_MEMBER(tosp_near_lh_edge, 0, "Don't reduce box if the top left is non blank",
                    ccstruct_->params())
    , double_MEMBER(tosp_silly_kn_sp_gap, 0.2, "Don't let sp minus kn get too small",
                    ccstruct_->params())
    , double_MEMBER(tosp_pass_wide_fuzz_sp_to_context, 0.75, "How wide fuzzies need context",
                    ccstruct_->params())
    ,
    // tordmain.cpp ///////////////////////////////////////////
    BOOL_MEMBER(textord_no_rejects, false, "Don't remove noise blobs", ccstruct_->params())
    , BOOL_MEMBER(textord_show_blobs, false, "Display unsorted blobs", ccstruct_->params())
    , BOOL_MEMBER(textord_show_boxes, false, "Display unsorted blobs", ccstruct_->params())
    , INT_MEMBER(textord_max_noise_size, 7, "Pixel size of noise", ccstruct_->params())
    , INT_MEMBER(textord_baseline_debug, 0, "Baseline debug level", ccstruct_->params())
    , double_MEMBER(textord_noise_area_ratio, 0.7, "Fraction of bounding box for noise",
                    ccstruct_->params())
    , double_MEMBER(textord_initialx_ile, 0.75, "Ile of sizes for xheight guess",
                    ccstruct_->params())
    , double_MEMBER(textord_initialasc_ile, 0.90, "Ile of sizes for xheight guess",
                    ccstruct_->params())
    , INT_MEMBER(textord_noise_sizefraction, 10, "Fraction of size for maxima", ccstruct_->params())
    , double_MEMBER(textord_noise_sizelimit, 0.5, "Fraction of x for big t count",
                    ccstruct_->params())
    , INT_MEMBER(textord_noise_translimit, 16, "Transitions for normal blob", ccstruct_->params())
    , double_MEMBER(textord_noise_normratio, 2.0, "Dot to norm ratio for deletion",
                    ccstruct_->params())
    , BOOL_MEMBER(textord_noise_rejwords, true, "Reject noise-like words", ccstruct_->params())
    , BOOL_MEMBER(textord_noise_rejrows, true, "Reject noise-like rows", ccstruct_->params())
    , double_MEMBER(textord_noise_syfract, 0.2, "xh fract height error for norm blobs",
                    ccstruct_->params())
    , double_MEMBER(textord_noise_sxfract, 0.4, "xh fract width error for norm blobs",
                    ccstruct_->params())
    , double_MEMBER(textord_noise_hfract, 1.0 / 64,
                    "Height fraction to discard outlines as speckle noise", ccstruct_->params())
    , INT_MEMBER(textord_noise_sncount, 1, "super norm blobs to save row", ccstruct_->params())
    , double_MEMBER(textord_noise_rowratio, 6.0, "Dot to norm ratio for deletion",
                    ccstruct_->params())
    , BOOL_MEMBER(textord_noise_debug, false, "Debug row garbage detector", ccstruct_->params())
    , double_MEMBER(textord_blshift_maxshift, 0.00, "Max baseline shift", ccstruct_->params())
    , double_MEMBER(textord_blshift_xfraction, 9.99, "Min size of baseline shift",
                    ccstruct_->params()) {}

// Make the textlines and words inside each block.
void Textord::TextordPage(PageSegMode pageseg_mode, const FCOORD &reskew, int width, int height,
                          Image binary_pix, Image thresholds_pix, Image grey_pix, bool use_box_bottoms,
                          BLOBNBOX_LIST *diacritic_blobs, BLOCK_LIST *blocks,
                          TO_BLOCK_LIST *to_blocks) {
  page_tr_.set_x(width);
  page_tr_.set_y(height);
  if (to_blocks->empty()) {
    // AutoPageSeg was not used, so we need to find_components first.
    find_components(binary_pix, blocks, to_blocks);
    TO_BLOCK_IT it(to_blocks);
    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
      TO_BLOCK *to_block = it.data();
      // Compute the edge offsets whether or not there is a grey_pix.
      // We have by-passed auto page seg, so we have to run it here.
      // By page segmentation mode there is no non-text to avoid running on.
      to_block->ComputeEdgeOffsets(thresholds_pix, grey_pix);
    }
  } else if (!PSM_SPARSE(pageseg_mode)) {
    // AutoPageSeg does not need to find_components as it did that already.
    // Filter_blobs sets up the TO_BLOCKs the same as find_components does.
    filter_blobs(page_tr_, to_blocks, true);
  }

  ASSERT_HOST(!to_blocks->empty());
  if (pageseg_mode == PSM_SINGLE_BLOCK_VERT_TEXT) {
    const FCOORD anticlockwise90(0.0f, 1.0f);
    const FCOORD clockwise90(0.0f, -1.0f);
    TO_BLOCK_IT it(to_blocks);
    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
      TO_BLOCK *to_block = it.data();
      BLOCK *block = to_block->block;
      // Create a fake poly_block in block from its bounding box.
      block->pdblk.set_poly_block(new POLY_BLOCK(block->pdblk.bounding_box(), PT_VERTICAL_TEXT));
      // Rotate the to_block along with its contained block and blobnbox lists.
      to_block->rotate(anticlockwise90);
      // Set the block's rotation values to obey the convention followed in
      // layout analysis for vertical text.
      block->set_re_rotation(clockwise90);
      block->set_classify_rotation(clockwise90);
    }
  }

  TO_BLOCK_IT to_block_it(to_blocks);
  TO_BLOCK *to_block = to_block_it.data();
  // Make the rows in the block.
  float gradient;
  // Do it the old fashioned way.
  if (PSM_LINE_FIND_ENABLED(pageseg_mode)) {
    gradient = make_rows(page_tr_, to_blocks);
  } else if (!PSM_SPARSE(pageseg_mode)) {
    // RAW_LINE, SINGLE_LINE, SINGLE_WORD and SINGLE_CHAR all need a single row.
    gradient = make_single_row(page_tr_, pageseg_mode != PSM_RAW_LINE, to_block, to_blocks);
  } else {
    gradient = 0.0f;
  }
  BaselineDetect baseline_detector(textord_baseline_debug, reskew, to_blocks);
  baseline_detector.ComputeStraightBaselines(use_box_bottoms);
  baseline_detector.ComputeBaselineSplinesAndXheights(
      page_tr_, pageseg_mode != PSM_RAW_LINE, textord_heavy_nr, textord_show_final_rows, this);
  // Now make the words in the lines.
  if (PSM_WORD_FIND_ENABLED(pageseg_mode)) {
    // SINGLE_LINE uses the old word maker on the single line.
    make_words(this, page_tr_, gradient, blocks, to_blocks);
  } else {
    // SINGLE_WORD and SINGLE_CHAR cram all the blobs into a
    // single word, and in SINGLE_CHAR mode, all the outlines
    // go in a single blob.
    TO_BLOCK *to_block = to_block_it.data();
    make_single_word(pageseg_mode == PSM_SINGLE_CHAR, to_block->get_rows(),
                     to_block->block->row_list());
  }
  // Remove empties.
  cleanup_blocks(PSM_WORD_FIND_ENABLED(pageseg_mode), blocks);
  TransferDiacriticsToBlockGroups(diacritic_blobs, blocks);
  // Compute the margins for each row in the block, to be used later for
  // paragraph detection.
  BLOCK_IT b_it(blocks);
  for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
    b_it.data()->compute_row_margins();
  }
#ifndef GRAPHICS_DISABLED
  close_to_win();
#endif
}

// If we were supposed to return only a single textline, and there is more
// than one, clean up and leave only the best.
void Textord::CleanupSingleRowResult(PageSegMode pageseg_mode, PAGE_RES *page_res) {
  if (PSM_LINE_FIND_ENABLED(pageseg_mode) || PSM_SPARSE(pageseg_mode)) {
    return; // No cleanup required.
  }
  PAGE_RES_IT it(page_res);
  // Find the best row, being the greatest mean word conf.
  float row_total_conf = 0.0f;
  int row_word_count = 0;
  ROW_RES *best_row = nullptr;
  float best_conf = 0.0f;
  for (it.restart_page(); it.word() != nullptr; it.forward()) {
    WERD_RES *word = it.word();
    row_total_conf += word->best_choice->certainty();
    ++row_word_count;
    if (it.next_row() != it.row()) {
      row_total_conf /= row_word_count;
      if (best_row == nullptr || best_conf < row_total_conf) {
        best_row = it.row();
        best_conf = row_total_conf;
      }
      row_total_conf = 0.0f;
      row_word_count = 0;
    }
  }
  // Now eliminate any word not in the best row.
  for (it.restart_page(); it.word() != nullptr; it.forward()) {
    if (it.row() != best_row) {
      it.DeleteCurrentWord();
    }
  }
}

} // namespace tesseract.