training.cpp

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

void tr_image_display::da_set_tools_vars(vector<plist_parsed_char> *sel_chars,
                                         vector<int> *split_chars_divider_pos,
                                         bool *join_letters, bool *rm_spots,
                                         bool *split_chars, 
                                         bool *search_alternate) {

     da.set_tools_vars(sel_chars, split_chars_divider_pos, join_letters, 
                       rm_spots, split_chars, search_alternate);

}

void tr_image_display::on_scrollbar_adjust() {

     int x = (int) get_hadjustment()->get_value();
     int y = (int) get_vadjustment()->get_value();
     int width = (int) get_hadjustment()->get_page_size();
     int height = (int) get_vadjustment()->get_page_size();

     //printf("x, y, width, height = %d, %d, %d, %d\n", x, y, width, height);
     da.set_swin_vis_props(x, y, width, height);

}

/////// text view (scrolled window):
training_text::training_text() {

     set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
     set_size_request(TR_TEXT_X_SIZE, TR_TEXT_Y_SIZE);
     set_shadow_type(Gtk::SHADOW_ETCHED_IN);
     add(text_view);
     setup_buffer();
     
     show_all_children();

}

void training_text::set_text(string text) {

     buffer_ref->set_text(text);

}

string training_text::get_text() {
     
     return (buffer_ref->get_text());

}

void training_text::setup_buffer() {

     buffer_ref = Gtk::TextBuffer::create();
     buffer_ref->set_text(string("The Quick Brown Fox Jumps Over The LazyDog"));
     text_view.set_wrap_mode(Gtk::WRAP_WORD); 
     text_view.set_buffer(buffer_ref);

}

