classnotes.cpp

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

/* classnotes.cpp : main function; starts the GUI;
 * Author: Maxie D. Schmidt (created 5/21/2006)     */

#include <stdlib.h>
#include <stdio.h>
#include <dirent.h>
#include <errno.h>
#include <time.h>
#include <string.h>

#include <gtkmm/main.h>

#include <string>
#include <vector>
using namespace std;

#include "classnotes.h"
#include "profile.h"
#include "runutils.h"
#include "mainwindow.h"

// externed vars: setup default values:
string cfg_profile = HOME_DIRECTORY + "/.classnotes/profiles/default.profile";
string cfg_profile_dir = HOME_DIRECTORY + "/.classnotes/profiles/";
string cfg_save_dir = HOME_DIRECTORY + "/.classnotes/save_dir/";
string cfg_scan_dir = HOME_DIRECTORY + "/.classnotes/scans/";
string cfg_log_dir = HOME_DIRECTORY + "/.classnotes/log/";
string cfg_log_file = HOME_DIRECTORY + "/.classnotes/log/classnotes.log";

png_file *pf = new png_file();
profile *prof = new profile(trcfg_grid_size_x, trcfg_grid_size_y,
                            trcfg_gridcell_size_x, trcfg_gridcell_size_y);
bool prompt_for_profile_name = false;
string new_profile_name = cfg_profile;
vector<translated_line> text_lines;
bool text_saved = true;
rgb_interval_t grid_rgb_int = create_interval(0, 100, 0, 100, 0, 100);
run_signals signals;

bool PARSE_NO_GUI = false;
bool PNG_PARSE_ALL_IN_SCANDIR = false;
vector<string> PNG_SCAN_FILES;
bool PNG_SINGLE_OUTPUT_FILE = false;
string PNG_SG_OUTPUT_FILE = "";
string PNG_OUTPUT_FILE_PREFIX = "";

// main functions:
void print_usage(char *prog_name);
void setup_args(int argc, char *argv[]);
void run_parse_no_gui();

int main(int argc, char *argv[]) {

     setup_classnotes_dirs();
     parse_from_config(CONFIG_FILE_PATH);
     setup_args(argc, argv);
     stamp_log_file(CLASSNOTES_LOG_STAMP);

     if(!load_profile_from_file(cfg_profile)) {

          log_error(ERROR_PROFILE, "in main: Error loading profile.", NULL);
          delete prof;
          prof = NULL;

          if(PARSE_NO_GUI) {

               log_error(ERROR_PARSE_NO_GUI, "Cannot continue without valid profile (exiting ... ).", NULL);
               exit(-1);

          }
     
     }

     // run the program:
     if(!PARSE_NO_GUI) {

          Gtk::Main main_runner(argc, argv);
          main_window window;
          main_runner.run(window);

     }
     else 
          run_parse_no_gui();

     return 0;

}

void print_usage(char *prog_file) {

     printf("Usage: %s [--scan-files file0 [... filen]] [--set-scan-dir dir]\n", prog_file);
     printf("       [--parse-all-in-scan-dir] [--set-save-dir dir]\n"); 
     printf("       [--single-output-file file] [--output-file-prefix prefix]\n");
     printf("       [--profile file] [--list-profiles] [--help]\n");

}

