chrpiece.c

NIST Handwriting OCR Testbed

/*
# proc: process_char_pieces_ml - shapes and smooths stems and descenders of character
# proc:              strokes that intersect the lines using a locally dynamic vector
# proc:              of median line widths.
# proc: identify_char_piece - categorizes the character piece by examining
# proc:              its left and right edges.
# proc: extract_shape_features - computes 4 features used to represent the
# proc:              character piece.
# proc: process_char_piece - main switch for shaping and smoothing a character
# proc:              piece based on its identified type.
*/

#include <stdio.h>
#include <defs.h>
#include <rmline.h>
#include <mytrace.h>

/***************************************************************************/
/* process_char_pieces - cleans up the portions of the characters around   */
/* where they intersected the removed line. This routine shapes and        */
/* smooths stems and descenders.                                           */
/***************************************************************************/
/***************************************************************************/
process_char_pieces_ml(ebin, msws, sw, fsy, tsy, nsw, cdata, w, h)
int *ebin, *msws, *sw, *fsy, *tsy, nsw;
unsigned char *cdata;
int w, h;
{
   int nextbin, chartype;
   int rs, re;

   nextbin = 0;
   /* any slice not erased to this point is assumed to belong to a character */
   while(next_n_run(0, &rs, &re, nextbin, ebin, nsw)){
      nextbin = re+1;
      /* identify the shape of the piece */
      chartype = identify_char_piece(rs, re, fsy, tsy, nsw, w, h);
      /* process the piece of character */
      process_char_piece(chartype, rs, re, msws[rs], ebin, sw, fsy, tsy, nsw, cdata, w, h);
   }
}

/***************************************************************************/
/* identify_char_piece - attempts to categorize the shape of a contiguous  */
/* run of slices potentially containing both character and line data. It   */
/* does this by simply looking at the left and right edges of the run, and */
/* determining if data exists above or below the the line being removed.   */
/***************************************************************************/
identify_char_piece(rs, re, fsy, tsy, nsw, w, h)
int rs, re, *fsy, *tsy, nsw;
int w, h;
{
   int lb, la;
   int rb, ra;

   /* if only one slice, then really don't know what it is */
   if(nsw == 1)
      return(RUN_UNKNOWN);

   /* identification is conducted based on four extracted features. */
   /* these features represent whether character data touch above   */
   /* and/or below the line on the left and right sides of the      */
   /* current run of slices. to measure this, the position of the   */
   /* last nbring slice previously erased is subtracted from the    */
   /* corresponding edge of the run of current slices. if the delta */
   /* is positive then character data is "assumed" to touch in that */
   /* area. this measurement works because the previously erased    */
   /* slice was removed because it was determined to "completely"   */
   /* part of the line. this provides a reference to the relative   */
   /* location of the line, from which the features can be measured.*/

   /* extract the four features */
   extract_shape_features(&la, &lb, &ra, &rb, rs, re, fsy, tsy, nsw);

   /* now try to identify the run of slices based on the four features */
   if(is_boot(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] boot\n", rs, re);
      return(RUN_BOOT);
   }
   if(is_hat(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] hat\n", rs, re);
      return(RUN_HAT);
   }
   if(is_ncross(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] negative crossover\n", rs, re);
      return(RUN_NCROSS);
   }
   if(is_pcross(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] positive crossover\n", rs, re);
      return(RUN_PCROSS);
   }
   if(is_thru_dl(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] thru down and left\n", rs, re);
      return(RUN_THRU_DL);
   }
   if(is_thru_dr(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] thru down and right\n", rs, re);
      return(RUN_THRU_DR);
   }
   if(is_thru_ul(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] thru up and left\n", rs, re);
      return(RUN_THRU_UL);
   }
   if(is_thru_ur(lb, la, rb, ra)){
      my_trace2("run [%d .. %d] thru up and right\n", rs, re);
      return(RUN_THRU_UR);
   }
   /* the run may not fit into one of these 8 categories */
   /* in this case the run is simply ignored */
   my_trace2("run [%d .. %d] unidentified\n", rs, re);
   return(RUN_UNKNOWN);
}

