/**********************************************************************
 * File:        ocrblock.cpp  (Formerly block.c)
 * Description: BLOCK member functions and iterator functions.
 * Author:		Ray Smith
 * Created:		Fri Mar 15 09:41:28 GMT 1991
 *
 * (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.
 *
 **********************************************************************/

#include "mfcpch.h"
#include          <stdlib.h>
#include          "blckerr.h"
#include          "ocrblock.h"
#include          "tprintf.h"

#define BLOCK_LABEL_HEIGHT  150  //char height of block id

ELISTIZE_S (BLOCK)
/**********************************************************************
 * BLOCK::BLOCK
 *
 * Constructor for a simple rectangular block.
 **********************************************************************/
BLOCK::BLOCK (                   //rectangular block
const char *name,                //filename
BOOL8 prop,                      //proportional
inT16 kern,                      //kerning
inT16 space,                     //spacing
inT16 xmin,                      //bottom left
inT16 ymin, inT16 xmax,          //top right
inT16 ymax):
PDBLK (xmin, ymin, xmax, ymax),
filename(name) {  //box(ICOORD(xmin,ymin),ICOORD(xmax,ymax))
                                 //boundaries
  ICOORDELT_IT left_it = &leftside;
  ICOORDELT_IT right_it = &rightside;

  proportional = prop;
  kerning = kern;
  spacing = space;
  font_class = -1;               //not assigned
  hand_block = NULL;
  hand_poly = NULL;
  left_it.set_to_list (&leftside);
  right_it.set_to_list (&rightside);
                                 //make default box
  left_it.add_to_end (new ICOORDELT (xmin, ymin));
  left_it.add_to_end (new ICOORDELT (xmin, ymax));
  right_it.add_to_end (new ICOORDELT (xmax, ymin));
  right_it.add_to_end (new ICOORDELT (xmax, ymax));
}


/**********************************************************************
 * BLOCK::set_sides
 *
 * Sets left and right vertex lists
 **********************************************************************/

//void                                                          BLOCK::set_sides(                       //set vertex lists
//ICOORDELT_LIST             *left,                        //left vertices
//ICOORDELT_LIST             *right                        //right vertices
//)
//{
//      ICOORDELT_IT                            left_it= &leftside;                             //boundaries
//      ICOORDELT_IT                            right_it= &rightside;

//      leftside.clear();
//      left_it.move_to_first();
//      left_it.add_list_before(left);
//      rightside.clear();
//      right_it.move_to_first();
//      right_it.add_list_before(right);
//}

/**********************************************************************
 * BLOCK::contains
 *
 * Return TRUE if the given point is within the block.
 **********************************************************************/

//BOOL8                                                         BLOCK::contains(                                        //test containment
//ICOORD                                                        pt                                                                              //point to test
//)
//{
//      BLOCK_RECT_IT                           it=this;                                                                //rectangle iterator
//      ICOORD                                          bleft,tright;                                           //corners of rectangle

//      for (it.start_block();!it.cycled_rects();it.forward())
//      {
//              it.bounding_box(bleft,tright);                                                  //get rectangle
//              if (pt.x()>=bleft.x() && pt.x()<=tright.x()                     //inside rect
//              && pt.y()>=bleft.y() && pt.y()<=tright.y())
//                      return TRUE;                                                                                            //is inside
//      }
//      return FALSE;                                                                                                           //not inside
//}

/**********************************************************************
 * BLOCK::move
 *
 * Reposition block
 **********************************************************************/

//void                                                     BLOCK::move(                                         // reposition block
//const ICOORD                                  vec                                                                     // by vector
//)
//{
//   ROW_IT                                             row_it( &rows );
//      ICOORDELT_IT                            it( &leftside );

//      for( row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward() )
//         row_it.data()->move( vec );

//      for( it.mark_cycle_pt(); !it.cycled_list(); it.forward() )
//         *(it.data()) += vec;

//   it.set_to_list( &rightside );

