runutils.cpp

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

/* runutils.cpp : misc utility functions to run the program
 * Author: Maxie D. Schmidt (created 5/20/2006)              */

#include "runutils.h"

/////// init:
void setup_classnotes_dirs() {

     // check to see if the initial directory exists:
     string cn_home = HOME_DIRECTORY + "/.classnotes";
     string create_cmd;
     DIR *cn_home_dir = opendir(cn_home.c_str());
     if(cn_home_dir == NULL) {

          string create_cmd = string("mkdir ") + cn_home;
          system(create_cmd.c_str());
          
     }
     else 
          closedir(cn_home_dir);
     
     vector<string> dirs;
     dirs.push_back(cfg_profile_dir);
     dirs.push_back(cfg_save_dir);
     dirs.push_back(cfg_scan_dir);
     dirs.push_back(cfg_log_dir);
     
     for(int i = 0; i < dirs.size(); i++) {

          cn_home_dir = opendir(dirs[i].c_str());
          if(cn_home_dir == NULL) {

               create_cmd = string("mkdir ") + dirs[i];
               system(create_cmd.c_str());

          }
          closedir(cn_home_dir);

     } // for i

}

bool init_png_file(string filename, png_file *pf) {

     pf->filename = filename;
     
     // open the png file, read some values:
     FILE *fp;
     char png_check_buf[8];
     unsigned char *temp;
     
     png_structp png_ptr;
     png_infop info_ptr;
     
     fp = fopen(filename.c_str(), "rb");
     if(fp == NULL) {
          
          log_error(ERROR_OPENING_FILE, "in init_png_file", strerror(errno));
          return false;

     }
     
     if(fread(png_check_buf, 1, 8, fp) != 8) {

          fclose(fp);
          log_error(ERROR_PNG_READING_SIG, "in init_png_file", NULL);
          return false;

     }

     if(png_sig_cmp((png_byte *) png_check_buf, (png_size_t) 0, 8)) {

          fclose(fp);
          log_error(ERROR_PNG_INCORRECT_SIG, "in init_png_file", NULL);
          return false;

     }
     
     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
     if(png_ptr == NULL) {

          fclose(fp);
          log_error(ERROR_PNG_PNG_PTR, "in init_png_file", NULL);
          return false;

     }

     info_ptr = png_create_info_struct(png_ptr);
     if(info_ptr == NULL) {

          fclose(fp);
          png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
          log_error(ERROR_PNG_INFO_PTR, "in init_png_file", NULL);
          return false;

     }

     if(setjmp(png_jmpbuf(png_ptr))) {

          png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
          fclose(fp);
          log_error(ERROR_PNG_SETJMP, "in init_png_file", NULL);
          return false;

     }

     png_init_io(png_ptr, fp);
     png_set_sig_bytes(png_ptr, 8);

     png_read_png(png_ptr, info_ptr, 0, png_voidp_NULL);
     
     pf->height = png_get_image_height(png_ptr, info_ptr);
     pf->width = png_get_image_width(png_ptr, info_ptr);
     //printf("bit_depth: %d\n", (int) png_get_bit_depth(png_ptr, info_ptr));

     // fill in buf:
     pf->buf = (unsigned char *) malloc((pf->height) * (pf->width) * 3);
     if(pf->buf == NULL) {
          
          log_error(ERROR_BAD_MALLOC, "in init_png_file", NULL);
          return false;

     }
     
     png_bytepp row_ptrs = png_get_rows(png_ptr, info_ptr);
     temp = pf->buf;
     for(int i = 0; i < (pf->height); i++) {

          for(int j = 0; j < (3 * (pf->width)); j += 3) {

              *temp = row_ptrs[i][j];
              *(temp + 1) = row_ptrs[i][j + 1];
              *(temp + 2) = row_ptrs[i][j + 2];

              temp += 3;
              
          }

     }

     png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
     
     // setup tracks buffer:
     int num_bytes = (pf->width * pf->height) / 8;
     if(((pf->width * pf->height) % 8) != 0)
          num_bytes++;
     
     pf->tracks = (unsigned char *) malloc(num_bytes);
     if(pf->tracks == NULL) {

          log_error(ERROR_BAD_MALLOC, "tracks in init_png_file", NULL);
          return false;

     }
     pf->tracks_num_bytes = num_bytes;
     
     if(text_lines.size() != 0)
          pf->scan_starting_line_num = text_lines[text_lines.size()-1].line_num;
     pf->is_valid = true;

     return true;

}

/////// save text to file:
bool save_text(string file, bool append) {

     FILE *fp;
     if(!append)
          fp = fopen(file.c_str(), "w");
     else
          fp = fopen(file.c_str(), "a");
     
     if(fp == NULL) {

          log_error(ERROR_OPENING_FILE, "in save_text", strerror(errno));
          return false;

     }

     string cur_line;
     for(int i = 0; i < text_lines.size(); i++) {

          cur_line = text_lines[i].text + ' ';
          fputs(cur_line.c_str(), fp);

     }

     fclose(fp);
     return true;

}

