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

 * File:        pdblock.h  (Formerly pdblk.h)

 * Description: Page block class definition.

 * Author:      Ray Smith

 *

 * (C) Copyright 1991, Hewlett-Packard Ltd.

 ** 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.

 *

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

#ifndef PDBLOCK_H

#define PDBLOCK_H

#include "clst.h"

#include "polyblk.h"

struct Pix;

namespace tesseract {

class PDBLK; // forward decl

CLISTIZEH(PDBLK)

/// page block

class PDBLK {

  friend class BLOCK_RECT_IT; ///< block iterator

  friend class BLOCK;         ///< Page Block

public:

  /// empty constructor

  PDBLK() {

    hand_poly = nullptr;

    index_ = 0;

  }

  /// simple constructor

  PDBLK(TDimension xmin, ///< bottom left

        TDimension ymin,

        TDimension xmax, ///< top right

        TDimension ymax);

  /// set vertex lists

  ///@param left list of left vertices

  ///@param right list of right vertices

  void set_sides(ICOORDELT_LIST *left, ICOORDELT_LIST *right);

  /// destructor

  ~PDBLK() {

    delete hand_poly;

  }

  POLY_BLOCK *poly_block() const {

    return hand_poly;

  }

  /// set the poly block

  void set_poly_block(POLY_BLOCK *blk) {

    hand_poly = blk;

  }

  /// get box

  void bounding_box(ICOORD &bottom_left,       // bottom left

                    ICOORD &top_right) const { // topright

    bottom_left = box.botleft();

    top_right = box.topright();

  }

  /// get real box

  const TBOX &bounding_box() const {

    return box;

  }

  int index() const {

    return index_;

  }

  void set_index(int value) {

    index_ = value;

  }

  /// is pt inside block

  bool contains(ICOORD pt);

  /// reposition block

  void move(const ICOORD vec); // by vector

  // Returns a binary Pix mask with a 1 pixel for every pixel within the

  // block. Rotates the coordinate system by rerotation prior to rendering.

  // If not nullptr, mask_box is filled with the position box of the returned

  // mask image.

  Image render_mask(const FCOORD &rerotation, TBOX *mask_box);

#ifndef GRAPHICS_DISABLED

  /// draw histogram

  ///@param window window to draw in

  ///@param serial serial number

  ///@param colour colour to draw in

  void plot(ScrollView *window, int32_t serial, ScrollView::Color colour);

#endif // !GRAPHICS_DISABLED

  /// assignment

  ///@param source from this

  PDBLK &operator=(const PDBLK &source);

protected:

  POLY_BLOCK *hand_poly;    ///< weird as well

  ICOORDELT_LIST leftside;  ///< left side vertices

  ICOORDELT_LIST rightside; ///< right side vertices

  TBOX box;                 ///< bounding box

  int index_;               ///< Serial number of this block.

};

class BLOCK_RECT_IT // rectangle iterator

{

public:

  /// constructor

  ///@param blkptr block to iterate

  BLOCK_RECT_IT(PDBLK *blkptr);

  /// start (new) block

  void set_to_block(PDBLK *blkptr); // block to iterate

  /// start iteration

  void start_block();

  /// next rectangle

  void forward();

  /// test end

  bool cycled_rects() const {

    return left_it.cycled_list() && right_it.cycled_list();

  }

  /// current rectangle

  ///@param bleft bottom left

  ///@param tright top right

  void bounding_box(ICOORD &bleft, ICOORD &tright) {

    // bottom left

    bleft = ICOORD(left_it.data()->x(), ymin);

    // top right

    tright = ICOORD(right_it.data()->x(), ymax);

  }

private:

  TDimension ymin = 0;    ///< bottom of rectangle

  TDimension ymax = 0;    ///< top of rectangle

  PDBLK *block = nullptr; ///< block to iterate

  ICOORDELT_IT left_it;   ///< boundary iterators

  ICOORDELT_IT right_it;

};

/// rectangle iterator

class BLOCK_LINE_IT {

public:

  /// constructor

  ///@param blkptr from block

  BLOCK_LINE_IT(PDBLK *blkptr) : rect_it(blkptr) {

    block = blkptr; // remember block

  }

  /// start (new) block

  ///@param blkptr block to start

  void set_to_block(PDBLK *blkptr) {

    block = blkptr; // remember block

                    // set iterator

    rect_it.set_to_block(blkptr);

  }

  /// get a line

  ///@param y line to get

  ///@param xext output extent

  TDimension get_line(TDimension y, TDimension &xext);

private:

  PDBLK *block;          ///< block to iterate

  BLOCK_RECT_IT rect_it; ///< rectangle iterator

};

} // namespace tesseract

#endif