//   for( it.mark_cycle_pt(); !it.cycled_list(); it.forward() )
//         *(it.data()) += vec;

//   box.move( vec );
//}

/**********************************************************************
 * decreasing_top_order
 *
 * Sort Comparator: Return <0 if row1 top < row2 top
 **********************************************************************/

int decreasing_top_order(  //
                         const void *row1,
                         const void *row2) {
  return (*(ROW **) row2)->bounding_box ().top () -
    (*(ROW **) row1)->bounding_box ().top ();
}


/**********************************************************************
 * BLOCK::sort_rows
 *
 * Order rows so that they are in order of decreasing Y coordinate
 **********************************************************************/

void BLOCK::sort_rows() {  // order on "top"
  ROW_IT row_it(&rows);

  row_it.sort (decreasing_top_order);
}


/**********************************************************************
 * BLOCK::compress
 *
 * Delete space between the rows. (And maybe one day, compress the rows)
 * Fill space of block from top down, left aligning rows.
 **********************************************************************/

void BLOCK::compress() {  // squash it up
  #define           ROW_SPACING 5

  ROW_IT row_it(&rows);
  ROW *row;
  ICOORD row_spacing (0, ROW_SPACING);

  ICOORDELT_IT icoordelt_it;

  sort_rows();

  box = TBOX (box.topleft (), box.topleft ());
  box.move_bottom_edge (ROW_SPACING);
  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
    row = row_it.data ();
    row->move (box.botleft () - row_spacing -
      row->bounding_box ().topleft ());
    box += row->bounding_box ();
  }

  leftside.clear ();
  icoordelt_it.set_to_list (&leftside);
  icoordelt_it.add_to_end (new ICOORDELT (box.left (), box.bottom ()));
  icoordelt_it.add_to_end (new ICOORDELT (box.left (), box.top ()));
  rightside.clear ();
  icoordelt_it.set_to_list (&rightside);
  icoordelt_it.add_to_end (new ICOORDELT (box.right (), box.bottom ()));
  icoordelt_it.add_to_end (new ICOORDELT (box.right (), box.top ()));
}


/**********************************************************************
 * BLOCK::check_pitch
 *
 * Check whether the block is fixed or prop, set the flag, and set
 * the pitch if it is fixed.
 **********************************************************************/

void BLOCK::check_pitch() {  // check prop
  //      tprintf("Missing FFT fixed pitch stuff!\n");
  pitch = -1;
}


/**********************************************************************
 * BLOCK::compress
 *
 * Compress and move in a single operation.
 **********************************************************************/

void BLOCK::compress(                  // squash it up
                     const ICOORD vec  // and move
                    ) {
  box.move (vec);
  compress();
}


/**********************************************************************
 * BLOCK::print
 *
 * Print the info on a block
 **********************************************************************/

void BLOCK::print(            //print list of sides
                  FILE *,     //file to print on
                  BOOL8 dump  //print full detail
                 ) {
  ICOORDELT_IT it = &leftside;   //iterator

  box.print ();
  tprintf ("Proportional= %s\n", proportional ? "TRUE" : "FALSE");
  tprintf ("Kerning= %d\n", kerning);
  tprintf ("Spacing= %d\n", spacing);
  tprintf ("Fixed_pitch=%d\n", pitch);
  tprintf ("Filename= %s\n", filename.string ());

  if (dump) {
    tprintf ("Left side coords are:\n");
    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
      tprintf ("(%d,%d) ", it.data ()->x (), it.data ()->y ());
    tprintf ("\n");
    tprintf ("Right side coords are:\n");
    it.set_to_list (&rightside);
    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
      tprintf ("(%d,%d) ", it.data ()->x (), it.data ()->y ());
    tprintf ("\n");
  }
}


/**********************************************************************
 * BLOCK::plot
 *
 * Plot the outline of a block in the given colour.
 **********************************************************************/

