voids.c

NIST Handwriting OCR Testbed

/*
# proc: unerase_short_voids_ml - refills short voids between character pices based on one
# proc:               of the pieces abutting to the void with a slice width "close" to
# proc:               the locally dynamic median line width.
# proc: unerase_curved_voids_ml - refills voids based on the intersection of slope
# proc:                trajectories using a vector of locally dynamic median line widths.
# proc: join_nbrs_on_top - refills voids based on the intersection of slope trajectories
# proc:                    measured from 2 nbring character pieces sitting on top the line.
# proc: join_nbrs_below - refills voids based on the intersection of slope trajectories
# proc:                   measured from 2 nbring character pieces touching along the bottom
# proc:                   of the line.
# proc: right_vert_clear - checks if right edge is vertically clear of character data above
# proc:                    and below.
# proc: left_vert_clear - checks if left edge is vertically clear of character data above
# proc:                   and below.
# proc: top_left_hori_clear - checks if top-left edge is horizontally clear of character data.
# proc:
# proc: top_right_hori_clear - checks if top-right edge is horizontally clear of
# proc:                        character data.
# proc:
# proc: bottom_left_hori_clear - checks if bot-left edge is horizontally clear of
# proc:                          character data.
# proc: bottom_right_hori_clear - checks if bot-right edge is horizontally clear of
# proc:                          character data.
*/

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

/***************************************************************************/
/* unserase_short_voids - refills short voids between character pieces     */
/* based on one of the pieces abutting to the void with a slice width      */
/* "close" to the median line width. This routine is useful to join left   */
/* and right pices of horizontal stokes separated by a short void where    */
/* the original stroke overlapped close enough with the line to be         */
/* partially erased.                                                       */
/***************************************************************************/
/***************************************************************************/
unerase_short_voids_ml(ebin, msws, sw, fsy, tsy, nsw, cdata, w, h)
int *ebin, *msws, *sw, *fsy, *tsy, nsw;
unsigned char *cdata;
int w, h;
{
   int i, rs, re, nextbin;
   int limit, rlen;

   my_trace("entered unerase_short_voids_ml\n");
   nextbin = 0;
   while(next_n_run(ERASED, &rs, &re, nextbin, ebin, nsw)){
      limit = max(MIN_SHORT_VOID, sround(SHORT_VOID_FCTR*msws[rs]));
      my_trace2("next void from %d to %d\n", rs, re);
      if((rs > 0) && (re < nsw-1)){
         rlen = re - rs + 1;
         /* if void is short enough ... */
         if(rlen < limit){
            /* test nbring character pieces */
            if((sw[rs-1] <= msws[rs]+SMALL_NOISE) ||
               (sw[re+1] <= msws[re]+SMALL_NOISE)){
               my_trace("unerase void\n");
               for(i = rs; i <= re; i++){
                  if(sw[i] != 0)
                     draw_slice_hori(1, i, fsy[i], tsy[i], cdata, w, h);
                  ebin[i] = UNERASED;
               }
            }
         }
      }
      nextbin = re+1;
   }
   my_trace("finished unerase_short_voids_ml\n");
}

