/**********************************************************************
* File: werd.cpp (Formerly word.c)
* Description: Code for the WERD class.
* Author: Ray Smith
* Created: Tue Oct 08 14:32:12 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 "blckerr.h"
#include "linlsq.h"
#include "werd.h"
#define FIRST_COLOUR ScrollView::RED //first rainbow colour
//last rainbow colour
#define LAST_COLOUR ScrollView::AQUAMARINE
#define CHILD_COLOUR ScrollView::BROWN //colour of children
const ERRCODE CANT_SCALE_EDGESTEPS =
"Attempted to scale an edgestep format word";
#define EXTERN
EXTERN BOOL_VAR (bln_numericmode, 0, "Optimize for numbers");
EXTERN INT_VAR (bln_x_height, 128, "Baseline Normalisation X-height");
EXTERN INT_VAR (bln_baseline_offset, 64, "Baseline Norm. offset of baseline");
EXTERN double_VAR (bln_blshift_maxshift, -1.0,
"Fraction of xh before shifting");
EXTERN double_VAR (bln_blshift_xfraction, 0.75,
"Size fraction of xh before shifting");
ELISTIZE_S (WERD)
/**********************************************************************
* WERD::WERD
*
* Constructor to build a WERD from a list of C_BLOBs.
* The C_BLOBs are not copied so the source list is emptied.
**********************************************************************/
WERD::WERD ( //constructor
C_BLOB_LIST * blob_list, //in word order
uinT8 blank_count, //blanks in front
const char *text //correct text
):
flags (0),
correct(text) {
C_BLOB_IT start_it = blob_list;//iterator
C_BLOB_IT end_it = blob_list; //another
//rejected blobs in wd
C_BLOB_IT rej_cblob_it = &rej_cblobs;
C_OUTLINE_IT c_outline_it; //coutline iterator
BOOL8 blob_inverted;
BOOL8 reject_blob;
inT16 inverted_vote = 0;
inT16 non_inverted_vote = 0;
while (!end_it.at_last ())
end_it.forward (); //move to last
//move to our list
cblobs.assign_to_sublist (&start_it, &end_it);
blanks = blank_count;
/*
Set white on black flag for the WERD, moving any duff blobs onto the
rej_cblobs list.
First, walk the cblobs checking the inverse flag for each outline of each
cblob. If a cblob has inconsistent flag settings for its different
outlines, move the blob to the reject list. Otherwise, increment the
appropriate w-on-b or b-on-w vote for the word.
Now set the inversion flag for the WERD by maximum vote.
Walk the blobs again, moving any blob whose inversion flag does not agree
with the concencus onto the reject list.
*/
start_it.set_to_list (&cblobs);
if (start_it.empty ())
return;
for (start_it.mark_cycle_pt ();
!start_it.cycled_list (); start_it.forward ()) {
c_outline_it.set_to_list (start_it.data ()->out_list ());
blob_inverted = c_outline_it.data ()->flag (COUT_INVERSE);
reject_blob = FALSE;
for (c_outline_it.mark_cycle_pt ();
!c_outline_it.cycled_list () && !reject_blob;
c_outline_it.forward ()) {
reject_blob =
c_outline_it.data ()->flag (COUT_INVERSE) != blob_inverted;
}
if (reject_blob)
rej_cblob_it.add_after_then_move (start_it.extract ());
else {
if (blob_inverted)
inverted_vote++;
else
non_inverted_vote++;
}
}
flags.set_bit (W_INVERSE, (inverted_vote > non_inverted_vote));
start_it.set_to_list (&cblobs);
if (start_it.empty ())
return;
for (start_it.mark_cycle_pt ();
!start_it.cycled_list (); start_it.forward ()) {
c_outline_it.set_to_list (start_it.data ()->out_list ());
if (c_outline_it.data ()->flag (COUT_INVERSE) != flags.bit (W_INVERSE))
rej_cblob_it.add_after_then_move (start_it.extract ());
}
}
/**********************************************************************
* WERD::WERD
*
* Constructor to build a WERD from a list of BLOBs.
* The BLOBs are not copied so the source list is emptied.
**********************************************************************/
WERD::WERD ( //constructor
PBLOB_LIST * blob_list, //in word order
uinT8 blank_count, //blanks in front
const char *text //correct text
):
flags (0),
correct(text) {
PBLOB_IT start_it = blob_list; //iterator
PBLOB_IT end_it = blob_list; //another
while (!end_it.at_last ())
end_it.forward (); //move to last
((PBLOB_LIST *) (&cblobs))->assign_to_sublist (&start_it, &end_it);
//move to our list
//it's a polygon
flags.set_bit (W_POLYGON, TRUE);
blanks = blank_count;
// fprintf(stderr,"Wrong constructor!!!!\n");
}
/**********************************************************************
* WERD::WERD
*
* Constructor to build a WERD from a list of BLOBs.
* The BLOBs are not copied so the source list is emptied.
**********************************************************************/
WERD::WERD ( //constructor
PBLOB_LIST * blob_list, //in word order
WERD * clone //sorce of flags
):flags (clone->flags), correct (clone->correct) {
PBLOB_IT start_it = blob_list; //iterator
PBLOB_IT end_it = blob_list; //another
while (!end_it.at_last ())
end_it.forward (); //move to last
((PBLOB_LIST *) (&cblobs))->assign_to_sublist (&start_it, &end_it);
//move to our list
blanks = clone->blanks;
// fprintf(stderr,"Wrong constructor!!!!\n");
}
/**********************************************************************
* WERD::WERD
*
* Constructor to build a WERD from a list of C_BLOBs.
* The C_BLOBs are not copied so the source list is emptied.
**********************************************************************/
WERD::WERD ( //constructor
C_BLOB_LIST * blob_list, //in word order
WERD * clone //sorce of flags
):flags (clone->flags), correct (clone->correct) {
C_BLOB_IT start_it = blob_list;//iterator
C_BLOB_IT end_it = blob_list; //another
while (!end_it.at_last ())
end_it.forward (); //move to last
((C_BLOB_LIST *) (&cblobs))->assign_to_sublist (&start_it, &end_it);
//move to our list
blanks = clone->blanks;
// fprintf(stderr,"Wrong constructor!!!!\n");
}
/**********************************************************************
* WERD::poly_copy
*
* Make a copy of a WERD in polygon format.
* The source WERD is untouched.
**********************************************************************/
WERD *WERD::poly_copy( //make a poly copy
float xheight //row height
) {
PBLOB *blob; //new blob
WERD *result = new WERD; //output word
C_BLOB_IT src_it = &cblobs; //iterator
// LARC_BLOB_IT larc_it=(LARC_BLOB_LIST*)(&cblobs);
PBLOB_IT dest_it = (PBLOB_LIST *) (&result->cblobs);
//another
if (flags.bit (W_POLYGON)) {
*result = *this; //just copy it
}
else {
result->flags = flags;
result->correct = correct; //copy info
result->dummy = dummy;
if (!src_it.empty ()) {
// if (flags.bit(W_LINEARC))
// {
// do
// {
// blob=new PBLOB;
// poly_linearc_outlines(larc_it.data()->out_list(),
// blob->out_list()); //convert outlines
// dest_it.add_after_then_move(blob); //add to dest list
// larc_it.forward();
// }
// while (!larc_it.at_first());
// }
// else
// {
do {
blob = new PBLOB (src_it.data (), xheight);
//convert blob
//add to dest list
dest_it.add_after_then_move (blob);
src_it.forward ();
}
while (!src_it.at_first ());
// }
}
if (!rej_cblobs.empty ()) {
/* Polygonal approx of reject blobs */
src_it.set_to_list (&rej_cblobs);
dest_it = (PBLOB_LIST *) (&result->rej_cblobs);
do {
//convert blob
blob = new PBLOB (src_it.data (), xheight);
//add to dest list
dest_it.add_after_then_move (blob);
src_it.forward ();
}
while (!src_it.at_first ());
}
//polygon now
result->flags.set_bit (W_POLYGON, TRUE);
result->blanks = blanks;
}
return result;
}
/**********************************************************************
* WERD::bounding_box
*
* Return the bounding box of the WERD.
* This is quite a mess to compute!
* ORIGINALLY, REJECT CBLOBS WERE EXCLUDED, however, this led to bugs when the
* words on the row were re-sorted. The original words were built with reject
* blobs included. The FUZZY SPACE flags were set accordingly. If ALL the
* blobs in a word are rejected the BB for the word is NULL, causing the sort
* to screw up, leading to the erroneous possibility of the first word in a
* row being marked as FUZZY space.
**********************************************************************/
TBOX WERD::bounding_box() { //bounding box
TBOX box; //box being built
//rejected blobs in wd
C_BLOB_IT rej_cblob_it = &rej_cblobs;
for (rej_cblob_it.mark_cycle_pt ();
!rej_cblob_it.cycled_list (); rej_cblob_it.forward ()) {
box += rej_cblob_it.data ()->bounding_box ();
}
if (flags.bit (W_POLYGON)) {
//polygons
PBLOB_IT it = (PBLOB_LIST *) (&cblobs);
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
box += it.data ()->bounding_box ();
}
}
else {
C_BLOB_IT it = &cblobs; //blobs of WERD
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
box += it.data ()->bounding_box ();
}
}
return box;
}
/**********************************************************************
* WERD::move
*
* Reposition WERD by vector
* NOTE!! REJECT CBLOBS ARE NOT MOVED
**********************************************************************/
void WERD::move( // reposition WERD
const ICOORD vec // by vector
) {
PBLOB_IT blob_it ((PBLOB_LIST *) & cblobs);
// blob iterator
// LARC_BLOB_IT lblob_it((LARC_BLOB_LIST*)&cblobs);
C_BLOB_IT cblob_it(&cblobs); // cblob iterator
if (flags.bit (W_POLYGON))
for (blob_it.mark_cycle_pt ();
!blob_it.cycled_list (); blob_it.forward ())
blob_it.data ()->move (vec);
// else if (flags.bit(W_LINEARC))
// for( lblob_it.mark_cycle_pt();
// !lblob_it.cycled_list();
// lblob_it.forward() )
// lblob_it.data()->move( vec );
else
for (cblob_it.mark_cycle_pt ();
!cblob_it.cycled_list (); cblob_it.forward ())
cblob_it.data ()->move (vec);
}
/**********************************************************************
* WERD::scale
*
* Scale WERD by multiplier
**********************************************************************/
void WERD::scale( // scale WERD
const float f // by multiplier
) {
PBLOB_IT blob_it ((PBLOB_LIST *) & cblobs);
// blob iterator
// LARC_BLOB_IT lblob_it((LARC_BLOB_LIST*)&cblobs);
if (flags.bit (W_POLYGON))
for (blob_it.mark_cycle_pt ();
!blob_it.cycled_list (); blob_it.forward ())
blob_it.data ()->scale (f);
// else if (flags.bit(W_LINEARC))
// for (lblob_it.mark_cycle_pt();
// !lblob_it.cycled_list();
// lblob_it.forward() )
// lblob_it.data()->scale( f );
else
CANT_SCALE_EDGESTEPS.error ("WERD::scale", ABORT, NULL);
}
/**********************************************************************
* WERD::join_on
*
* Join other word onto this one. Delete the old word.
**********************************************************************/
void WERD::join_on( // join WERD
WERD *&other //other word
) {
PBLOB_IT blob_it ((PBLOB_LIST *) & cblobs);
// blob iterator
PBLOB_IT src_it ((PBLOB_LIST *) & other->cblobs);
C_BLOB_IT rej_cblob_it(&rej_cblobs);
C_BLOB_IT src_rej_it (&other->rej_cblobs);
while (!src_it.empty ()) {
blob_it.add_to_end (src_it.extract ());
src_it.forward ();
}
while (!src_rej_it.empty ()) {
rej_cblob_it.add_to_end (src_rej_it.extract ());
src_rej_it.forward ();
}
}
/**********************************************************************
* WERD::copy_on
*
* Copy blobs from other word onto this one.
**********************************************************************/
void WERD::copy_on( //copy blobs
WERD *&other //from other
) {
if (flags.bit (W_POLYGON)) {
PBLOB_IT blob_it ((PBLOB_LIST *) & cblobs);
// blob iterator
PBLOB_LIST blobs;
blobs.deep_copy(reinterpret_cast<PBLOB_LIST*>(&other->cblobs),
&PBLOB::deep_copy);
blob_it.move_to_last ();
blob_it.add_list_after (&blobs);
} else {
C_BLOB_IT c_blob_it(&cblobs);
C_BLOB_LIST c_blobs;
c_blobs.deep_copy(&other->cblobs, &C_BLOB::deep_copy);
c_blob_it.move_to_last ();
c_blob_it.add_list_after (&c_blobs);
}
if (!other->rej_cblobs.empty ()) {
C_BLOB_IT rej_c_blob_it(&rej_cblobs);
C_BLOB_LIST new_rej_c_blobs;
new_rej_c_blobs.deep_copy(&other->rej_cblobs, &C_BLOB::deep_copy);
rej_c_blob_it.move_to_last ();
rej_c_blob_it.add_list_after (&new_rej_c_blobs);
}
}
/**********************************************************************
* WERD::baseline_normalise
*
* Baseline Normalise the word in Tesseract style. (I.e origin at centre of
* word at bottom. x-height region scaled to region y =
* (bln_baseline_offset)..(bln_baseline_offset + bln_x_height)
* - usually 64..192)
**********************************************************************/
void WERD::baseline_normalise( // Tess style BL Norm
ROW *row,
DENORM *denorm //antidote
) {
baseline_normalise_x (row, row->x_height (), denorm);
//Use standard x ht
}
/**********************************************************************
* WERD::baseline_normalise_x
*
* Baseline Normalise the word in Tesseract style. (I.e origin at centre of
* word at bottom. x-height region scaled to region y =
* (bln_baseline_offset)..(bln_baseline_offset + bln_x_height)
* - usually 64..192)
* USE A SPECIFIED X-HEIGHT - NOT NECESSARILY THE ONE IN row
**********************************************************************/
void WERD::baseline_normalise_x( // Tess style BL Norm
ROW *row,
float x_height, //non standard value
DENORM *denorm //antidote
) {
BOOL8 using_row; //as baseline
float blob_x_centre; //middle of blob
float blob_offset; //bottom miss
float top_offset; //top miss
float blob_x_height; //xh for this blob
inT16 segments; //no of segments
inT16 segment; //current segment
DENORM_SEG *segs; //array of segments
float mean_x; //mean xheight
inT32 x_count; //no of xs
TBOX word_box = bounding_box ();//word bounding box
TBOX blob_box; //blob bounding box
PBLOB_IT blob_it ((PBLOB_LIST *) & cblobs);
// blob iterator
PBLOB *blob;
LLSQ line; //fitted line
double line_m, line_c; //fitted line
//inverse norm
DENORM antidote (word_box.left () +
(word_box.right () - word_box.left ()) / 2.0,
bln_x_height / x_height, row);
if (!flags.bit (W_POLYGON)) {
WRONG_WORD.error ("WERD::baseline_normalise", ABORT,
"Need to poly approx");
}
if (flags.bit (W_NORMALIZED)) {
WRONG_WORD.error ("WERD::baseline_normalise", ABORT,
"Baseline unnormalised");
}
if (bln_numericmode) {
segs = new DENORM_SEG[blob_it.length ()];
segments = 0;
float factor; // For scaling to baseline normalised size.
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
blob->move (FCOORD (-antidote.origin (),
-blob_box.bottom ()));
factor = bln_x_height * 4.0f / (3 * blob_box.height ());
// Constrain the scale factor as target numbers should be either
// cap height already or xheight.
if (factor < antidote.scale())
factor = antidote.scale();
else if (factor > antidote.scale() * 1.5f)
factor = antidote.scale() * 1.5f;
blob->scale (factor);
blob->move (FCOORD (0.0, bln_baseline_offset));
segs[segments].xstart = blob->bounding_box().left();
segs[segments].ycoord = blob_box.bottom();
segs[segments++].scale_factor = factor;
}
antidote = DENORM (antidote.origin (), antidote.scale (),
0.0f, 0.0f, segments, segs, true, row);
delete [] segs;
//Repeat for rej blobs
blob_it.set_to_list ((PBLOB_LIST *) & rej_cblobs);
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
blob->move (FCOORD (-antidote.origin (),
-blob_box.bottom ()));
blob->scale (bln_x_height * 4.0f / (3 * blob_box.height ()));
blob->move (FCOORD (0.0, bln_baseline_offset));
}
}
else if (bln_blshift_maxshift < 0) {
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
blob_x_centre = blob_box.left () +
(blob_box.right () - blob_box.left ()) / 2.0;
blob->move (FCOORD (-antidote.origin (),
-(row->base_line (blob_x_centre))));
blob->scale (antidote.scale ());
blob->move (FCOORD (0.0, bln_baseline_offset));
}
//Repeat for rej blobs
blob_it.set_to_list ((PBLOB_LIST *) & rej_cblobs);
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
blob_x_centre = blob_box.left () +
(blob_box.right () - blob_box.left ()) / 2.0;
blob->move (FCOORD (-antidote.origin (),
-(row->base_line (blob_x_centre))));
blob->scale (antidote.scale ());
blob->move (FCOORD (0.0, bln_baseline_offset));
}
}
else {
mean_x = x_height;
x_count = 1;
segs = new DENORM_SEG[blob_it.length ()];
segments = 0;
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
if (blob_box.height () > bln_blshift_xfraction * x_height) {
blob_x_centre = blob_box.left () +
(blob_box.right () - blob_box.left ()) / 2.0;
blob_offset =
blob_box.bottom () - row->base_line (blob_x_centre);
top_offset = blob_offset + blob_box.height () - x_height - 1;
blob_x_height = top_offset + x_height;
if (top_offset < 0)
top_offset = -top_offset;
if (blob_offset < 0)
blob_offset = -blob_offset;
if (blob_offset < bln_blshift_maxshift * x_height) {
segs[segments].ycoord = blob_box.bottom ();
line.add (blob_x_centre, blob_box.bottom ());
if (top_offset < bln_blshift_maxshift * x_height) {
segs[segments].scale_factor = blob_box.height () - 1.0f;
x_count++;
}
else
segs[segments].scale_factor = 0.0f;
//fix it later
}
else {
//not a goer
segs[segments].ycoord = -MAX_INT32;
if (top_offset < bln_blshift_maxshift * x_height) {
segs[segments].scale_factor = blob_x_height;
x_count++;
}
else
segs[segments].scale_factor = 0.0f;
//fix it later
}
}
else {
segs[segments].scale_factor = 0.0f;
segs[segments].ycoord = -MAX_INT32;
}
segs[segments].xstart = blob_box.left ();
segments++;
}
using_row = line.count () <= 1;
if (!using_row) {
line_m = line.m ();
line_c = line.c (line_m);
}
else
line_m = line_c = 0;
segments = 0;
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
blob_x_centre = blob_box.left () +
(blob_box.right () - blob_box.left ()) / 2.0;
if (segs[segments].ycoord == -MAX_INT32
&& segs[segments].scale_factor != 0 && !using_row) {
blob_offset = line_m * blob_x_centre + line_c;
segs[segments].scale_factor = blob_box.top () - blob_offset;
}
if (segs[segments].scale_factor != 0)
mean_x += segs[segments].scale_factor;
segments++;
}
mean_x /= x_count;
// printf("mean x=%g, count=%d, line_m=%g, line_c=%g\n",
// mean_x,x_count,line_m,line_c);
segments = 0;
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
blob_x_centre = blob_box.left () +
(blob_box.right () - blob_box.left ()) / 2.0;
if (segs[segments].ycoord != -MAX_INT32)
blob_offset = (float) segs[segments].ycoord;
else if (using_row)
blob_offset = row->base_line (blob_x_centre);
else
blob_offset = line_m * blob_x_centre + line_c;
if (segs[segments].scale_factor == 0)
segs[segments].scale_factor = mean_x;
segs[segments].scale_factor =
bln_x_height / segs[segments].scale_factor;
// printf("Blob sf=%g, top=%d, bot=%d, base=%g\n",
// segs[segments].scale_factor,blob_box.top(),
// blob_box.bottom(),blob_offset);
blob->move (FCOORD (-antidote.origin (), -blob_offset));
blob->
scale (FCOORD (antidote.scale (), segs[segments].scale_factor));
blob->move (FCOORD (0.0, bln_baseline_offset));
segments++;
}
//Repeat for rej blobs
blob_it.set_to_list ((PBLOB_LIST *) & rej_cblobs);
segment = 0;
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
blob_box = blob->bounding_box ();
blob_x_centre = blob_box.left () +
(blob_box.right () - blob_box.left ()) / 2.0;
while (segment < segments - 1
&& segs[segment + 1].xstart <= blob_x_centre)
segment++;
if (segs[segment].ycoord != -MAX_INT32)
blob_offset = (float) segs[segment].ycoord;
else if (using_row)
blob_offset = row->base_line (blob_x_centre);
else
blob_offset = line_m * blob_x_centre + line_c;
blob->move (FCOORD (-antidote.origin (), -blob_offset));
blob->
scale (FCOORD (antidote.scale (), segs[segment].scale_factor));
blob->move (FCOORD (0.0, bln_baseline_offset));
}
if (line.count () > 0 || x_count > 1)
antidote = DENORM (antidote.origin (), antidote.scale (),
line_m, line_c, segments, segs, using_row, row);
delete[]segs;
}
if (denorm != NULL)
*denorm = antidote;
//it's normalised
flags.set_bit (W_NORMALIZED, TRUE);
}
/**********************************************************************
* WERD::baseline_denormalise
*
* Baseline DeNormalise the word in Tesseract style. (I.e origin at centre of
* word at bottom. x-height region scaled to region y =
* (bln_baseline_offset)..(bln_baseline_offset + bln_x_height)
* - usually 64..192)
**********************************************************************/
void WERD::baseline_denormalise( // Tess style BL Norm
const DENORM *denorm //antidote
) {
PBLOB_IT blob_it ((PBLOB_LIST *) & cblobs);
// blob iterator
PBLOB *blob;
if (!flags.bit (W_NORMALIZED)) {
WRONG_WORD.error ("WERD::baseline_denormalise", ABORT,
"Baseline normalised");
}
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list (); blob_it.forward ()) {
blob = blob_it.data ();
//denormalise it
blob->baseline_denormalise (denorm);
}
//Repeat for rej blobs
blob_it.set_to_list ((PBLOB_LIST *) & rej_cblobs);
for (blob_it.mark_cycle_pt (); !blob_it.cycled_list (); blob_it.forward ()) {
blob = blob_it.data ();
//denormalise it
blob->baseline_denormalise (denorm);
}
//it's not normalised
flags.set_bit (W_NORMALIZED, FALSE);
}
/**********************************************************************
* WERD::print
*
* Display members
**********************************************************************/
void WERD::print( //print
FILE * //file to print on
) {
tprintf ("Blanks= %d\n", blanks);
bounding_box ().print ();
tprintf ("Flags = %d = 0%o\n", flags.val, flags.val);
tprintf (" W_SEGMENTED = %s\n",
flags.bit (W_SEGMENTED) ? "TRUE" : "FALSE ");
tprintf (" W_ITALIC = %s\n", flags.bit (W_ITALIC) ? "TRUE" : "FALSE ");
tprintf (" W_BOL = %s\n", flags.bit (W_BOL) ? "TRUE" : "FALSE ");
tprintf (" W_EOL = %s\n", flags.bit (W_EOL) ? "TRUE" : "FALSE ");
tprintf (" W_NORMALIZED = %s\n",
flags.bit (W_NORMALIZED) ? "TRUE" : "FALSE ");
tprintf (" W_POLYGON = %s\n", flags.bit (W_POLYGON) ? "TRUE" : "FALSE ");
tprintf (" W_LINEARC = %s\n", flags.bit (W_LINEARC) ? "TRUE" : "FALSE ");
tprintf (" W_DONT_CHOP = %s\n",
flags.bit (W_DONT_CHOP) ? "TRUE" : "FALSE ");
tprintf (" W_REP_CHAR = %s\n",
flags.bit (W_REP_CHAR) ? "TRUE" : "FALSE ");
tprintf (" W_FUZZY_SP = %s\n",
flags.bit (W_FUZZY_SP) ? "TRUE" : "FALSE ");
tprintf (" W_FUZZY_NON = %s\n",
flags.bit (W_FUZZY_NON) ? "TRUE" : "FALSE ");
tprintf ("Correct= %s\n", correct.string ());
tprintf ("Rejected cblob count = %d\n", rej_cblobs.length ());
}
/**********************************************************************
* WERD::plot
*
* Draw the WERD in the given colour.
**********************************************************************/
#ifndef GRAPHICS_DISABLED
void WERD::plot( //draw it
ScrollView* window, //window to draw in
ScrollView::Color colour, //colour to draw in
BOOL8 solid //draw larcs solid
) {
if (flags.bit (W_POLYGON)) {
//polygons
PBLOB_IT it = (PBLOB_LIST *) (&cblobs);
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
it.data ()->plot (window, colour, colour);
}
}
// else if (flags.bit(W_LINEARC))
// {
// LARC_BLOB_IT it=(LARC_BLOB_LIST*)(&cblobs);
// for ( it.mark_cycle_pt(); !it.cycled_list(); it.forward() )
// {
// it.data()->plot(window,solid,colour,solid ? BLACK : colour);
// }
// }
else {
C_BLOB_IT it = &cblobs; //blobs of WERD
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
it.data ()->plot (window, colour, colour);
}
}
plot_rej_blobs(window, solid);
}
#endif
/**********************************************************************
* WERD::plot
*
* Draw the WERD in rainbow colours.
**********************************************************************/
#ifndef GRAPHICS_DISABLED
void WERD::plot( //draw it
ScrollView* window, //window to draw in
BOOL8 solid //draw larcs solid
) {
ScrollView::Color colour = FIRST_COLOUR; //current colour
if (flags.bit (W_POLYGON)) {
//polygons
PBLOB_IT it = (PBLOB_LIST *) (&cblobs);
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
it.data ()->plot (window, colour, CHILD_COLOUR);
colour = (ScrollView::Color) (colour + 1);
if (colour == LAST_COLOUR)
colour = FIRST_COLOUR; //cycle round
}
}
// else if (flags.bit(W_LINEARC))
// {
// LARC_BLOB_IT it=(LARC_BLOB_LIST*)(&cblobs);
// for ( it.mark_cycle_pt(); !it.cycled_list(); it.forward() )
// {
// it.data()->plot(window,solid,colour,solid ? BLACK : CHILD_COLOUR);
// colour=(COLOUR)(colour+1);
// if (colour==LAST_COLOUR)
// colour=FIRST_COLOUR;
// }
// }
else {
C_BLOB_IT it = &cblobs; //blobs of WERD
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
it.data ()->plot (window, colour, CHILD_COLOUR);
colour = (ScrollView::Color) (colour + 1);
if (colour == LAST_COLOUR)
colour = FIRST_COLOUR; //cycle round
}
}
plot_rej_blobs(window, solid);
}
#endif
/**********************************************************************
* WERD::plot_rej_blobs
*
* Draw the WERD rejected blobs - ALWAYS GREY
**********************************************************************/
#ifndef GRAPHICS_DISABLED
void WERD::plot_rej_blobs( //draw it
ScrollView* window, //window to draw in
BOOL8 solid //draw larcs solid
) {
if (flags.bit (W_POLYGON)) {
PBLOB_IT it = (PBLOB_LIST *) (&rej_cblobs);
//polygons
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
it.data ()->plot (window, ScrollView::GREY, ScrollView::GREY);
}
} else {
C_BLOB_IT it = &rej_cblobs; //blobs of WERD
for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
it.data ()->plot (window, ScrollView::GREY, ScrollView::GREY);
}
}
}
#endif
/**********************************************************************
* WERD::shallow_copy()
*
* Make a shallow copy of a word
**********************************************************************/
WERD *WERD::shallow_copy() { //shallow copy
WERD *new_word = new WERD;
new_word->blanks = blanks;
new_word->flags = flags;
new_word->dummy = dummy;
new_word->correct = correct;
return new_word;
}
/**********************************************************************
* WERD::operator=
*
* Assign a word, DEEP copying the blob list
**********************************************************************/
WERD & WERD::operator= ( //assign words
const WERD & source //from this
) {
this->ELIST_LINK::operator= (source);
blanks = source.blanks;
flags = source.flags;
dummy = source.dummy;
correct = source.correct;
if (flags.bit (W_POLYGON)) {
if (!cblobs.empty ())
reinterpret_cast<PBLOB_LIST*>(&cblobs)->clear();
reinterpret_cast<PBLOB_LIST*>(&cblobs)->deep_copy(
reinterpret_cast<const PBLOB_LIST*>(&source.cblobs), &PBLOB::deep_copy);
if (!rej_cblobs.empty ())
reinterpret_cast<PBLOB_LIST*>(&rej_cblobs)->clear();
reinterpret_cast<PBLOB_LIST*>(&rej_cblobs)->deep_copy(
reinterpret_cast<const PBLOB_LIST*>(&source.rej_cblobs),
&PBLOB::deep_copy);
} else {
if (!cblobs.empty ())
cblobs.clear ();
cblobs.deep_copy(&source.cblobs, &C_BLOB::deep_copy);
if (!rej_cblobs.empty ())
rej_cblobs.clear ();
rej_cblobs.deep_copy(&source.rej_cblobs, &C_BLOB::deep_copy);
}
return *this;
}
/**********************************************************************
* word_comparator()
*
* word comparator used to sort a word list so that words are in increasing
* order of left edge.
**********************************************************************/
int word_comparator( //sort blobs
const void *word1p, //ptr to ptr to word1
const void *word2p //ptr to ptr to word2
) {
WERD *
word1 = *(WERD **) word1p;
WERD *
word2 = *(WERD **) word2p;
return word1->bounding_box ().left () - word2->bounding_box ().left ();
}