/////// training window:
training_window::training_window(string input_text) : 
     plus_line_button("[+] line"),
     minus_line_button("[-] line"), plus_spint_line_button("[+] space line"),
     minus_spint_line_button("[-] space line"), 
     select_lines_button("Select Lines"), 
     clear_select_lines_button("Clear Select Lines"), parse_button("Parse"),
     add_to_config_button("Add to config"),
     add_to_profile_button("Add to profile"), clear_button("Clear"),
     view_cfg_button("View Config"), view_logs_button("View Logs"), 
     view_gridding_cfg_button("View Gridding Config"),
     view_profile_stats_button("View Profile Stats"), close_button("Close"),
     tools_start_button("Start"), tools_action_button("Action"), 
     tools_clear_selected_button("Clear Selected"), tools_label("Tools: "),
     tools_search_alternate_checkbutton("search alternate")  {

     set_title("Training");
     set_border_width(10);
     set_default_size(TR_MAIN_WIN_X_SIZE, TR_MAIN_WIN_Y_SIZE);

     if(input_text != "")
          train_with_scan = true;
     else
          train_with_scan = false;
     
     draw_interval_lines = true;
     selected_chars = new vector<plist_parsed_char>();
     tool_split_chars_divider_pos = new vector<int>();
     tool_join_letters = new bool();
     *tool_join_letters = false;
     tool_rm_spots = new bool();
     *tool_rm_spots = false;
     tool_split_chars = new bool();
     *tool_split_chars = false;
     tools_search_alternate = new bool();
     *tools_search_alternate = false;
     img_display.da_set_tools_vars(selected_chars, tool_split_chars_divider_pos,
                                   tool_join_letters, tool_rm_spots, 
                                   tool_split_chars, tools_search_alternate);

     // signal handlers:
     plus_line_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_plus_line_click));
     minus_line_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_minus_line_click));
     plus_spint_line_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_plus_spint_line_click));
     minus_spint_line_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_minus_spint_line_click));
     select_lines_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_select_lines_click));
     clear_select_lines_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_clear_select_lines_click));
     parse_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_parse_button_click));
     add_to_config_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_add_to_config_click));
     add_to_profile_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_add_to_profile_click));
     clear_button.signal_clicked().connect(sigc::mem_fun(*this, 
                              &training_window::on_clear_button_click));
     view_cfg_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_view_tr_cfg_click));
     view_gridding_cfg_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_view_gridding_cfg_click));
     view_profile_stats_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_view_profile_stats_click));
     view_logs_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_view_logs_click));
     close_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_close_button_click));
     tools_start_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_tools_start_button_click));
     tools_action_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_tools_action_button_click));
     tools_clear_selected_button.signal_clicked().connect(sigc::mem_fun(*this,
                              &training_window::on_tools_clear_selected_click));
     tools_search_alternate_checkbutton.signal_clicked().connect(sigc::mem_fun(
                    *this, &training_window::on_tools_search_alternate_click));
     
     // tools:
     tools_buttonbox.set_spacing(10);
     tools_buttonbox.pack_start(tools_start_button, Gtk::PACK_SHRINK);
     tools_buttonbox.pack_start(tools_action_button, Gtk::PACK_SHRINK);
     tools_buttonbox.pack_start(tools_clear_selected_button, Gtk::PACK_SHRINK);

     tools_combobox.append_text("Join Letters");
     tools_combobox.append_text("Remove Spots");
     tools_combobox.append_text("Split Characters");
     tools_combobox.set_active(0);
     
     tools_hbox.set_spacing(10);
     tools_hbox.pack_start(tools_label, Gtk::PACK_SHRINK);
     tools_hbox.pack_start(tools_combobox, Gtk::PACK_SHRINK);
     tools_hbox.pack_start(tools_buttonbox, Gtk::PACK_SHRINK);
     tools_hbox.pack_start(tools_search_alternate_checkbutton,Gtk::PACK_SHRINK);

     line_buttonbox.pack_start(minus_line_button, Gtk::PACK_SHRINK);
     line_buttonbox.pack_start(plus_line_button, Gtk::PACK_SHRINK);
     line_buttonbox.pack_start(plus_spint_line_button, Gtk::PACK_SHRINK);
     line_buttonbox.pack_start(minus_spint_line_button, Gtk::PACK_SHRINK);
     line_buttonbox.pack_start(select_lines_button, Gtk::PACK_SHRINK);
     line_buttonbox.pack_start(clear_select_lines_button, Gtk::PACK_SHRINK);
     line_buttonbox.set_border_width(5);
     line_buttonbox.set_layout(Gtk::BUTTONBOX_SPREAD);
     
     middle_buttonbox.pack_start(parse_button, Gtk::PACK_SHRINK);
     middle_buttonbox.pack_start(add_to_config_button, Gtk::PACK_SHRINK);
     middle_buttonbox.pack_start(add_to_profile_button, Gtk::PACK_SHRINK);
     middle_buttonbox.pack_start(clear_button, Gtk::PACK_SHRINK);
     middle_buttonbox.set_border_width(5);
     middle_buttonbox.set_layout(Gtk::BUTTONBOX_SPREAD);
     
     bottom_buttonbox.pack_start(view_cfg_button, Gtk::PACK_SHRINK);
     bottom_buttonbox.pack_start(view_gridding_cfg_button, Gtk::PACK_SHRINK);
     bottom_buttonbox.pack_start(view_profile_stats_button, Gtk::PACK_SHRINK);
     bottom_buttonbox.pack_start(view_logs_button, Gtk::PACK_SHRINK);
     bottom_buttonbox.pack_start(close_button, Gtk::PACK_SHRINK);
     bottom_buttonbox.set_border_width(5);
     bottom_buttonbox.set_layout(Gtk::BUTTONBOX_SPREAD);

     bottom_buttonbox_vbox.pack_start(line_buttonbox, Gtk::PACK_SHRINK);
     bottom_buttonbox_vbox.pack_start(middle_buttonbox, Gtk::PACK_SHRINK);
     bottom_buttonbox_vbox.pack_start(bottom_buttonbox, Gtk::PACK_SHRINK);
     
     win_bottom_vbox.set_spacing(5);
     win_bottom_vbox.pack_start(tools_hbox, Gtk::PACK_SHRINK);
     if(train_with_scan)
          image_text.set_text(input_text);
     win_bottom_vbox.pack_start(image_text, true, true, 10);
     win_bottom_vbox.pack_start(bottom_buttonbox_vbox, Gtk::PACK_SHRINK);

     divider.add1(img_display);
     divider.add2(win_bottom_vbox);
     get_vbox()->pack_start(divider, Gtk::PACK_SHRINK);
     
     show_all_children();

}

training_window::~training_window() {

     delete selected_chars;
     delete tool_split_chars_divider_pos;
     delete tool_join_letters;
     delete tool_rm_spots;
     delete tool_split_chars;
     delete tools_search_alternate;

}

void training_window::on_plus_line_click() {

     img_display.da_add_line(1);

}

void training_window::on_minus_line_click() {

     img_display.da_delete_line();
     
}

void training_window::on_plus_spint_line_click() {

     if(!img_display.da_add_spint_line(1))
          popup_message(*this, "Unable to add a spint line. See the logs (log button) for more detailed information.");

}

void training_window::on_minus_spint_line_click() {

     if(!img_display.da_delete_spint_line())
          popup_message(*this, "Unable to delete a spint line. See the logs (log button) for more detailed information.");

}

void training_window::on_select_lines_click() {

     img_display.da_select_lines();

}

void training_window::on_clear_select_lines_click() {

     img_display.da_clear_select_lines();

}