/***************************************************************************/
/* unerase_curved_voids - refills erased voids based on the intersection   */
/* of slope trajectories measured from two neighboring character pieces.   */
/* This routine is useful to join left and right pieces of curvatures,     */
/* such as a hole in the top or bottom of a zero.                          */
/***************************************************************************/
/***************************************************************************/
unerase_curved_voids_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;
   int lrs, lre, rrs, rre;
   float lm, rm;
   float slope_left_above(), slope_right_above();
   float slope_left_below(), slope_right_below();
   int slimit, x, max_x;

   my_trace("entered unerase_curved_voids_ml\n");
   max_x = w-1;
   nextbin = 0;
   /* slices not erased to this point are assumed to be pieces of characters */
   /* find the left character piece */
   if(next_n_run(0, &lrs, &lre, nextbin, ebin, nsw)){
      slimit = step_limit(msws[lre]);
      nextbin = lre+1;
      /* find the next right character piece ... */
      while(next_n_run(0, &rrs, &rre, nextbin, ebin, nsw)){
         nextbin = rre+1;
         my_trace2("left char piece from %d to %d\n", lrs, lre);
         my_trace2("right char piece from %d to %d\n", rrs, rre);
         /* check if left and right edges of the void are vertically clear - */
         /* we are looking for places severed completely through a horizontal */
         /* stroke at the top or the bottom of a potentially curved character */
         if((right_vert_clear(lrs,lre,fsy,tsy,msws[lre],nsw,cdata,w,h)) &&
            (left_vert_clear(rrs,rre,fsy,tsy,msws[rrs],nsw,cdata,w,h))){
            my_trace("void has vertically clear edges\n");
            /* is only character data potentially touching the top of the line? */
            if((bottom_right_hori_clear(lrs, lre, fsy, tsy,msws[lre],nsw, cdata, w, h)) &&
               (bottom_left_hori_clear(rrs, rre, fsy, tsy,msws[rrs],nsw, cdata, w, h))){
               my_trace("character data maybe touching top of line\n");
               /* get slope from left char piece's right edge */
               x = min(lre+1, max_x);
               lm = slope_right_above(x, fsy[x], slimit, RUN_DYS, cdata, w, h);
               my_trace1("left nbr slope = %f\n", lm);
               /* get slope from right char piece's left edge */
               x = max(0, rrs-1);
               rm = slope_left_above(x, fsy[x], slimit, RUN_DYS, cdata, w, h);
               my_trace1("right nbr slope = %f\n", rm);
               /* test to join nboring char pieces based on intersection of slopes */
               join_nbrs_on_top(lm, lrs, lre, rm, rrs, rre, fsy, tsy, ebin, sw, nsw,
                                msws[lre], cdata, w, h);
            /* is only character data potentially touching the bottom of the line? */
            }else if((top_right_hori_clear(lrs,lre,fsy,tsy,msws[lre],nsw,cdata,w,h)) &&
               (top_left_hori_clear(rrs, rre, fsy, tsy, msws[rrs], nsw, cdata, w, h))){
               my_trace("character data maybe touching bottom of line\n");
               /* get slope from left char piece's right edge */
               x = min(lre+1, max_x);
               lm = slope_right_below(x, tsy[x], slimit, RUN_DYS, cdata, w, h);
               my_trace1("left nbr slope = %f\n", lm);
               /* get slope from right char piece's left edge */
               x = max(0, rrs-1);
               rm = slope_left_below(x, tsy[x], slimit, RUN_DYS, cdata, w, h);
               my_trace1("right nbr slope = %f\n", rm);
               /* test to join nboring char pieces based on intersection of slopes */
               join_nbrs_below(lm, lrs, lre, rm, rrs, rre, fsy, tsy, ebin, sw, nsw,
                               msws[lre], cdata, w, h);
            }
         }
         /* right char piece becomes left char piece */
         lrs = rrs;
         lre = rre;
      }
   }
   my_trace("finished unerase_curved_voids_ml\n");
}

/***************************************************************************/
/* join_nbrs_on_top - refills erased voids based on the intersection of    */
/* slope trajectories measured from two neighboring character pieces       */
/* sitting on top of the line.                                             */
/***************************************************************************/
join_nbrs_on_top(lm, lrs, lre, rm, rrs, rre, fsy, tsy, ebin, sw, nsw, msw, cdata, w, h)
float lm, rm;
int lrs, lre, rrs, rre;
int *fsy, *tsy, *ebin, *sw, nsw, msw;
unsigned char *cdata;
int w, h;
{
   int i, ix, iy, ty, by;
   int lx, rx, limit;

   my_trace("entered join_nbrs_on_top\n");
   /* form the bounding box within which intersections will be accepted */
   lx = min(lre+1, nsw-1);
   rx = max(0, rrs-1);
   my_trace2("void from %d to %d\n", lx, rx);
   ty = min(fsy[lx], fsy[rx]);
   by = max(tsy[lx], tsy[rx]);

   /* set a limit on the length of the void to avoid rediculous unerasures */
   limit = max(MIN_CURVE_VOID, sround(CURVE_VOID_FCTR*msw));

   /* to be compatible: */
   /* the left nbr slope must be positive and right nbr slope must be negative */
   if((lm >= 0) && ((rm == MAXFLOAT) || (rm <= 0)) &&
      /* to account for annomalies in the measured slopes: */
      /* one side is not permitted to be "perfectly" vertical with the other */
      /* side "perfectly" horizontal */
      ((lm != MAXFLOAT) || (rm != 0.0)) &&
      ((rm != MAXFLOAT) || (lm != 0.0)) &&
      /* the length of the void must not exceed the limit */
      ((rx - lx + 1) < limit) &&
      /* an intersection between the two slopes must exist (ie. slopes not parallel) */
      (pt_intersect(&ix, &iy, lx, fsy[lx], lm, rx, fsy[rx], rm))){

      my_trace3("left line: pt = (%d, %d) slope = %f\n", lx, fsy[lx], lm);
      my_trace3("right line: pt = (%d, %d) slope = %f\n", rx, fsy[rx], rm);
      my_trace2("intersection at (%d, %d)\n", ix, iy);
      /* if intersection point is within the rectangular region of acceptance ... */
      if((is_in_range(ix, lx, rx) && (is_in_range(iy, ty, by)))){
         /* unerase the void */
         my_trace("unerase void\n");
         for(i = lx; i <= rx; i++){
            if(sw[i] != 0)
               draw_slice_hori(1, i, fsy[i], tsy[i], cdata, w, h);
            ebin[i] = UNERASED;
         }