drawingarea.cpp

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

/* drawingarea.cpp : code for the drawing area base class used in mainwindow
 *                   and in training;
 * Author: Maxie D. Schmidt (created 5/31/2006)                              */

#include "drawingarea.h"

drawing_area::drawing_area(int size_x, int size_y) : DrawingArea() {

     set_size_request(size_x, size_y);

}

void drawing_area::refresh() {}

void drawing_area::set_size(int size_x, int size_y) {

     set_size_request(size_x, size_y);

}

void drawing_area::draw_image() {}

void drawing_area::draw_parse_boundary() {

     //if((scan_ignore_edges_top < 0) || (scan_ignore_edges_bottom < 0) ||
     //   (scan_ignore_edges_left < 0) || (scan_ignore_edges_right < 0))
     //     return;
     
     Glib::RefPtr<Gdk::Window> win = get_window();
     Glib::RefPtr<Gdk::GC> gc = Gdk::GC::create(win);
     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 purple;
     purple.set_red(51400);
     purple.set_green(7967);
     purple.set_blue(47802);
     colormap->alloc_color(purple);

     gc->set_foreground(purple);
     win->draw_rectangle(gc, 0, scan_ignore_edges_left, scan_ignore_edges_top, 
                         pf->width - scan_ignore_edges_left -
                         scan_ignore_edges_right, pf->height - 
                         scan_ignore_edges_top - scan_ignore_edges_bottom);

}

void drawing_area::draw_parse_list(parse_list *plist) {

     if((plist == NULL) || ((plist->pl_begin) == NULL))
          return;
     
     // colors: (*) blue for line markers
     //         (*) purple for char markers

     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 blue, purple;
    
     blue.set_red(0);
     blue.set_green(39321);
     blue.set_blue(65535);
     colormap->alloc_color(blue);
     
     // prev value: (26214, 0, 39321)
     purple.set_red(49601);
     purple.set_green(41377);
     purple.set_blue(60138);
     colormap->alloc_color(purple);
     
     parsed_line *cur_pl = plist->pl_begin;
     while(cur_pl != NULL) {

          gc->set_foreground(blue);
          win->draw_rectangle(gc, 0, cur_pl->self_node.self_box.xy.x, 
                              cur_pl->self_node.self_box.xy.y - 1, 
                              cur_pl->self_node.self_box.horiz_len, 
                              cur_pl->self_node.self_box.vert_len + 2);
                    
          parsed_char *cur_pc = cur_pl->pc_begin;
          gc->set_foreground(purple);
          while(cur_pc != NULL) {

               if(cur_pc->self_node.is_space) {
               
                    cur_pc = cur_pc->next;
                    continue;
               
               }
               
               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);
                              
               cur_pc = cur_pc->next;

          }

          cur_pl = cur_pl->next;

     } // while

}

// gridded chars:
grid_char_da::grid_char_da() {

     set_size_request(0, 0);

     letter_buf = NULL;
     cur_char_box = NULL_BOX();
     grid_fill = false;
     grid_offset_x = grid_offset_y = 0;
     gs_x = gs_y = gc_x = gc_y = -1;

}

grid_char_da::~grid_char_da() {

     free(letter_buf);

}

void grid_char_da::refresh() {

     if(letter_buf != NULL)
          draw_letter_buf();
     if(grid_fill && (letter_buf != NULL))
          draw_grid_fill();
     draw_grid_lines();

}

void grid_char_da::set_size(int size_x, int size_y) {

     set_size_request(size_x, size_y);

}

void grid_char_da::draw_letter_buf() {

     if(letter_buf == NULL)
          return;

     Glib::RefPtr<Gdk::GC> gc = get_style()->get_black_gc();
     Glib::RefPtr<Gdk::GC> white_gc = get_style()->get_white_gc();
     Glib::RefPtr<Gdk::Window> win = get_window();
     win->draw_rectangle(white_gc, true, 0, 0, gs_x, gs_y);
     win->draw_rgb_image(gc, grid_offset_x, grid_offset_y, 
                         cur_char_box.horiz_len, 
                         cur_char_box.vert_len, Gdk::RGB_DITHER_MAX, 
                         letter_buf, 3 * cur_char_box.horiz_len);

}

void grid_char_da::set_grid_draw_fill(bool tf) {

     grid_fill = tf;

}