/***************************************************************************/
/* extract_shape_features - computes the four features used to represent   */
/* whether character data touch above and/or below the line on the left    */
/* and right sides of the current run of unerased slices. To measure this, */
/* the position of the closest nbring erased slice is subtracted from the  */
/* corresponding edge of the run of unerased slices. If the delta is       */
/* positive then character data is "assumed" to touch in that area.        */
/***************************************************************************/
extract_shape_features(la, lb, ra, rb, rs, re, fsy, tsy, nsw)
int *la, *lb, *ra, *rb;
int rs, re, *fsy, *tsy, nsw;
{
   int lx, rx, max_x;

   /* extract the four features */
   lx = rs - 1;
   rx = re + 1;
   max_x = nsw - 1;
   *lb = tsy[rs] - tsy[max(0,lx)];
   *la = fsy[max(0,lx)] - fsy[rs];
   *rb = tsy[re] - tsy[min(rx, max_x)];
   *ra = fsy[min(rx, max_x)] - fsy[re];

   if(*lb > 0)
      my_trace("left edge: character data below line\n");
   if(*la > 0)
      my_trace("left edge: character data above line\n");
   if(*lb <= 0 && *la <= 0)
      my_trace("left edge: no character data found\n");

   if(*rb > 0)
      my_trace("right edge: character data below line\n");
   if(*ra > 0)
      my_trace("right edge: character data above line\n");
   if(*rb <= 0 && *ra <= 0)
      my_trace("right edge: no character data found\n");
}

/***************************************************************************/
/* process_char_piece - main switch for shaping and smoothing various      */
/* categories of character descenders and strokes that touch the line.     */
/***************************************************************************/
process_char_piece(chartype, rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh)
int chartype, rs, re, msw, *ebin, *sw, *fsy, *tsy, nsw;
unsigned char *cdata;
int fw, fh;
{
   switch(chartype){
   case RUN_BOOT:
      /* character data sitting on top of the line */
/*
                      \           /
                       \         /
                     ---------------
                       |x       x|
                       |xx     xx|
                     ---------------
*/
      process_boot(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   case RUN_HAT:
      /* character data touching the bottom of the line */
/*
                    ---------------
                      |xx     xx|
                      |x       x|
                    ---------------
                      /         \
                     /           \
*/
      process_hat(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   case RUN_NCROSS:
      /* character stroke with negative slope (downward right to left) */
      /* passing through the line */
/*
                          /       /
                         /       /
                   -----------------
                     |xx        x|
                     |x        xx|
                   -----------------
                     /       /
                    /       /
*/
      process_ncross(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   case RUN_PCROSS:
      /* character stroke with positive slope (downward left to right) */
      /* passing through the line */
/*
                    \       \
                     \       \
                   -----------------
                     |x        xx|
                     |xx        x|
                   -----------------
                         \       \
                          \       \
*/
      process_pcross(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   case RUN_THRU_DL:
      /* character stoke passing through and protruding on the */
      /* bottom left of the line */
/*
                       /        /
                      |        /
                   ----------------
                      |      xx|
                      |    xxxx|
                   ----------------
                      | /
                      |/
*/
      process_thru_dl(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   case RUN_THRU_DR:
      /* character stoke passing through and protruding on the */
      /* bottom right of the line */
/*
                     \        \
                      \        |
                   ----------------
                      |xx      |
                      |xxxx    |
                   ----------------
                             \ |
                              \|
*/
      process_thru_dr(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   case RUN_THRU_UL:
      /* character stoke passing through and protruding on the */
      /* top left of the line */
/*
                      |\
                      | \
                   ----------------
                      |    xxxx|
                      |      xx|
                   ----------------
                      |        \
                       \        \
*/
      process_thru_ul(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   case RUN_THRU_UR:
      /* character stoke passing through and protruding on the */
      /* top right of the line */
/*
                              /|
                             / |
                   ----------------
                      |xxxx    |
                      |xx      |
                   ----------------
                      /        |
                     /        /
*/
      process_thru_ur(rs, re, msw, ebin, sw, fsy, tsy, nsw, cdata, fw, fh);
   break;
   default:
      /* if character piece not identified, just ignore it and continue */
      my_trace("category of character piece not identified\n");
   break;
   }
}