/*****************************************************************************

 *

 * File:         blkocc.cpp  (Formerly blockocc.c)

 * Description:  Block Occupancy routines

 * Author:       Chris Newton

 *

 * (c) Copyright 1991, Hewlett-Packard Company.

 ** 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 "blkocc.h"

#include "drawtord.h"

#include "errcode.h"

#include <cctype>

#include <cmath>

#include "helpers.h"

namespace tesseract {

double_VAR(textord_underline_threshold, 0.5, "Fraction of width occupied");

// Forward declarations of static functions

static void horizontal_cblob_projection(C_BLOB *blob,  // blob to project

                                        STATS *stats); // output

static void horizontal_coutline_projection(C_OUTLINE *outline,

                                           STATS *stats); // output

/**

 * test_underline

 *

 * Check to see if the blob is an underline.

 * Return true if it is.

 */

bool test_underline(  // look for underlines

    bool testing_on,  ///< drawing blob

    C_BLOB *blob,     ///< blob to test

    int16_t baseline, ///< coords of baseline

    int16_t xheight   ///< height of line

) {

  TDimension occ;

  STATS projection;

  auto blob_box = blob->bounding_box();

  auto blob_width = blob->bounding_box().width();

  projection.set_range(blob_box.bottom(), blob_box.top());

  if (testing_on) {

    //              blob->plot(to_win,GOLDENROD,GOLDENROD);

    //              line_color_index(to_win,GOLDENROD);

    //              move2d(to_win,blob_box.left(),baseline);

    //              draw2d(to_win,blob_box.right(),baseline);

    //              move2d(to_win,blob_box.left(),baseline+xheight);

    //              draw2d(to_win,blob_box.right(),baseline+xheight);

    tprintf("Testing underline on blob at (%d,%d)->(%d,%d), base=%d\nOccs:",

            blob->bounding_box().left(), blob->bounding_box().bottom(),

            blob->bounding_box().right(), blob->bounding_box().top(), baseline);

  }

  horizontal_cblob_projection(blob, &projection);

  int32_t desc_occ = 0;

  for (occ = blob_box.bottom(); occ < baseline; occ++) {

    if (occ <= blob_box.top() && projection.pile_count(occ) > desc_occ) {

      // max in region

      desc_occ = projection.pile_count(occ);

    }

  }

  int32_t x_occ = 0;

  for (occ = baseline; occ <= baseline + xheight; occ++) {

    if (occ >= blob_box.bottom() && occ <= blob_box.top() && projection.pile_count(occ) > x_occ) {

      // max in region

      x_occ = projection.pile_count(occ);

    }

  }

  int32_t asc_occ = 0;

  for (occ = baseline + xheight + 1; occ <= blob_box.top(); occ++) {

    if (occ >= blob_box.bottom() && projection.pile_count(occ) > asc_occ) {

      asc_occ = projection.pile_count(occ);

    }

  }

  if (testing_on) {

    tprintf("%d %d %d\n", desc_occ, x_occ, asc_occ);

  }

  if (desc_occ == 0 && x_occ == 0 && asc_occ == 0) {

    tprintf("Bottom=%d, top=%d, base=%d, x=%d\n", blob_box.bottom(), blob_box.top(), baseline,

            xheight);

    projection.print();

  }

  if (desc_occ > x_occ + x_occ && desc_occ > blob_width * textord_underline_threshold) {

    return true; // real underline

  }

  return asc_occ > x_occ + x_occ && asc_occ > blob_width * textord_underline_threshold; // overline

                                                                                        // neither

}

/**

 * horizontal_cblob_projection

 *

 * Compute the horizontal projection of a cblob from its outlines

 * and add to the given STATS.

 */

static void horizontal_cblob_projection( // project outlines

    C_BLOB *blob,                        ///< blob to project

    STATS *stats                         ///< output

) {

  // outlines of blob

  C_OUTLINE_IT out_it = blob->out_list();

  for (out_it.mark_cycle_pt(); !out_it.cycled_list(); out_it.forward()) {

    horizontal_coutline_projection(out_it.data(), stats);

  }

}

/**

 * horizontal_coutline_projection

 *

 * Compute the horizontal projection of an outline from its outlines

 * and add to the given STATS.

 */

static void horizontal_coutline_projection( // project outlines

    C_OUTLINE *outline,                     ///< outline to project

    STATS *stats                            ///< output

) {

  ICOORD pos;        // current point

  ICOORD step;       // edge step

  int32_t length;    // of outline

  int16_t stepindex; // current step

  C_OUTLINE_IT out_it = outline->child();

  pos = outline->start_pos();

  length = outline->pathlength();

  for (stepindex = 0; stepindex < length; stepindex++) {

    step = outline->step(stepindex);

    if (step.y() > 0) {

      stats->add(pos.y(), pos.x());

    } else if (step.y() < 0) {

      stats->add(pos.y() - 1, -pos.x());

    }

    pos += step;

  }

  for (out_it.mark_cycle_pt(); !out_it.cycled_list(); out_it.forward()) {

    horizontal_coutline_projection(out_it.data(), stats);

  }

}

} // namespace tesseract