//void                                                          BLOCK::plot(                                            //draw outline
//WINDOW                                                        window,                                                         //window to draw in
//inT32                                                         serial,                                                         //serial number
//COLOUR                                                        colour                                                          //colour to draw in
//)
//{
//      ICOORD                                          startpt;                                                                //start of outline
//      ICOORD                                          endpt;                                                          //end of outline
//      ICOORD                                          prevpt;                                                         //previous point
//      ICOORDELT_IT                            it= &leftside;                                          //iterator
//      char                                                    number[32];                                                     //block id

//      line_color_index(window,colour);                                                                //set the colour
//      text_color_index(window,colour);
//      character_height(window,(float)BLOCK_LABEL_HEIGHT);
//      text_font_index(window,6);

//      if (!leftside.empty())
//      {
//              startpt= *(it.data());                                                                          //bottom left corner
////            fprintf(stderr,"Block %d bottom left is (%d,%d)\n",
////                    serial,startpt.x(),startpt.y());
//              sprintf(number,"%d",serial);
//              text2d(window,startpt.x(),startpt.y(),number,0,FALSE);

//              move2d(window,startpt.x(),startpt.y());
//              do
//              {
//                      prevpt= *(it.data());                                                                   //previous point
//                      it.forward();                                                                                           //move to next point
//                      draw2d(window,prevpt.x(),it.data()->y());                       //draw round corner
//                      draw2d(window,it.data()->x(),it.data()->y());
//              }
//              while (!it.at_last());                                                                          //until end of list
//              endpt= *(it.data());                                                                                    //end point

//              move2d(window,startpt.x(),startpt.y());                         //other side of boundary
//              it.set_to_list(&rightside);
//              prevpt=startpt;
//              for (it.mark_cycle_pt();!it.cycled_list();it.forward())
//              {
//                      draw2d(window,prevpt.x(),it.data()->y());                       //draw round corner
//                      draw2d(window,it.data()->x(),it.data()->y());
//                      prevpt= *(it.data());                                                                   //previous point
//              }
//              draw2d(window,endpt.x(),endpt.y());                                             //close boundary
//              if (hand_block!=NULL)
//                      hand_block->plot(window,colour,serial);
//      }
//}

/**********************************************************************
 * BLOCK::show
 *
 * Show the image corresponding to a block as its set of rectangles.
 **********************************************************************/

//void                                                          BLOCK::show(                                            //show image block
//IMAGE                                                         *image,                                                         //image to show
//WINDOW                                                        window                                                          //window to show in
//)
//{
//      BLOCK_RECT_IT                           it=this;                                                                //rectangle iterator
//      ICOORD                                          bleft,tright;                                           //corners of rectangle

//      for (it.start_block();!it.cycled_rects();it.forward())
//      {
//              it.bounding_box(bleft,tright);                                                  //get rectangle
////            fprintf(stderr,"Drawing a block with a bottom left of (%d,%d)\n",
////                    bleft.x(),bleft.y());
//              show_sub_image(image,bleft.x(),bleft.y(),
//                      tright.x()-bleft.x(),tright.y()-bleft.y(),
//                      window,bleft.x(),bleft.y());                                                    //show it
//      }
//}

/**********************************************************************
 * BLOCK::operator=
 *
 * Assignment - duplicate the block structure, but with an EMPTY row list.
 **********************************************************************/

BLOCK & BLOCK::operator= (       //assignment
const BLOCK & source             //from this
) {
  this->ELIST_LINK::operator= (source);
  this->PDBLK::operator= (source);
  proportional = source.proportional;
  kerning = source.kerning;
  spacing = source.spacing;
  filename = source.filename;    //STRINGs assign ok
  if (!rows.empty ())
    rows.clear ();
  //   if ( !leftside.empty() )
  //              leftside.clear();
  // if ( !rightside.empty() )
  //              rightside.clear();
  //   leftside.deep_copy( &source.leftside );
  //   rightside.deep_copy( &source.rightside );
  //      box=source.box;
  return *this;
}
