parseutils.cpp

Ocr source code. provides an Ocr engine that works in C++ language.

/* parseutils.cpp : code for utils to parse and handle scans
 * Author: Maxie D. Schmidt (created 5/26/2006)              */

#include "parseutils.h"

// externs default value:
double ZERO_INST_PR0_PGIVEN = 0.05;
double ZERO_INST_PR1_PGIVEN = 0.05;
double ZERO_INST_PR0_PGC = 0.01;
double ZERO_INST_PR1_PGC = 0.01;
double PR_SCALING_FACTOR = 10.0;

// lines:
box_t find_line_box(int entry_y, png_file *pfile) {

     if((pfile == NULL) || (!(pfile->is_valid))) {
          
          log_error(ERROR_INVALID_PNG_FILE, "in find_line_box", NULL);
          return NULL_BOX();

     }
     
     int upper_y = -1, lower_y = -1;
     bool upper_y_found = false, lower_y_found = false;
     for(int i = entry_y; i < (pfile->height - scan_ignore_edges_bottom); i++) {

          for(int j = (scan_ignore_edges_left - 1); j < (pfile->width - 
                                                scan_ignore_edges_right); j++) {

               if(pfile->grid(i, j)) {

                    upper_y = i;
                    upper_y_found = true;
                    break;

               }

          }

          if(upper_y_found)
               break;

     }
     if(upper_y == -1) // blank line
          return NULL_BOX();
    
     for(int i = (upper_y + 1); i < (pfile->height - scan_ignore_edges_bottom);
                                                                          i++) {

          for(int j = (scan_ignore_edges_left - 1); j < (pfile->width - 
                                                scan_ignore_edges_right); j++) {

               if(pfile->grid(i, j))
                    break;
               else if(j == (pfile->width - scan_ignore_edges_right - 1)) {

                    lower_y = i - 1;
                    lower_y_found = true;
                    break;

               }

          }

          if(lower_y_found)
               break;

     }
     if(lower_y == -1) 
          lower_y = pfile->height - scan_ignore_edges_bottom - 1;
     
     return create_box(scan_ignore_edges_left, upper_y, lower_y - upper_y + 1, 
                       pfile->width - scan_ignore_edges_left - 
                       scan_ignore_edges_right);

}

// traverse char:
xy_point n_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x;
     r_val.y = pt.y - 1;
     
     return r_val;

}

xy_point ne_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x + 1;
     r_val.y = pt.y - 1;
     
     return r_val;

}    

xy_point e_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x + 1;
     r_val.y = pt.y;
     
     return r_val;

}

xy_point se_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x + 1;
     r_val.y = pt.y + 1;
     
     return r_val;

}

xy_point s_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x;
     r_val.y = pt.y + 1;
     
     return r_val;

}

xy_point sw_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x - 1;
     r_val.y = pt.y + 1;
     
     return r_val;

}

xy_point w_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x - 1;
     r_val.y = pt.y;
     
     return r_val;

}

xy_point nw_point(xy_point pt) {
     
     xy_point r_val;
     r_val.x = pt.x - 1;
     r_val.y = pt.y - 1;
     
     return r_val;

}

box_points traverse_char(xy_point entry_point, png_file *pfile) {

     if((pfile == NULL) || (!pfile->is_valid)) {

          log_error(ERROR_INVALID_PNG_FILE, "in traverse_char", NULL);
          return NULL_PTS();

     }
     else if((entry_point.y >= pfile->height) || (entry_point.x >= pfile->width)
               || (entry_point.y < 0) || (entry_point.x < 0)) {

          log_error(ERROR_OUT_OF_BOUNDS, "in traverse_char: entry_point", NULL);
          return NULL_PTS();

     }
     else if(!(pfile->grid(entry_point.y, entry_point.x)))
          return NULL_PTS();

     box_points r_val, cur_val;
     r_val.r_most = r_val.l_most = r_val.t_most = r_val.b_most = entry_point;
     pfile->mark(entry_point.y, entry_point.x);
     
     // start traversing in all directions:
     // NORTH:
     cur_val = traverse_char(n_point(entry_point), NORTH, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);
     
     // NORTHEAST:
     cur_val = traverse_char(ne_point(entry_point), NORTHEAST, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);

     // EAST:
     cur_val = traverse_char(e_point(entry_point), EAST, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);

     // SOUTHEAST:
     cur_val = traverse_char(se_point(entry_point), SOUTHEAST, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);

     // SOUTH:
     cur_val = traverse_char(s_point(entry_point), SOUTH, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);
    
     // SOUTHWEST:
     cur_val = traverse_char(sw_point(entry_point), SOUTHWEST, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);

     // WEST:
     cur_val = traverse_char(w_point(entry_point), WEST, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);

     // NORTHWEST:
     cur_val = traverse_char(nw_point(entry_point), NORTHWEST, pfile);
     if( !equals_NULL_PTS(cur_val) )
          r_val = find_biggest_box(cur_val, r_val);

     return r_val;

}