void setup_args(int argc, char *argv[]) {

     if(argc > 1)
          PARSE_NO_GUI = true;

     for(int i = 1; i < argc; i++) {

         if((!strcmp(argv[i], "--scan-files") 
            || !strcmp(argv[i], "--single-output-file")
            || !strcmp(argv[i], "--output-file-prefix")
            || !strcmp(argv[i], "--profile")
            || !strcmp(argv[i], "--set-scan-dir")
            || !strcmp(argv[i], "--set-save-dir")) &&
            (((i + 1) == argc) || (argv[i + 1][0] == '-'))) {

              printf("The option \"%s\" requires an argument (exiting ... ).\n");
              exit(-1);

         }

         if(!strcmp(argv[i], "--scan-files")) {

              while((i != (argc - 1)) && (argv[i + 1][0] != '-')) {

                   if(!file_exists(argv[i + 1])) {

                        string error_msg = string("File ") + argv[i + 1] +
                                           " does not exist (exiting ... ).";
                        log_error(ERROR_PARSE_NO_GUI, error_msg.c_str(), NULL);
                        exit(-1);

                   }

                   PNG_SCAN_FILES.push_back(argv[i + 1]);
                   i++;

              } // while

         }
         else if(!strcmp(argv[i], "--set-scan-dir")) {

              if(!directory_exists(argv[i + 1])) {

                   printf("Scan directory does not exist (exiting ... ).\n");
                   exit(-1);

              }

              cfg_scan_dir = argv[i + 1];
              i++;

         }
         else if(!strcmp(argv[i], "--parse-all-in-scan-dir"))
              PNG_PARSE_ALL_IN_SCANDIR = true;
         else if(!strcmp(argv[i], "--set-save-dir")) {

              if(!directory_exists(argv[i + 1])) {

                   printf("Save directory does not exist (exiting ... ).\n");
                   exit(-1);

              }

              cfg_save_dir = argv[i + 1];
              i++;

         }
         else if(!strcmp(argv[i], "--single-output-file"))
              PNG_SINGLE_OUTPUT_FILE = true;
         else if(!strcmp(argv[i], "--output-file-prefix")) {

              PNG_OUTPUT_FILE_PREFIX = argv[i + 1];
              i++;

         }
         else if(!strcmp(argv[i], "--profile")) {

              if(!file_exists(argv[i + 1])) {

                   log_error(ERROR_PARSE_NO_GUI, "Profile file does not exist (exiting ... ).", NULL);
                   exit(-1);

              }

              cfg_profile = argv[i + 1];
              i++;

         }
         else if(!strcmp(argv[i], "--list-profiles")) {

               vector<string> profiles;
               DIR *profile_dir = opendir(cfg_profile_dir.c_str());
               if(profile_dir == NULL) {

                    printf("Unable to open profile dir (exiting ... ).\n");
                    exit(-1);

               }

               dirent *profile_dir_dirent;
               errno = 0;
               string profile;
               while((profile_dir_dirent = readdir(profile_dir))) {

                    profile = profile_dir_dirent->d_name;
                    if(profile.length() < 9)
                         continue;
                    if(profile.substr(profile.length() - 8, 8) == ".profile")
                         profiles.push_back(profile);

               } // while
               if(errno) {

                    printf("Error reading files from profile directory (exiting ... ).\n");
                    exit(-1);

               }
               
               if(profiles.size() == 0)
                    printf("There are no profiles in dir %s.\n", 
                           cfg_profile_dir.c_str());
               else {
                    
                    printf("Profiles:\n\n");
                    for(int i = 0; i < profiles.size(); i++)
                         printf("   (%d / %d) %s%s\n", i + 1, profiles.size(),
                                cfg_profile_dir.c_str(), profiles[i].c_str());
                    printf("\n");

               }
               
               exit(0);
         
         }
         else if(!strcmp(argv[i], "--help")) {

              print_usage(argv[0]);
              exit(0);

         }
         else {

              printf("Invalid option \"%s\" (exiting ... ).\n\n", argv[i]);
              print_usage(argv[0]);
              exit(-1);

         }

    } // for i

}

