pgedit.cpp

来自「一个google的OCR源码」· C++ 代码 · 共 1,866 行 · 第 1/4 页

          }
          tprintf
           ("Max inter char gap = %d.\nMin inter word gap = %d.\n",
            max_inter_char_gap, min_inter_word_gap);
          all_gap_stats.short_print(NULL, TRUE);
          all_gap_stats.smooth(2);
          tprintf("SMOOTHED DATA...\n");
          all_gap_stats.short_print(NULL, TRUE);
        }
      }
    }
  }
}


/**********************************************************************
 * show_point()
 *
 * Show coords of point, blob bounding box, word bounding box and offset from
 * row baseline
 **********************************************************************/

void show_point(                        // display posn of bloba word
                BLOCK_LIST *block_list,  // blocks to check
                float x,
                float y) {
  FCOORD pt(x, y);
  TBOX box;
  BLOCK_IT block_it(block_list);
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;
  WERD_IT word_it;
  WERD *word;
  PBLOB_IT blob_it;
  PBLOB *blob;
  C_BLOB_IT cblob_it;
  C_BLOB *cblob;

  char msg[160];
  char *msg_ptr = msg;

  msg_ptr += sprintf(msg_ptr, "Pt:(%0.3f, %0.3f) ", x, y);

  for (block_it.mark_cycle_pt();
  !block_it.cycled_list(); block_it.forward()) {
    block = block_it.data();
    if (block->bounding_box().contains(pt)) {
      row_it.set_to_list(block->row_list());
      for (row_it.mark_cycle_pt();
      !row_it.cycled_list(); row_it.forward()) {
        row = row_it.data();
        if (row->bounding_box().contains(pt)) {
          msg_ptr += sprintf(msg_ptr, "BL(x)=%0.3f ",
            row->base_line(x));

          word_it.set_to_list(row->word_list());
          for (word_it.mark_cycle_pt();
          !word_it.cycled_list(); word_it.forward()) {
            word = word_it.data();
            box = word->bounding_box();
            if (box.contains(pt)) {
              msg_ptr += sprintf(msg_ptr,
                "Wd(%d, %d)/(%d, %d) ",
                box.left(), box.bottom(),
                box.right(), box.top());

              if (word->flag(W_POLYGON)) {
                blob_it.set_to_list(word->blob_list());
                for (blob_it.mark_cycle_pt();
                  !blob_it.cycled_list();
                blob_it.forward()) {
                  blob = blob_it.data();
                  box = blob->bounding_box();
                  if (box.contains(pt)) {
                    msg_ptr += sprintf(msg_ptr,
                      "Blb(%d, %d)/(%d, %d) ",
                      box.left(),
                      box.bottom(),
                      box.right(),
                      box.top());
                  }
                }
              }
              else {
                cblob_it.set_to_list(word->cblob_list());
                for (cblob_it.mark_cycle_pt();
                  !cblob_it.cycled_list();
                cblob_it.forward()) {
                  cblob = cblob_it.data();
                  box = cblob->bounding_box();
                  if (box.contains(pt)) {
                    msg_ptr += sprintf(msg_ptr,
                      "CBlb(%d, %d)/(%d, %d) ",
                      box.left(),
                      box.bottom(),
                      box.right(),
                      box.top());
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  image_win->AddMessage(msg);
}


/**********************************************************************
 * WERD PROCESSOR FUNCTIONS
 * ========================
 *
 * These routines are invoked by one or mode of:
 *    process_all_words()
 *    process_selected_words()
 * or
 *    process_all_words_it()
 *    process_selected_words_it()
 * for each word to be processed
 **********************************************************************/

/**********************************************************************
 * word_blank_and_set_display()  Word processor
 *
 * Blank display of word then redisplay word according to current display mode
 * settings
 **********************************************************************/

BOOL8 word_blank_and_set_display(              // display a word
                                 BLOCK *block,  // block holding word
                                 ROW *row,      // row holding word
                                 WERD *word     // word to be processed
                                ) {
  word->bounding_box().plot(image_win, ScrollView::BLACK, ScrollView::BLACK);
  return word_set_display(block, row, word);
}


/**********************************************************************
 * word_bln_display()
 *
 * Normalise word and display in word window
 **********************************************************************/

BOOL8 word_bln_display(           // bln & display
                       BLOCK *,    // block holding word
                       ROW *row,   // row holding word
                       WERD *word  // word to be processed
                      ) {
  WERD *bln_word;

  bln_word = word->poly_copy(row->x_height());
  bln_word->baseline_normalise(row);
  bln_word_window_handle()->Clear();
  display_bln_lines(bln_word_window_handle(), ScrollView::CYAN,
                     1.0, 0.0f, -1000.0f, 1000.0f);
  bln_word->plot(bln_word_window_handle(), ScrollView::RED);
  delete bln_word;
  return TRUE;
}


/**********************************************************************
 * word_change_text()
 *
 * Change the correct text of a word
 **********************************************************************/

BOOL8 word_change_text(              // change correct text
                       BLOCK *block,  // block holding word
                       ROW *row,      // row holding word
                       WERD *word     // word to be processed
                      ) {
  char* cp = image_win->ShowInputDialog(
      "Enter/edit the correct text and press <<RETURN>>");
  word->set_text(cp);
  delete[] cp;

  if (word_display_mode.bit(DF_TEXT) || word->display_flag(DF_TEXT)) {
    word_blank_and_set_display(block, row, word);
    ScrollView::Update();
  }

  *current_image_changed = TRUE;
  return TRUE;
}


/**********************************************************************
 * word_copy()
 *
 * Copy a word to other display list
 **********************************************************************/

BOOL8 word_copy(              // copy a word
                BLOCK *block,  // block holding word
                ROW *row,      // row holding word
                WERD *word     // word to be processed
               ) {
  WERD *copy_word = new WERD;

  *copy_word = *word;
  add_word(copy_word, row, block, other_block_list);
  *other_image_changed = TRUE;
  return TRUE;
}


/**********************************************************************
 * word_delete()
 *
 * Delete a word
 **********************************************************************/

BOOL8 word_delete(                    // delete a word
                  BLOCK *block,        // block holding word
                  ROW *row,            // row holding word
                  WERD *word,          // word to be processed
                  BLOCK_IT &block_it,  // block list iterator
                  ROW_IT &row_it,      // row list iterator
                  WERD_IT &word_it     // word list iterator
                 ) {
  word_it.extract();
  word->bounding_box().plot(image_win, ScrollView::BLACK, ScrollView::BLACK);
  delete(word);

  if (word_it.empty()) {        // no words left in row
                                 // so delete row
    row_it.extract();
    row->bounding_box().plot(image_win, ScrollView::BLACK, ScrollView::BLACK);
    delete(row);

    if (row_it.empty()) {       // no rows left in blk
                                 // so delete block
      block_it.extract();
      block->bounding_box().plot(image_win, ScrollView::BLACK, ScrollView::BLACK);
      delete(block);
    }
  }
  *current_image_changed = TRUE;
  return TRUE;
}


/**********************************************************************
 *  word_display()  Word Processor
 *
 *  Display a word according to its display modes
 **********************************************************************/

BOOL8 word_display(           // display a word
                   BLOCK *,    // block holding word
                   ROW *row,   // row holding word
                   WERD *word  // word to be processed
                  ) {
  TBOX word_bb;                   // word bounding box
  int word_height;               // ht of word BB
  BOOL8 displayed_something = FALSE;
  BOOL8 displayed_rainbow = FALSE;
  float shift;                   // from bot left
  PBLOB_IT it;                   // blob iterator
  C_BLOB_IT c_it;                // cblob iterator
  WERD *word_ptr;                // poly copy
  WERD temp_word;
  float scale_factor;            // for BN_POLYGON

  /*
    Note the double coercions of(COLOUR)((inT32)editor_image_word_bb_color)
    etc. are to keep the compiler happy.
  */

                                 // display bounding box
  if (word->display_flag(DF_BOX)) {
    word->bounding_box().plot(image_win,
     (ScrollView::Color)((inT32)
      editor_image_word_bb_color),
     (ScrollView::Color)((inT32)
      editor_image_word_bb_color));

    ScrollView::Color c = (ScrollView::Color)
       ((inT32) editor_image_blob_bb_color);
    image_win->Pen(c);
    if (word->flag(W_POLYGON)) {
      it.set_to_list(word->blob_list());
      for (it.mark_cycle_pt(); !it.cycled_list(); it.forward())
        it.data()->bounding_box().plot(image_win);
    }
    else {
      c_it.set_to_list(word->cblob_list());
      for (c_it.mark_cycle_pt(); !c_it.cycled_list(); c_it.forward())
        c_it.data()->bounding_box().plot(image_win);
    }
    displayed_something = TRUE;
  }

                                 // display edge steps
  if (word->display_flag(DF_EDGE_STEP) &&
  !word->flag(W_POLYGON)) {     // edgesteps available
    word->plot(image_win);      // rainbow colors
    displayed_something = TRUE;
    displayed_rainbow = TRUE;
  }

                                 // display poly approx
  if (word->display_flag(DF_POLYGONAL)) {
                                 // need to convert
    if (!word->flag(W_POLYGON)) {
      word_ptr = word->poly_copy(row->x_height());

      /* CALL POLYGONAL APPROXIMATOR WHEN AVAILABLE - on a temp_word */

      if (displayed_rainbow)
                                 // ensure its visible
        word_ptr->plot(image_win, ScrollView::WHITE);
      else
                                 // rainbow colors
          word_ptr->plot(image_win);
      delete word_ptr;
    }
    else {
      if (displayed_rainbow)
                                 // ensure its visible
        word->plot(image_win, ScrollView::WHITE);
      else
        word->plot(image_win);  // rainbow colors
    }

    displayed_rainbow = TRUE;
    displayed_something = TRUE;
  }

                                 // disp BN poly approx
  if (word->display_flag(DF_BN_POLYGONAL)) {
                                 // need to convert
    if (!word->flag(W_POLYGON)) {
      word_ptr = word->poly_copy(row->x_height());
      temp_word = *word_ptr;
      delete word_ptr;

      /* CALL POLYGONAL APPROXIMATOR WHEN AVAILABLE - on a temp_word */

    }
    else
      temp_word = *word;         // copy word
    word_bb = word->bounding_box();
    if (!temp_word.flag(W_NORMALIZED))
      temp_word.baseline_normalise(row);

    scale_factor = re_scale_and_move_bln_word(&temp_word, word_bb);
    display_bln_lines(image_win, ScrollView::CYAN, scale_factor,
      word_bb.bottom(), word_bb.left(), word_bb.right());

    if (displayed_rainbow)
                                 // ensure its visible
      temp_word.plot(image_win, ScrollView::WHITE);
    else
      temp_word.plot(image_win); // rainbow colors

    displayed_rainbow = TRUE;
    displayed_something = TRUE;
  }

  // display correct text
  if (word->display_flag(DF_TEXT)) {
    word_bb = word->bounding_box();
    ScrollView::Color c =(ScrollView::Color)
       ((inT32) editor_image_blob_bb_color);
    image_win->Pen(c);
    word_height = word_bb.height();
    image_win->TextAttributes("Times", 0.75 * word_height,
                              false, false, false);
    if (word_height < word_bb.width())
      shift = 0.25 * word_height;
    else
      shift = 0.0f;

    image_win->Text(word_bb.left() + shift,
                    word_bb.bottom() + 0.25 * word_height, word->text());

    if (strlen(word->text()) > 0)
      displayed_something = TRUE;
  }

  if (!displayed_something)      // display BBox anyway
    word->bounding_box().plot(image_win,
     (ScrollView::Color)((inT32) editor_image_word_bb_color),
     (ScrollView::Color)((inT32)
      editor_image_word_bb_color));
  return TRUE;
}


/**********************************************************************
 * word_dumper()
 *
 * Dump members to the debug window
 **********************************************************************/

BOOL8 word_dumper(              // dump word
                  BLOCK *block,  // block holding word
                  ROW *row,      // row holding word
                  WERD *word     // word to be processed
                 ) {

  tprintf("\nBlock data...\n");
  block->print(NULL, FALSE);
  tprintf("\nRow data...\n");
  row->print(NULL);
  tprintf("\nWord data...\n");
  word->print(NULL);
  return TRUE;
}


/**********************************************************************
 * word_set_display()  Word processor
 *
 * Display word according to current display mode settings
 **********************************************************************/

BOOL8 word_set_display(              // display a word
                       BLOCK *block,  // block holding word
                       ROW *row,      // row holding word
                       WERD *word     // word to be processed
                      ) {
  TBOX word_bb;                   // word bounding box

  word->set_display_flag(DF_BOX, word_display_mode.bit(DF_BOX));
  word->set_display_flag(DF_TEXT, word_display_mode.bit(DF_TEXT));
  word->set_display_flag(DF_POLYGONAL, word_display_mode.bit(DF_POLYGONAL));
  word->set_display_flag(DF_EDGE_STEP, word_display_mode.bit(DF_EDGE_STEP));
  word->set_display_flag(DF_BN_POLYGONAL,
    word_display_mode.bit(DF_BN_POLYGONAL));
  *current_image_changed = TRUE;
  return word_display(block, row, word);
}


/**********************************************************************
 * word_toggle_seg()
 *
 * Toggle the correct segmentation flag
 **********************************************************************/

BOOL8 word_toggle_seg(           // toggle seg flag
                      BLOCK *,    // block holding word
                      ROW *,      // row holding word
                      WERD *word  // word to be processed
                     ) {
  word->set_flag(W_SEGMENTED, !word->flag(W_SEGMENTED));
  *current_image_changed = TRUE;
  return TRUE;
}


/* DEBUG ONLY */

void do_check_mem( // do it
                  inT32 level) {
  check_mem("Doing it", level);
}