pdblock.h

Go to the documentation of this file.

/**********************************************************************
 * 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)
class PDBLK {
  friend class BLOCK_RECT_IT; 
  friend class BLOCK;         
 
public:
  PDBLK() {
    hand_poly = nullptr;
    index_ = 0;
  }
  PDBLK(TDimension xmin, 
        TDimension ymin,
        TDimension xmax, 
        TDimension ymax);
 
  void set_sides(ICOORDELT_LIST *left, ICOORDELT_LIST *right);
 
  ~PDBLK() {
    delete hand_poly;
  }
 
  POLY_BLOCK *poly_block() const {
    return hand_poly;
  }
  void set_poly_block(POLY_BLOCK *blk) {
    hand_poly = blk;
  }
  void bounding_box(ICOORD &bottom_left,       // bottom left
                    ICOORD &top_right) const { // topright
    bottom_left = box.botleft();
    top_right = box.topright();
  }
  const TBOX &bounding_box() const {
    return box;
  }
 
  int index() const {
    return index_;
  }
  void set_index(int value) {
    index_ = value;
  }
 
  bool contains(ICOORD pt);
 
  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
  void plot(ScrollView *window, int32_t serial, ScrollView::Color colour);
#endif // !GRAPHICS_DISABLED
 
  PDBLK &operator=(const PDBLK &source);
 
protected:
  POLY_BLOCK *hand_poly;    
  ICOORDELT_LIST leftside;  
  ICOORDELT_LIST rightside; 
  TBOX box;                 
  int index_;               
};
 
class BLOCK_RECT_IT // rectangle iterator
{
public:
  BLOCK_RECT_IT(PDBLK *blkptr);
 
  void set_to_block(PDBLK *blkptr); // block to iterate
 
  void start_block();
 
  void forward();
 
  bool cycled_rects() const {
    return left_it.cycled_list() && right_it.cycled_list();
  }
 
  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;    
  TDimension ymax = 0;    
  PDBLK *block = nullptr; 
  ICOORDELT_IT left_it;   
  ICOORDELT_IT right_it;
};
 
class BLOCK_LINE_IT {
public:
  BLOCK_LINE_IT(PDBLK *blkptr) : rect_it(blkptr) {
    block = blkptr; // remember block
  }
 
  void set_to_block(PDBLK *blkptr) {
    block = blkptr; // remember block
                    // set iterator
    rect_it.set_to_block(blkptr);
  }
 
  TDimension get_line(TDimension y, TDimension &xext);
 
private:
  PDBLK *block;          
  BLOCK_RECT_IT rect_it; 
};
 
} // namespace tesseract
 
#endif