runutils.cpp

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

     if(dir == NULL) 
          return false;
     else {

          closedir(dir);
          return true;

     }

}

bool file_exists(string filename) {

     FILE *fp = fopen(filename.c_str(), "r");
     if(fp == NULL)
          return false;
     else {

          fclose(fp);
          return true;

     }

}

// error handling:
string resolve_local_error(int error_code) {

     switch(error_code) {

          case ERROR_NO_ERROR:
               return string("NO ERROR");
          case ERROR_OPENING_FILE:
               return string("ERROR OPENING FILE");
          case ERROR_BAD_MALLOC:
               return string("ERROR BAD MALLOC");
          case ERROR_INVALID_CONFIG_OPTION:
               return string("ERROR INVALID CONFIG OPTION");
          case ERROR_INVALID_INTERVAL:
               return string("ERROR INVALID INTERVAL");
          case ERROR_OUT_OF_BOUNDS:
               return string("ERROR OUT OF BOUNDS");
          case ERROR_PARSE_ERROR:
               return string("PARSE ERROR");
          case ERROR_GRID_ERROR:
               return string("GRID ERROR");
          case ERROR_PARSE_NO_GUI:
               return string("ERROR PARSE NO GUI");
          case ERROR_INVALID_PNG_FILE:
               return string("ERROR INVALID PNG FILE");
          case ERROR_PROFILE:
               return string("ERROR_PROFILE");
          case ERROR_PNG_READING_SIG:
               return string("ERROR PNG READING SIG");
          case ERROR_PNG_INCORRECT_SIG:
               return string("ERROR PNG INCORRECT SIG");
          case ERROR_PNG_PNG_PTR:
               return string("ERROR PNG PNG_PTR");
          case ERROR_PNG_INFO_PTR:
               return string("ERROR PNG INFO_PTR");
          case ERROR_PNG_SETJMP:
               return string("ERROR PNG SETJMP");
          default:
               return string("ERROR UNKNOWN");

     }

}

bool stamp_log_file(string stamp) {

     FILE *fp = fopen(cfg_log_file.c_str(), "a+");
     if(fp == NULL)
          return false;

     fputs(stamp.c_str(), fp);
     fclose(fp);
     
     return true;

}

bool log_error(int lerror_code, const char *msg, char *errno_msg) {
     
     string error_line = resolve_local_error(lerror_code);
     error_line = error_line + ": ";
     if(msg != NULL)
          error_line = error_line + msg + " ";
     if(errno_msg != NULL)
          error_line = error_line + "(errno msg = " + errno_msg + ")\n\n";
     else
          error_line = error_line + "(errno msg = none)\n\n";

     FILE *fp = fopen(cfg_log_file.c_str(), "a+");
     if(fp == NULL) {
          
          printf("log_error: fp is NULL\n");
          return false;
     
     }

     fputs(error_line.c_str(), fp);
     fclose(fp);

     return true;

}

void popup_message(Gtk::Window &window, string message) {

     Gtk::MessageDialog dialog(window, message);
     dialog.run();

}

/////// math:
int max(int x0, int x1) {

     return ((x0 > x1) ? x0 : x1);

}

int min(int x0, int x1) {

     return ((x0 < x1) ? x0 : x1);

}

// intervals:
int_interval_t create_interval(int lower, int upper) {

     int_interval_t r_val;
     r_val.lower = lower;
     r_val.upper = upper;

     return r_val;

}

rgb_interval_t create_interval(int Rl, int Ru, int Gl, int Gu, int Bl, int Bu) {

     rgb_interval_t interval;
     interval.Rl = Rl;
     interval.Ru = Ru;
     interval.Gl = Gl;
     interval.Gu = Gu;
     interval.Bl = Bl;
     interval.Bu = Bu;

     return interval;

}

bool within_interval(int value, int_interval_t interval, bool ends_inclusive) {

     if(ends_inclusive && (value >= interval.lower) && 
                                                   (value <= interval.upper))
          return true;
     else if(!ends_inclusive && (value > interval.lower) &&
                                                    (value < interval.upper))
          return true;

     return false;

}

bool within_interval(int R, int G, int B, rgb_interval_t interval) {

     if((R >= interval.Rl) && (R <= interval.Ru) && (G >= interval.Gl) && 
        (R <= interval.Gu) && (R >= interval.Bl) && (R <= interval.Bu))
          return true;

     return false;

}

// checks against NULL for types:
bool equals_NULL_POINT(xy_point pt) {

     if((pt.x == -1) && (pt.y == -1))
          return true;
     else
          return false;

}

bool equals_NULL_BOX(box_t box) {

     if(equals_NULL_POINT(box.xy))
          return true;
     else 
          return false;

}

bool equals_NULL_PTS(box_points pts) {

     if((pts.r_most.x == -1) && (pts.r_most.y == -1))
          return true;
     else
          return false;

}

// xy_point:
xy_point create_xy_point(int x, int y) {

     xy_point r_val;
     r_val.x = x;
     r_val.y = y;

     return r_val;

}

// boxes:
box_t create_box(int lcorner_x, int lcorner_y, int vlen, int hlen) {

     box_t r_val;
     r_val.xy.x = lcorner_x;
     r_val.xy.y = lcorner_y;
     r_val.vert_len = vlen;
     r_val.horiz_len = hlen;

     return r_val;

}

box_t extreme_points_to_box(box_points pts) {

     box_t r_val;

     r_val.xy.x = pts.l_most.x;
     r_val.xy.y = pts.t_most.y;
     r_val.horiz_len = pts.r_most.x - pts.l_most.x + 1;
     r_val.vert_len = pts.b_most.y - pts.t_most.y + 1;

     return r_val;

}