void run_parse_no_gui() {
     
     printf("%s:\n\n", CLASSNOTES_VER_STR.c_str());
     
     // get files to parse:
     vector<string> files;
     if(PNG_PARSE_ALL_IN_SCANDIR) {

          DIR *scan_dir = opendir(cfg_scan_dir.c_str());
          if(scan_dir == NULL) {

               printf("Error opening the scan dir (exiting ... ).\n");
               exit(-1);

          }

          dirent *scan_dir_dirent;
          errno = 0;
          string png_file;
          while((scan_dir_dirent = readdir(scan_dir))) {

               png_file = scan_dir_dirent->d_name;
               if((png_file.length() >= 4) &&
                  (png_file.substr(png_file.length() - 5, 4) == ".png"))
                    files.push_back(cfg_scan_dir + png_file);

          }
          if(errno) {

               printf("Error reading files from scan directory (exiting ... ).\n");
               exit(-1);

          }
          
          closedir(scan_dir);
          
     }
     else 
          files = PNG_SCAN_FILES;

     if(files.size() == 0) {

          printf("There are no files to parse (exiting ... ).\n");
          exit(0);

     }

     // read, parse, and save output text for each file:
     FILE *output_fp;
     int file_num = 0;
     char num[64];
     string filename, stripped_filename, prefix;
     for(int i = 0; i < files.size(); i++) {

          if(PNG_SINGLE_OUTPUT_FILE)
               filename = PNG_SG_OUTPUT_FILE;
          else {

               int last_slash_pos = files[i].rfind("/", files[i].length() - 1);
               stripped_filename = files[i].substr(last_slash_pos + 1,
                                   files[i].length() - last_slash_pos - 1);
               stripped_filename = stripped_filename.substr(0, 
                                   stripped_filename.length() - 4);
               if(PNG_OUTPUT_FILE_PREFIX != "")
                    prefix = PNG_OUTPUT_FILE_PREFIX + "-";
               else
                    prefix = "";
               
               filename = cfg_save_dir + prefix + stripped_filename + 
                          "-output-";
               sprintf(num, "%d", file_num);
               filename = filename + num + ".txt";

          }
          
          if(file_exists(filename))
               output_fp = fopen(filename.c_str(), "a");
          else
               output_fp = fopen(filename.c_str(), "w");
          
          if(output_fp == NULL) {

               printf("Error opening output file %s (%s) (exiting ... ).\n", 
                      filename.c_str(), strerror(errno));
               exit(-1);

          }
          
          png_file *pfile = new png_file();
          if(init_png_file(files[i], pfile)) {

               png_file *temp = pf;
               pf = pfile;
               delete temp;

          }
          else {

               delete pfile;
               printf("Error loading png_file %s (exiting ... ).\n", files[i].c_str());
               exit(-1);

          }

          if(pf->plist == NULL)
               pf->plist = new parse_list();

          if(!fill_parse_list(trcfg_line_height_int, pf, pf->plist)) {

               pf->plist->clear();
               delete pf->plist;
               pf->plist = NULL;
               delete pf;

               printf("Error filling parse list (file %s) (exiting ... ).\n", files[i].c_str());
               exit(-1);

          }

          // translate characters:
          parsed_line *cur_pl = pf->plist->pl_begin;
          parsed_char *cur_pc;
          grid_t char_grid;
          vector<char_probability> prs;
          translated_line t_line;
          while(cur_pl != NULL) {

               t_line.text = "";
               cur_pc = cur_pl->pc_begin;
               while(cur_pc != NULL) {

                    // spaces:
                    if(cur_pc != cur_pl->pc_begin) {
                    
                         int char_spacing = cur_pc->self_node.self_box.xy.x -
                                            (cur_pc->prev->self_node.self_box.xy.x +
                                             cur_pc->prev->self_node.self_box.horiz_len);
                         if((char_spacing >= trcfg_space_int.lower) &&
                            (char_spacing <= trcfg_space_int.upper))
                              t_line.text = t_line.text + ' ';

                    } // if cur_pc != cur_pl->pc_begin
               
                    char_grid = grid_char(cur_pc->self_node.self_box);
                    prs = identify_character(char_grid); 
                    if(prs.size() != 0) 
                         t_line.text = t_line.text + prs[0].character;

                    cur_pc = cur_pc->next;

               } // while cur_pc
               
               t_line.text = t_line.text + "\n";
               fputs(t_line.text.c_str(), output_fp);
               cur_pl = cur_pl->next;
               
          } // while cur_pl

          printf("(%d / %d) : File %s written.\n", i + 1, 
                 files.size(), filename.c_str());
          file_num++;
          fclose(output_fp);
          
     } // for i

     printf("\nTotal: %d scans processed.\n", files.size());

}