void training_window::on_parse_button_click() {

     if(tr_parse_list->letters_parsed) {

          popup_message(*this, "The scan is already parsed. To re-parse it first click on \"Clear\" and then on \"Parse\".");
          return;

     }
     
     string img_text = image_text.get_text();
     vector<int> lines = img_display.da_get_lines(),
                 spint_lines = img_display.da_get_spint_lines();
     
     draw_interval_lines = false;
     if(!parse_training(img_text, lines, spint_lines)) {

          tr_parse_list->clear();
          popup_message(*this, "An error occurred while parsing the image. Check the logs for more detailed information.");
          draw_interval_lines = true;
          signals.do_tr_refresh();
          return;

     }
     
}

void training_window::on_add_to_config_click() {

     write_config_file(CONFIG_FILE_PATH);

}

void training_window::on_add_to_profile_click() {

     // create profile from the scan:
     if((tr_parse_list->pl_begin == NULL) || 
        (tr_parse_list->pl_begin->pc_begin == NULL))
          return;
     
     if(tr_profile == NULL)
          tr_profile = new profile(trcfg_grid_size_x, trcfg_grid_size_y,
                                 trcfg_gridcell_size_x, trcfg_gridcell_size_y);
     
     parsed_line *cur_pl = tr_parse_list->pl_begin;
     parsed_char *cur_pc;
     box_t char_box;
     grid_t char_grid;
     int profile_index;
     while(cur_pl != NULL) {

          cur_pc = cur_pl->pc_begin;
          while(cur_pc != NULL) {

               if(cur_pc->self_node.is_space) {

                    cur_pc = cur_pc->next;
                    continue;

               }

               // grid the character:
               char_box = cur_pc->self_node.self_box;
               char_grid = grid_char(char_box);
               profile_index = find_character_index(cur_pc->self_node.character,
                                                    tr_profile);
               if(profile_index == -1)
                    return;
               
               // add to profile:
               for(int i = 0; i < char_grid.size(); i++) {

                    for(int j = 0; j < char_grid[i].size(); j++) {
                         
                         if(char_grid[i][j])
                              (tr_profile->character_nodes[profile_index].
                                                              gc_count[i][j])++;

                    }

               }

               (tr_profile->character_nodes[profile_index].num_instances)++;
               (tr_profile->total_instances)++;

               cur_pc = cur_pc->next;
               
          } // while pc

          cur_pl = cur_pl->next;

     } // while pl

     tr_profile->update();
     if(!merge_profiles(tr_profile)) {

          popup_message(*this, "Cannot add to main profile: the grid(cell) sizes of the profiles do not match. Try clearing the main profile with the menu option \"Profile->Clear Profile\" first.");
          return;

     }
     else {

          if(prompt_for_profile_name) {
               
               profile_name_dialog pn_dialog;
               pn_dialog.run();
               write_profile_to_file(new_profile_name, prof);
               cfg_profile = new_profile_name;
               write_config_file(CONFIG_FILE_PATH);
               prompt_for_profile_name = false;

          }
          else
               write_profile_to_file(cfg_profile, prof);

     }
     
     delete tr_profile;
     tr_profile = NULL;
     
}

void training_window::on_clear_button_click() {

     parse_list *temp_pl, *new_pl;

     if(tr_parse_list != NULL) {
          
          new_pl = new parse_list();
          temp_pl = tr_parse_list;
          tr_parse_list = new_pl;
          delete temp_pl;

     }
          
     if(tr_profile != NULL) {
          
          delete tr_profile;
          tr_profile = NULL;

     }
     
     draw_interval_lines = true;
     
     // delete lines:
     int num_lines = img_display.da_get_lines().size();
     for(int i = 0; i < num_lines; i++)
          img_display.da_delete_line();

     signals.do_tr_refresh();
     
}

void training_window::on_view_tr_cfg_click() {

     cfg_dialog config_window(TRAINING);
     config_window.run();

}

void training_window::on_view_gridding_cfg_click() {

     grid_config_dialog dialog;
     dialog.run();

}

void training_window::on_view_profile_stats_click() {

     if(prof != NULL) {
          
          profile_stats_dialog dialog(prof);
          dialog.run();

     }
     else
          popup_message(*this, "Setup the profile before viewing stats.");

}

void training_window::on_view_logs_click() {

     log_file_dialog dialog;
     dialog.run();

}

void training_window::on_close_button_click() {

     hide();
     if(train_with_scan) {
          
          if(tr_train_with_scan_replace_text())
               text_saved = false;

     }
     cleanup_training();

}

void training_window::on_tools_start_button_click() {

     if(!(tr_parse_list->letters_parsed))
          return;
     
     int tool_selection = tools_combobox.get_active_row_number();
     if(tool_selection == 0) {

          if(*tool_split_chars) {

               tool_split_chars_divider_pos->clear();
               *tool_split_chars = false;

          }
          
          *tool_join_letters = true;
          *tool_rm_spots = false;

     }
     else if(tool_selection == 1) {

          if(*tool_split_chars) {

               tool_split_chars_divider_pos->clear();
               *tool_split_chars = false;

          }
          
          *tool_rm_spots = true;
          *tool_join_letters = false;

     }