training.cpp

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

     swin_vis_height = height;

}

void tr_drawing_area::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){

     selected_chars = sel_chars;
     tool_split_chars_divider_pos = split_chars_divider_pos;
     tool_join_letters = join_letters;
     tool_rm_spots = rm_spots;
     tool_split_chars = split_chars;
     tools_search_alternate = search_alternate;

}

bool tr_drawing_area::on_button_press_event(GdkEventButton *event) {

     int x = (int) event->x, y = (int) event->y;
     if(click_on_line(y) != -1) {
          
          if(selecting_lines && (selected_line_index0 == -1))
               selected_line_index0 = click_on_line(y);
          else if(selecting_lines) {

               selected_line_index1 = click_on_line(y);
               selecting_lines = false;

          }
          else {
               
               selected_line_index = click_on_line(y);
               dragging = true;

          }

     }
     else if(click_on_spint_line(x, y) != -1) {
          
          selected_spint_line_index = click_on_spint_line(x, y);
          dragging = true;

     }
     else if(*tool_split_chars && (split_chars_click_on_line(x, y) != -1)) {

          split_chars_line_index = split_chars_click_on_line(x, y);
          dragging = true;

     }
     else if(*tool_join_letters || *tool_rm_spots || *tool_split_chars) {

          plist_parsed_char pchar;
          pchar = point_to_char(tr_parse_list, x, y, *tools_search_alternate);
          if(pchar.pc == NULL)
               return true;

          for(int i = 0; i < selected_chars->size(); i++) {

               if(box_equals_box(pchar.pc->self_node.self_box, 
                                (*selected_chars)[i].pc->self_node.self_box))
                         return true;

          }

          selected_chars->push_back(pchar);
          if(*tool_split_chars)
               tool_split_chars_divider_pos->push_back(
               (*selected_chars)[selected_chars->size() - 1].pc->
               self_node.self_box.xy.x + 1);
               
          signals.do_tr_refresh();

     }

     return true;

}

bool tr_drawing_area::on_button_release_event(GdkEventButton *event) {

     dragging = false;
     selected_line_index = -1;
     selected_spint_line_index = -1;
     refresh();

}

bool tr_drawing_area::on_motion_notify_event(GdkEventMotion *event) {

     if(dragging && *tool_split_chars) {
     
          int x = (int) event->x;
          if((x >= (*selected_chars)[split_chars_line_index].pc->
             self_node.self_box.xy.x) && (x <= 
             ((*selected_chars)[split_chars_line_index].pc->
              self_node.self_box.xy.x + 
              (*selected_chars)[split_chars_line_index].pc->
              self_node.self_box.horiz_len - 1))) {
               
               (*tool_split_chars_divider_pos)[split_chars_line_index] = x;
               refresh();

          }
     
     }
     else if(dragging && (selected_line_index != -1)) {

          lines[selected_line_index] = (int) event->y; 
          refresh();

     }
     else if(dragging && (selected_spint_line_index != -1)) {

          spint_lines[selected_spint_line_index] = (int) event->x;
          refresh();

     }

     return true;

}

bool tr_drawing_area::on_expose_event(GdkEventExpose *event) {

     if(need_valid_vis) {

          swin_vis_x = min(swin_vis_x, event->area.x);
          swin_vis_y = min(swin_vis_y, event->area.y);
          swin_vis_width = min(swin_vis_width, event->area.width);
          swin_vis_height = min(swin_vis_height, event->area.height);
          need_valid_vis = false;

     }

     refresh();
     return true;

}

void tr_drawing_area::on_signal_tr_refresh() {

     refresh();

}

void tr_drawing_area::on_signal_tr_clear_int_lines() {

     lines.clear();
     spint_lines.clear();

}

void tr_drawing_area::draw_image() {

     Glib::RefPtr<Gdk::GC> gc = get_style()->get_black_gc();
     Glib::RefPtr<Gdk::Window> win = get_window();
     
     if(dragging) {
          
          unsigned char *buf_start;
          buf_start = pf->buf + (3 * pf->width) * swin_vis_y + 3 * swin_vis_x;
          win->draw_rgb_image(gc, swin_vis_x, swin_vis_y, swin_vis_width, 
                              swin_vis_height, Gdk::RGB_DITHER_MAX, 
                              buf_start, 3 * (pf->width));
     
     }
     else {
          
          int height = pf->height, width = pf->width;
          win->draw_rgb_image(gc, 0, 0, width, height, Gdk::RGB_DITHER_MAX,
                              pf->buf, 3 * width);

     }
     
}