/////// config:
bool parse_from_config(string filename) {

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

          log_error(ERROR_OPENING_FILE,"in parse_from_config", strerror(errno));
          return false;

     }
     
     char cur_line[256];
     string line_str;
     vector<string> split_line;
     int line_num = 0;
          
     while(!feof(fp)) {

          fgets(cur_line, 256, fp);
          line_num++;
          
          line_str = cur_line;
          line_str = trim_whitespace(line_str);
          if(line_str == "")
               continue;

          split_line = split_string(line_str, '=');
          if(split_line.size() != 2) {

               string error_msg = string("in parse_from_config at line #") +
                                  int_to_string(line_num);
               log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
               fclose(fp);
               return false;

          }
          
          // regular training:
          if(split_line[0] == "CFG_PROFILE") {

               if(!file_exists(split_line[1])) {

                    string error_msg = "CFG_PROFILE: profile does not exist";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }
               
               cfg_profile = split_line[1];

          }
          else if(split_line[0] == "CFG_PROFILE_DIR") {

               if(!directory_exists(split_line[1])) {

                    string error_msg = "CFG_PROFILE_DIR: profile dir does not exist";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               cfg_profile_dir = split_line[1];

          }
          else if(split_line[0] == "CFG_SAVE_DIR") {

               if(!directory_exists(split_line[1])) {

                    string error_msg = "CFG_SAVE_DIR: dir does not exist";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               cfg_save_dir = split_line[1];

          }
          else if(split_line[0] == "CFG_SCAN_DIR") {

               if(!directory_exists(split_line[1])) {

                    string error_msg = "CFG_SCAN_DIR: profile does not exist";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               cfg_scan_dir = split_line[1];

          }
          else if(split_line[0] == "CFG_LOG_DIR") {

               if(!directory_exists(split_line[1])) {

                    string error_msg = "CFG_LOG_DIR: profile does not exist";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               cfg_log_dir = split_line[1];

          }
          else if(split_line[0] == "CFG_LOG_FILE") {

               if(!file_exists(split_line[1])) {

                    string error_msg = "CFG_LOG_FILE: profile does not exist";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               cfg_log_file = split_line[1];

          }
         
          // misc config:
          else if(split_line[0] == "GRID_RGB_INT_RL") {

               int value = atoi(split_line[1].c_str());
               if((value < 0) || (value > 255)) {

                    string error_msg = "GRID_RGB_INT_RL: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }
               
               grid_rgb_int.Rl = value;

          }
          else if(split_line[0] == "GRID_RGB_INT_RU") {

               int value = atoi(split_line[1].c_str());
               if((value < 0) || (value > 255)) {

                    string error_msg = "GRID_RGB_INT_RU: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               grid_rgb_int.Ru = value;

          }
          else if(split_line[0] == "GRID_RGB_INT_GL") {

               int value = atoi(split_line[1].c_str());
               if((value < 0) || (value > 255)) {

                    string error_msg = "GRID_RGB_INT_GL: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               grid_rgb_int.Gl = value;

          }
          else if(split_line[0] == "GRID_RGB_INT_GU") {

               int value = atoi(split_line[1].c_str());
               if((value < 0) || (value > 255)) {

                    string error_msg = "GRID_RGB_INT_GU: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               grid_rgb_int.Gu = value;

          }
          else if(split_line[0] == "GRID_RGB_INT_BL") {

               int value = atoi(split_line[1].c_str());
               if((value < 0) || (value > 255)) {

                    string error_msg = "GRID_RGB_INT_BL: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               grid_rgb_int.Bl = value;

          }
          else if(split_line[0] == "GRID_RGB_INT_BU") {

               int value = atoi(split_line[1].c_str());
               if((value < 0) || (value > 255)) {

                    string error_msg = "GRID_RGB_INT_BU: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }

               grid_rgb_int.Bu = value;

          }

          // parse config:
          else if(split_line[0] == "ZI_PR0_PG") {

               float value = atof(split_line[1].c_str());
               if((value < 0.0) || (value > 1.0)) {

                    string error_msg = "ZI_PR0_PG: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }
               
               ZERO_INST_PR0_PGIVEN = value;

          }
          else if(split_line[0] == "ZI_PR1_PG") {

               float value = atof(split_line[1].c_str());
               if((value < 0.0) || (value > 1.0)) {

                    string error_msg = "ZI_PR1_PG: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }
               
               ZERO_INST_PR1_PGIVEN = value;

          }
          else if(split_line[0] == "ZI_PR0_PGC") {

               float value = atof(split_line[1].c_str());
               if((value < 0.0) || (value > 1.0)) {

                    string error_msg = "ZI_PR0_PGC: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }
               
               ZERO_INST_PR0_PGC = value;

          }
          else if(split_line[0] == "ZI_PR1_PGC") {

               float value = atof(split_line[1].c_str());
               if((value < 0.0) || (value > 1.0)) {

                    string error_msg = "ZI_PR1_PGC: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }
               
               ZERO_INST_PR1_PGC = value;

          }
          else if(split_line[0] == "PRSF") {

               float value = atof(split_line[1].c_str());
               if(value < 0.0) {

                    string error_msg = "PRSF: value out of range";
                    log_error(ERROR_INVALID_CONFIG_OPTION, error_msg.c_str(), NULL);
                    continue;

               }
               
               PR_SCALING_FACTOR = value;

          }