/**********************************************************************
* File: polyblob.cpp (Formerly blob.c)
* Description: Code for PBLOB class.
* Author: Ray Smith
* Created: Wed Oct 23 15:17:41 BST 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 "varable.h"
#include "ocrrow.h"
#include "polyblob.h"
//#include "lapoly.h"
#include "polyaprx.h"
#define EXTERN
EXTERN BOOL_VAR (polygon_tess_approximation, TRUE,
"Do tess poly instead of greyscale");
ELISTIZE_S (PBLOB)
/**********************************************************************
* position_outline
*
* Position the outline in the given list at the relevant place
* according to its nesting.
**********************************************************************/
static void position_outline( //put in place
OUTLINE *outline, //thing to place
OUTLINE_LIST *destlist //desstination list
) {
OUTLINE *dest_outline; //outline from dest list
OUTLINE_IT it = destlist; //iterator
//iterator on children
OUTLINE_IT child_it = outline->child ();
if (!it.empty ()) {
do {
dest_outline = it.data (); //get destination
//encloses dest
if (*dest_outline < *outline) {
//take off list
dest_outline = it.extract ();
//put this in place
it.add_after_then_move (outline);
//make it a child
child_it.add_to_end (dest_outline);
while (!it.at_last ()) {
it.forward (); //do rest of list
//check for other children
dest_outline = it.data ();
if (*dest_outline < *outline) {
//take off list
dest_outline = it.extract ();
child_it.add_to_end (dest_outline);
//make it a child
if (it.empty ())
break;
}
}
return; //finished
}
//enclosed by dest
else if (*outline < *dest_outline) {
position_outline (outline, dest_outline->child ());
//place in child list
return; //finished
}
it.forward ();
}
while (!it.at_first ());
}
it.add_to_end (outline); //at outer level
}
/**********************************************************************
* plot_outline_list
*
* Draw a list of outlines in the given colour and their children
* in the child colour.
**********************************************************************/
#ifndef GRAPHICS_DISABLED
static void plot_outline_list( //draw outlines
OUTLINE_LIST *list, //outline to draw
ScrollView* window, //window to draw in
ScrollView::Color colour, //colour to use
ScrollView::Color child_colour //colour of children
) {
OUTLINE *outline; //current outline
OUTLINE_IT it = list; //iterator
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
outline = it.data ();
//draw it
outline->plot (window, colour);
if (!outline->child ()->empty ())
plot_outline_list (outline->child (), window,
child_colour, child_colour);
}
}
#endif
/**********************************************************************
* PBLOB::PBLOB
*
* Constructor to build a PBLOB from a list of OUTLINEs.
* The OUTLINEs are not copied so the source list is emptied.
* The OUTLINEs are nested correctly in the blob.
**********************************************************************/
PBLOB::PBLOB( //constructor
OUTLINE_LIST *outline_list //in random order
) {
OUTLINE *outline; //current outline
OUTLINE_IT it = outline_list; //iterator
while (!it.empty ()) { //grab the list
outline = it.extract (); //get off the list
//put it in place
position_outline(outline, &outlines);
if (!it.empty ())
it.forward ();
}
}
/**********************************************************************
* approximate_outline_list
*
* Convert a list of outlines to polygonal form.
**********************************************************************/
static void approximate_outline_list( //do list of outlines
C_OUTLINE_LIST *srclist, //list to convert
OUTLINE_LIST *destlist, //desstination list
float xheight //height of line
) {
C_OUTLINE *src_outline; //outline from src list
OUTLINE *dest_outline; //result
C_OUTLINE_IT src_it = srclist; //source iterator
OUTLINE_IT dest_it = destlist; //iterator
do {
src_outline = src_it.data ();
// if (polygon_tess_approximation)
dest_outline = tesspoly_outline (src_outline, xheight);
// else
// dest_outline=greypoly_outline(src_outline,xheight);
if (dest_outline != NULL) {
dest_it.add_after_then_move (dest_outline);
if (!src_outline->child ()->empty ())
//do child list
approximate_outline_list (src_outline->child (), dest_outline->child (), xheight);
}
src_it.forward ();
}
while (!src_it.at_first ());
}
/**********************************************************************
* PBLOB::PBLOB
*
* Constructor to build a PBLOB from a C_BLOB by polygonal approximation.
**********************************************************************/
PBLOB::PBLOB( //constructor
C_BLOB *cblob, //compact blob
float xheight //height of line
) {
TBOX bbox; //bounding box
if (!cblob->out_list ()->empty ()) {
//get bounding box
bbox = cblob->bounding_box ();
if (bbox.height () > xheight)
xheight = bbox.height (); //max of line and blob
//copy it
approximate_outline_list (cblob->out_list (), &outlines, xheight);
}
}
/**********************************************************************
* PBLOB::bounding_box
*
* Return the bounding box of the blob.
**********************************************************************/
TBOX PBLOB::bounding_box() { //bounding box
OUTLINE *outline; //current outline
OUTLINE_IT it = &outlines; //outlines of blob
TBOX box; //bounding box
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
outline = it.data ();
box += outline->bounding_box ();
}
return box;
}
/**********************************************************************
* PBLOB::area
*
* Return the area of the blob.
**********************************************************************/
float PBLOB::area() { //area
OUTLINE *outline; //current outline
OUTLINE_IT it = &outlines; //outlines of blob
float total; //total area
total = 0.0f;
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
outline = it.data ();
total += outline->area ();
}
return total;
}
/**********************************************************************
* PBLOB::baseline_normalise
*
* Baseline normalize a blob
**********************************************************************/
PBLOB *PBLOB::baseline_normalise( //normalize blob
ROW *row, //row it came from
DENORM *denorm //inverse mapping
) {
TBOX blob_box = bounding_box ();
float x_centre = (blob_box.left () + blob_box.right ()) / 2.0;
PBLOB *bn_blob; //copied blob
*denorm = DENORM (x_centre, bln_x_height / row->x_height (), row);
bn_blob = new PBLOB; //get one
*bn_blob = *this; //deep copy
bn_blob->move (FCOORD (-denorm->origin (), -row->base_line (x_centre)));
bn_blob->scale (denorm->scale ());
bn_blob->move (FCOORD (0.0, bln_baseline_offset));
return bn_blob;
}
/**********************************************************************
* PBLOB::baseline_denormalise
*
* DeBaseline Normalise the blob properly with the given denorm.
**********************************************************************/
void PBLOB::baseline_denormalise( // Tess style BL Norm
const DENORM *denorm //antidote
) {
float blob_x_left; // Left edge of blob.
TBOX blob_box; //blob bounding box
move(FCOORD (0.0f, 0.0f - bln_baseline_offset));
blob_box = bounding_box ();
blob_x_left = blob_box.left ();
scale (1.0 / denorm->scale_at_x (blob_x_left));
move (FCOORD (denorm->origin (),
denorm->yshift_at_x (blob_x_left)));
}
/**********************************************************************
* PBLOB::move
*
* Move PBLOB by vector
**********************************************************************/
void PBLOB::move( // reposition blob
const FCOORD vec // by vector
) {
OUTLINE_IT it(&outlines); // iterator
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
it.data ()->move (vec); // move each outline
}
/**********************************************************************
* PBLOB::scale
*
* Scale PBLOB by float multiplier
**********************************************************************/
void PBLOB::scale( // scale blob
const float f // by multiplier
) {
OUTLINE_IT it(&outlines); // iterator
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
it.data ()->scale (f); // scale each outline
}
/**********************************************************************
* PBLOB::scale
*
* Scale PBLOB by float multiplier
**********************************************************************/
void PBLOB::scale( // scale blob
const FCOORD vec // by multiplier
) {
OUTLINE_IT it(&outlines); // iterator
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
it.data ()->scale (vec); // scale each outline
}
/**********************************************************************
* PBLOB::rotate
*
* Rotate PBLOB 90 deg anticlockwise about the origin.
**********************************************************************/
void PBLOB::rotate() { // Rotate 90 deg anti
rotate(FCOORD(0.0f, 1.0f));
}
/**********************************************************************
* PBLOB::rotate
*
* Rotate PBLOB by the given rotation about the origin.
* The rotation is defined to be (cos a, sin a) where a is the anticlockwise
* rotation angle (in units appropriate for cos, sin).
* Alternatively think of multiplication by the complex number
* rotation = z = (x + iy), with |z| = 1.
**********************************************************************/
void PBLOB::rotate(const FCOORD& rotation) { // Rotate by given rotation.
OUTLINE_IT it(&outlines);
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
it.data()->rotate(rotation); // Rotate each outline.
}
}
/**********************************************************************
* PBLOB::plot
*
* Draw the PBLOB in the given colour.
**********************************************************************/
#ifndef GRAPHICS_DISABLED
void PBLOB::plot( //draw it
ScrollView* window, //window to draw in
ScrollView::Color blob_colour, //main colour
ScrollView::Color child_colour //for holes
) {
plot_outline_list(&outlines, window, blob_colour, child_colour);
}
#endif