werd.cpp

一ＯＣＲ的相关资料。．希望对研究ＯＣＲ的朋友有所帮助．

      //                              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
                WINDOW window,  //window to draw in
                COLOUR 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
                WINDOW window,  //window to draw in
                BOOL8 solid     //draw larcs solid
               ) {
  COLOUR 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 = (COLOUR) (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 = (COLOUR) (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
                          WINDOW 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, GREY, GREY);
    }
  }
  //      else if (flags.bit(W_LINEARC))
  //      {
  //              LARC_BLOB_IT                    it=(LARC_BLOB_LIST*)(&rej_cblobs);

  //              for ( it.mark_cycle_pt(); !it.cycled_list(); it.forward() )
  //              {
  //                      it.data()->plot(window,solid,GREY,solid ? BLACK : 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, GREY, 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 ())
      ((PBLOB_LIST *) (&cblobs))->clear ();
    ((PBLOB_LIST *) (&cblobs))->deep_copy ((PBLOB_LIST *) (&source.cblobs));

    if (!rej_cblobs.empty ())
      ((PBLOB_LIST *) (&rej_cblobs))->clear ();
    ((PBLOB_LIST *) (&rej_cblobs))->deep_copy ((PBLOB_LIST *) (&source.
      rej_cblobs));

  }
  //      else if (flags.bit(W_LINEARC))
  //      {
  //              if ( !cblobs.empty() )
  //                      ((LARC_BLOB_LIST*)(&cblobs))->clear();
  //              ((LARC_BLOB_LIST*)(&cblobs))->deep_copy(
  //                      (LARC_BLOB_LIST*)(&source.cblobs));

  //      if ( !rej_cblobs.empty() )
  //              rej_cblobs.clear();
  //              rej_cblobs.deep_copy( &source.rej_cblobs );
  //      }
  else {
    if (!cblobs.empty ())
      cblobs.clear ();
    cblobs.deep_copy (&source.cblobs);

    if (!rej_cblobs.empty ())
      rej_cblobs.clear ();
    rej_cblobs.deep_copy (&source.rej_cblobs);
  }
  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 ();
}