void tr_drawing_area::draw_selected_chars() {

     Glib::RefPtr<Gdk::Window> win = get_window();
     Glib::RefPtr<Gdk::GC> gc = Gdk::GC::create(win);
     Glib::RefPtr<Gdk::GC> text_gc = get_style()->get_white_gc();
     gc->set_line_attributes(2, Gdk::LINE_SOLID, Gdk::CAP_ROUND,
                             Gdk::JOIN_ROUND);
     
     Glib::RefPtr<Pango::Layout> layout = create_pango_layout("");
     Pango::FontDescription fd;
     fd.set_weight(Pango::WEIGHT_HEAVY);
     layout->set_font_description(fd);
     layout->set_width(15);
     layout->set_alignment(Pango::ALIGN_CENTER);
     
     Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
     Gdk::Color orange;
    
     orange.set_red(61423);
     orange.set_green(45232);
     orange.set_blue(2827);
     colormap->alloc_color(orange);
     gc->set_foreground(orange);

     parsed_char *cur_pc;
     for(int i = 0; i < selected_chars->size(); i++) {

          cur_pc = (*selected_chars)[i].pc;

          win->draw_rectangle(gc, 0, cur_pc->self_node.self_box.xy.x,
                              cur_pc->self_node.self_box.xy.y, 
                              cur_pc->self_node.self_box.horiz_len,
                              cur_pc->self_node.self_box.vert_len);
               
          // set letter at the corner of the box:
          win->draw_rectangle(gc, true, cur_pc->self_node.self_box.xy.x,
                              cur_pc->self_node.self_box.xy.y, 15, 15);
          layout->set_text(cur_pc->self_node.character);
          win->draw_layout(text_gc, cur_pc->self_node.self_box.xy.x + 7,
                           cur_pc->self_node.self_box.xy.y - 2, layout);

     }

}

void tr_drawing_area::draw_lines() {

     Glib::RefPtr<Gdk::Window> win = get_window();
     Glib::RefPtr<Gdk::GC> blue_gc = Gdk::GC::create(win);
     blue_gc->set_line_attributes(2, Gdk::LINE_SOLID, Gdk::CAP_ROUND, 
                                  Gdk::JOIN_ROUND);
     Glib::RefPtr<Gdk::GC> selected_blue_gc = Gdk::GC::create(win);
     selected_blue_gc->set_line_attributes(TR_DA_SELECTED_LINE_THICKNESS, 
                                           Gdk::LINE_SOLID, Gdk::CAP_ROUND,
                                           Gdk::JOIN_ROUND);
     Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
     Gdk::Color blue;
     blue.set_red(0);
     blue.set_green(0);
     blue.set_blue(65535);
     colormap->alloc_color(blue);
     blue_gc->set_foreground(blue);
     selected_blue_gc->set_foreground(blue);
     
     for(int i = 0; i < lines.size(); i++) {

          if((i == selected_line_index0) || (i == selected_line_index1))
               win->draw_line(selected_blue_gc, 0, lines[i], pf->width - 2, 
                              lines[i]);
          else
               win->draw_line(blue_gc, 0, lines[i], pf->width - 2, lines[i]);

     }

}         

void tr_drawing_area::draw_spint_lines() {

     if((selected_line_index0 == -1) || (selected_line_index1 == -1))
          return;
     
     Glib::RefPtr<Gdk::Window> win = get_window();
     Glib::RefPtr<Gdk::GC> magenta_gc = Gdk::GC::create(win);
     magenta_gc->set_line_attributes(2, Gdk::LINE_SOLID, Gdk::CAP_ROUND, 
                                  Gdk::JOIN_ROUND);
     Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
     Gdk::Color magenta;
     magenta.set_red(63744);
     magenta.set_green(10752);
     magenta.set_blue(50688);
     colormap->alloc_color(magenta);
     magenta_gc->set_foreground(magenta);

     int upper_index, lower_index;
     if(lines[selected_line_index0] < lines[selected_line_index]) {

          upper_index = selected_line_index0;
          lower_index = selected_line_index1;

     }
     else {

          upper_index = selected_line_index1;
          lower_index = selected_line_index0;

     }
     
     for(int i = 0; i < spint_lines.size(); i++)
          win->draw_line(magenta_gc, spint_lines[i], lines[upper_index],
                         spint_lines[i], lines[lower_index]);

}