bool fits_in_box(box_t main_box, box_t box) {

    if((box.xy.x >= main_box.xy.x) && ((box.xy.x + box.horiz_len - 1) <=
        (main_box.xy.x + main_box.horiz_len - 1)) &&
       (box.xy.y >= main_box.xy.y) && ((box.xy.y + box.vert_len - 1) <=
        (main_box.xy.y + main_box.vert_len - 1)))
         return true;
    else
         return false;

}

bool box_equals_box(box_t box0, box_t box1) {

     if( (box0.xy.x == box1.xy.x) && (box0.xy.y == box1.xy.y) &&
        (box0.horiz_len == box1.horiz_len) && (box0.vert_len == box1.vert_len) )
          return true;
     else
          return false;

}

box_points find_biggest_box(box_points pt0, box_points pt1) {

     box_points r_val;
     
     if(max(pt0.r_most.x, pt1.r_most.x) == pt0.r_most.x)
          r_val.r_most = pt0.r_most;
     else
          r_val.r_most = pt1.r_most;
     
     if(min(pt0.l_most.x, pt1.l_most.x) == pt0.l_most.x)
          r_val.l_most = pt0.l_most;
     else
          r_val.l_most = pt1.l_most;

     if(min(pt0.t_most.y, pt1.t_most.y) == pt0.t_most.y)
          r_val.t_most = pt0.t_most;
     else
          r_val.t_most = pt1.t_most;

     if(max(pt0.b_most.y, pt1.b_most.y) == pt0.b_most.y)
          r_val.b_most = pt0.b_most;
     else
          r_val.b_most = pt1.b_most;

     return r_val;

}

box_t find_biggest_box(box_t box0, box_t box1) {

     box_t r_val;
     r_val.xy.x = min(box0.xy.x, box1.xy.x);
     r_val.xy.y = min(box0.xy.y, box1.xy.y);
     r_val.vert_len = max(box0.xy.y + box0.vert_len - r_val.xy.y,
                          box1.xy.y + box1.vert_len - r_val.xy.y);
     r_val.horiz_len = max(box0.xy.x + box0.horiz_len - r_val.xy.x, 
                           box1.xy.x + box1.horiz_len - r_val.xy.x);

     return r_val;

}

vector<box_t> remove_duplicates(vector<box_t> boxen) {

     vector<box_t> r_val;
     box_t cur_box;
     
     if(boxen.size() <= 0)
          return r_val;
     
     for(int i = 0; i < boxen.size(); i++) {

          cur_box = boxen[i];
          bool include_box = true;
          for(int j = 0; j < r_val.size(); j++) {

               if(box_equals_box(cur_box, r_val[j])) {

                    include_box = false;
                    break;

               }

          }

          if(include_box)
               r_val.push_back(cur_box);

     }

     return r_val;

}

vector<box_t> sort_boxes_ltor(vector<box_t> boxen) {

     vector<box_t> r_val;
     vector<box_t>::iterator iter, cur_pos_iter;
     int v_index;

     while(boxen.size() != 0) {

          iter = boxen.begin();
          cur_pos_iter = boxen.begin();
          v_index = 0;
          for(int i = 0; i < boxen.size(); i++) {

               if(boxen[i].xy.x < boxen[v_index].xy.x) {

                    v_index = i;
                    iter = cur_pos_iter;

               }

               cur_pos_iter++;

          }

          r_val.push_back(boxen[v_index]);
          boxen.erase(iter);

     }

     return r_val;

}

/////// for parsing:
vector< vector<bool> > zero_matrix(int rows, int cols) {

     vector< vector<bool> > r_val;
     vector<bool> row;
     
     for(int i = 0; i < rows; i++) { 

          for(int j = 0; j < cols; j++)
               row.push_back(false);
          r_val.push_back(row);
          row.clear();

     }

     return r_val;

}

void clear_matrix(vector< vector<bool> > &matrix) {

     for(int i = 0; i < matrix.size(); i++) {

          for(int j = 0; j < matrix[i].size(); j++) 
               matrix[i][j] = false;

     }

}

grid_int_t zero_grid(int rows, int cols) {

     grid_int_t r_grid;
     vector<int> row;

     for(int j = 0; j < cols; j++)
          row.push_back(0);
     for(int i = 0; i < rows; i++)
          r_grid.push_back(row);

     return r_grid;

}
         

bool grid(unsigned char *buf, int height, int width, int row, int col) {

     if((row < 0) || (row >= height) || (col < 0) || (col >= width)) {

          log_error(ERROR_PARSE_ERROR, "in grid: row/col out of bounds", NULL);
          return false;

     }

     unsigned char *ptr = buf + (row * width * 3) + (col * 3);
     if(within_interval(*ptr, *(ptr + 1), *(ptr + 2), grid_rgb_int))
          return true;

     return false;

}

// training parsing:
vector<int> sort_lower_to_upper(vector<int> input) {

     vector<int> r_val;
     vector<int>::iterator iter, cur_pos_iter;
     int v_index;

     while(input.size() != 0) {

          iter = input.begin();
          cur_pos_iter = input.begin();
          v_index = 0;
          for(int i = 0; i < input.size(); i++) {

               if(input[i] < input[v_index]) {

                    v_index = i;
                    iter = cur_pos_iter;

               }

               cur_pos_iter++;

          }

          r_val.push_back(input[v_index]);
          input.erase(iter);

     } // while

     return r_val;

}