box_points traverse_char(xy_point entry_point, direction_t d, png_file *pfile) {

     // error checking: out of bounds, 0, visited
     if( (entry_point.x < 0) || (entry_point.y < 0) || 
          (entry_point.y >= pfile->height) || (entry_point.x >= pfile->width) )
          return NULL_PTS();
     else if(!pfile->grid(entry_point.y, entry_point.x))
          return NULL_PTS();
     else if(pfile->is_marked(entry_point.y, entry_point.x)) // already visited
          return NULL_PTS();

     // now, entry point ok:
     box_points r_val, cur_val;
     r_val.r_most = r_val.l_most = r_val.t_most = r_val.b_most = entry_point;
     pfile->mark(entry_point.y, entry_point.x); // mark current spot
     
     if(d == NORTH) {
          
          cur_val = traverse_char(n_point(entry_point), NORTH, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(nw_point(entry_point), NORTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(ne_point(entry_point), NORTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }
     else if(d == NORTHEAST) {
         
          cur_val = traverse_char(ne_point(entry_point), NORTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(n_point(entry_point), NORTH, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(e_point(entry_point), EAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);
          
          cur_val = traverse_char(se_point(entry_point), SOUTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(nw_point(entry_point), NORTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }
     else if(d == EAST) {

          cur_val = traverse_char(e_point(entry_point), EAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(ne_point(entry_point), NORTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(se_point(entry_point), SOUTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }
     else if(d == SOUTHEAST) {

          cur_val = traverse_char(se_point(entry_point), SOUTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(e_point(entry_point), EAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(s_point(entry_point), SOUTH, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);
         
          cur_val = traverse_char(ne_point(entry_point), NORTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(sw_point(entry_point), SOUTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }
     else if(d == SOUTH) {

          cur_val = traverse_char(s_point(entry_point), SOUTH, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(se_point(entry_point), SOUTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(sw_point(entry_point), SOUTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }
     else if(d == SOUTHWEST) {

          cur_val = traverse_char(sw_point(entry_point), SOUTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(s_point(entry_point), SOUTH, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(w_point(entry_point), WEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);
          
          cur_val = traverse_char(nw_point(entry_point), SOUTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(ne_point(entry_point), NORTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }
     else if(d == WEST) {
 
          cur_val = traverse_char(w_point(entry_point), WEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(nw_point(entry_point), NORTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(sw_point(entry_point), SOUTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }
     else if(d == NORTHWEST) {

          cur_val = traverse_char(nw_point(entry_point), NORTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(n_point(entry_point), NORTH, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(w_point(entry_point), WEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(sw_point(entry_point), SOUTHWEST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

          cur_val = traverse_char(ne_point(entry_point), NORTHEAST, pfile);
          if( !equals_NULL_PTS(cur_val) )
               r_val = find_biggest_box(r_val, cur_val);

     }

     return r_val;
     
}

// find chars:
vector<box_t> find_chars(box_t line_box, png_file *pfile) {

     // get entry_points:
     vector<xy_point> entry_points;
     for(int i = line_box.xy.y; i < (line_box.xy.y + line_box.vert_len); 
                                                     i += trcfg_intersect_px) {
          for(int j = line_box.xy.x; j < (line_box.xy.x + line_box.horiz_len);
                                                                         j++) {
               
               if(pfile->grid(i, j))
                    entry_points.push_back(create_xy_point(j, i));

          }

     }

     // get chars (unsorted):
     vector<box_t> chars;
     box_points char_pts;
     box_t char_box;
     
     for(int k = 0; k < entry_points.size(); k++) {

          pfile->cleanup_tracks();
          char_pts = traverse_char(entry_points[k], pfile);
          if(equals_NULL_PTS(char_pts)) {
               continue;
          }
          char_box = extreme_points_to_box(char_pts);
          if(chars.size() == 0)
               chars.push_back(char_box);
          else {
          
               for(int i = 0; i < chars.size(); i++) {
     
                    if(box_equals_box(chars[i], char_box))
                         break;
                    if(i == (chars.size() - 1))
                         chars.push_back(char_box);
     
               }

          }
          
     }

     // refine list:
     //chars = remove_duplicates(chars);
     chars = sort_boxes_ltor(chars);

     return chars;

}

// parse_list should be empty to begin with:
bool fill_parse_list(int_interval_t line_int, png_file *pfile, 
                                                           parse_list *plist) {
     
     if(pfile == NULL) {

          log_error(ERROR_INVALID_PNG_FILE, "fill_parse_list: NULL", NULL);
          return false;

     }
     else if(!pfile->is_valid) {

          log_error(ERROR_INVALID_PNG_FILE, "fill_parse_list: !is_valid", NULL);
          return false;

     }
     else if(plist->pl_begin != NULL) {

          log_error(ERROR_PARSE_ERROR, "fill_parse_list: list not empty", NULL);
          return false;

     }
     
     // check the interval:
     if(line_int.lower <= 0) {

          log_error(ERROR_INVALID_INTERVAL, "interval.lower <= 0", NULL);
          return false;
     
     }
     else if(line_int.lower > line_int.upper) {