void tr_drawing_area::draw_split_chars_lines() {

     Glib::RefPtr<Gdk::Window> win = get_window();
     Glib::RefPtr<Gdk::GC> red_gc = Gdk::GC::create(win);
     red_gc->set_line_attributes(2, Gdk::LINE_ON_OFF_DASH, Gdk::CAP_ROUND, 
                                  Gdk::JOIN_ROUND);
     Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
     Gdk::Color red;
     red.set_red(65535);
     red.set_green(0);
     red.set_blue(0);
     colormap->alloc_color(red);
     red_gc->set_foreground(red);

     box_t char_box;
     int pos_x;
     for(int i = 0; i < tool_split_chars_divider_pos->size(); i++) {

          char_box = (*selected_chars)[i].pc->self_node.self_box;
          pos_x = (*tool_split_chars_divider_pos)[i];
          win->draw_line(red_gc, pos_x, char_box.xy.y, pos_x, 
                         char_box.xy.y + char_box.vert_len - 1);

     }

}

bool tr_drawing_area::click_on_line(int line_index, int y) {

     if((line_index == selected_line_index0) || 
        (line_index == selected_line_index1)) {

          if((y >= lines[line_index]) && 
             (y <= lines[line_index] + (TR_DA_SELECTED_LINE_THICKNESS - 1)))
               return true;
          else
               return false;

     }
     else {
     
          if((y == lines[line_index]) || (y == (lines[line_index] + 1)))
               return true;
          else
               return false;

     }

}

int tr_drawing_area::click_on_line(int y) {

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

          if(click_on_line(i, y))
               return i;

     }

     return -1;

}

bool tr_drawing_area::click_on_spint_line(int line_index, int x, int y) {

     if((selected_line_index0 == -1) || (selected_line_index1 == -1))
          return false;
     
     int upper_index, lower_index;
     if(lines[selected_line_index0] < lines[selected_line_index1]) {

          upper_index = selected_line_index0;
          lower_index = selected_line_index1;

     }
     else {

          upper_index = selected_line_index1;
          lower_index = selected_line_index0;

     }
     
     if(((x == spint_lines[line_index]) || (x == spint_lines[line_index] + 1)) &&
         (y >= lines[upper_index]) && (y <= lines[lower_index]))
          return true;
     else 
          return false;

}

int tr_drawing_area::click_on_spint_line(int x, int y) {

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

         if(click_on_spint_line(i, x, y))
              return i;

    }

    return -1;

}

int tr_drawing_area::split_chars_click_on_line(int x, int y) {

     box_t char_box;
     for(int i = 0; i < selected_chars->size(); i++) {

          char_box = (*selected_chars)[i].pc->self_node.self_box;
          if((char_box.xy.y <= y) && ((char_box.xy.y + char_box.horiz_len - 1)
              >= y) && (char_box.xy.x <= x) && 
             ((char_box.xy.x + char_box.vert_len) >= x))
               return i;

     }

     return -1;

}

/////// image display:
tr_image_display::tr_image_display() : da(pf->width, pf->height) {

     set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
     set_size_request(TR_SWIN_X_SIZE, TR_SWIN_Y_SIZE);
     set_border_width(0);
     add(da);
     
     get_hadjustment()->signal_value_changed().connect(sigc::mem_fun(*this, 
                                      &tr_image_display::on_scrollbar_adjust));
     get_vadjustment()->signal_value_changed().connect(sigc::mem_fun(*this,
                                      &tr_image_display::on_scrollbar_adjust));
     
     show_all_children();

}

void tr_image_display::da_add_line(int line) {

     da.add_line(line);

}

void tr_image_display::da_delete_line() {

     da.delete_line();

}

vector<int> tr_image_display::da_get_lines() {

     return da.get_lines();

}


bool tr_image_display::da_add_spint_line(int line) {

     return da.add_spint_line(line);

}

bool tr_image_display::da_delete_spint_line() {

     return da.delete_spint_line();

}

vector<int> tr_image_display::da_get_spint_lines() {

     return da.get_spint_lines();

}

void tr_image_display::da_select_lines() {

     da.select_lines();

}

void tr_image_display::da_clear_select_lines() {

     da.clear_select_lines();

}