void grid_char_da::draw_grid_fill() {

     Glib::RefPtr<Gdk::Window> win = get_window();
     Glib::RefPtr<Gdk::GC> gc = get_style()->get_black_gc();

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

          for(int j = 0; j < grid_fill_matrix[i].size(); j++) {

               if(grid_fill_matrix[i][j])
                    win->draw_rectangle(gc, true, j * gc_x, i * gc_y, 
                                        gc_x, gc_y);

          }

     }

}

void grid_char_da::draw_grid_lines() {

     Glib::RefPtr<Gdk::Window> win = get_window();
     Glib::RefPtr<Gdk::GC> gc = Gdk::GC::create(win);
     Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
     Gdk::Color pink;

     pink.set_red(65535);
     pink.set_green(39321);
     pink.set_blue(52428);
     colormap->alloc_color(pink);
     gc->set_foreground(pink);

     // draw ends:
     win->draw_line(gc, gs_x - 1, 0, gs_x - 1, gs_y - 1);
     win->draw_line(gc, 0, gs_y - 1, gs_x - 1, gs_y - 1);

     // horiz and vert lines:
     for(int i = 0; i < (gs_y / gc_y); i++)
          win->draw_line(gc, 0, i * gc_y, gs_x - 1, i * gc_y);
     
     for(int i = 0; i < (gs_x / gc_x); i++)
          win->draw_line(gc, i * gc_x, 0, i * gc_x, gs_y - 1);

}

// this gets called when the update button for gs* or gc* is pushed:
void grid_char_da::set_grid_params(int gsx, int gsy, int gcx, int gcy) {

     gs_x = gsx;
     gs_y = gsy;
     gc_x = gcx;
     gc_y = gcy;

     if((gs_x > 0) && (gs_y > 0))
          set_size(gs_x, gs_y);

     if(letter_buf != NULL) { // have valid character
          
          // grid offsets (grid _should_ be >= buffer size_x/y):
          grid_offset_x = (gs_x - cur_char_box.horiz_len) / 2;
          grid_offset_y = (gs_y - cur_char_box.vert_len) / 2;
          
          // setup grid fill matrix:
          grid_fill_matrix = grid_char(letter_buf, cur_char_box.vert_len, 
                                       cur_char_box.horiz_len, grid_offset_x, 
                                       grid_offset_y, gs_x, gs_y, gc_x, gc_y);

     }

}

bool grid_char_da::on_expose_event(GdkEventExpose *event) {

     refresh();
     return true;

}

void grid_char_da::on_new_grid_cfg_letter(box_t char_box) {

     cur_char_box = char_box;
     
     if(!equals_NULL_BOX(cur_char_box)) {
     
          // setup new letter buffer:
          if(letter_buf != NULL)
               free(letter_buf);
          int byte_size = cur_char_box.horiz_len * cur_char_box.vert_len * 3;
          letter_buf = (unsigned char *) malloc(byte_size);
          if(letter_buf == NULL) {

               log_error(ERROR_BAD_MALLOC, "in on_new_grid_cfg_letter", NULL);
               return;

          }
          
          int lb_offset = 0, pf_offset = 0;
          for(int i = 0; i < cur_char_box.vert_len; i++) {

               for(int j = 0; j < (cur_char_box.horiz_len * 3); j += 3) {
                    
                    lb_offset = i * cur_char_box.horiz_len * 3 + j;
                    pf_offset = (i + cur_char_box.xy.y) * (pf->width) * 3 + 
                                    (cur_char_box.xy.x * 3 + j);
                    
                    *(letter_buf + lb_offset) = *(pf->buf + pf_offset);
                    *(letter_buf + lb_offset + 1) = *(pf->buf + pf_offset + 1);
                    *(letter_buf + lb_offset + 2) = *(pf->buf + pf_offset + 2);

               }

          }

          // grid offsets (grid _should_ be >= buffer size_x/y):
          grid_offset_x = (gs_x - cur_char_box.horiz_len) / 2;
          grid_offset_y = (gs_y - cur_char_box.vert_len) / 2;
          
          // setup grid fill matrix:
          grid_fill_matrix = grid_char(letter_buf, cur_char_box.vert_len, 
                                       cur_char_box.horiz_len, grid_offset_x, 
                                       grid_offset_y, gs_x, gs_y, gc_x, gc_y);
     
     } // if(!equals_NULL_BOX...

}