pgedit.cpp

一ＯＣＲ的相关资料。．希望对研究ＯＣＲ的朋友有所帮助．

              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 ());
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  command_window->msg (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, INT_SOLID, FALSE, BLACK, 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);
  clear_view_surface (bln_word_window_handle ());
  display_bln_lines (bln_word_window_handle (), CYAN, 1.0, 0.0f, -1000.0f,
    1000.0f);
  bln_word->plot (bln_word_window_handle (), 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 response_str[MAX_CHARS + 1];

  strcpy (response_str, word->text ());
  if (!command_window->
    prompt ("Enter/edit the correct text and press <<RETURN>>",
    response_str))
    return FALSE;
  else
    word->set_text (response_str);

  if (word_display_mode.bit (DF_TEXT) || word->display_flag (DF_TEXT)) {
    word_blank_and_set_display(block, row, word);
    overlap_picture_ops(TRUE);
  }

  *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, INT_SOLID, FALSE, BLACK, BLACK);
  delete(word);

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

    if (row_it.empty ()) {       //no rows left in blk
                                 //so delete block
      block_it.extract ();
      block->bounding_box ().plot (image_win, INT_SOLID, FALSE,
        BLACK, 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
                  ) {
  BOX 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, INT_HOLLOW, TRUE,
      (COLOUR) ((INT32)
      editor_image_word_bb_color),
      (COLOUR) ((INT32)
      editor_image_word_bb_color));

    perimeter_color_index (image_win,
      (COLOUR) ((INT32) editor_image_blob_bb_color));
    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, WHITE);
      else
                                 //rainbow colors
          word_ptr->plot (image_win);
      delete word_ptr;
    }
    else {
      if (displayed_rainbow)
                                 //ensure its visible
        word->plot (image_win, 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, CYAN, scale_factor, word_bb.bottom (),
      word_bb.left (), word_bb.right ());

    if (displayed_rainbow)
                                 //ensure its visible
      temp_word.plot (image_win, 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 ();
    text_color_index (image_win,
      (COLOUR) ((INT32) editor_image_text_color));
    text_font_index (image_win, 1);
    word_height = word_bb.height ();
    character_height (image_win, 0.75 * word_height);

    if (word_height < word_bb.width ())
      shift = 0.25 * word_height;
    else
      shift = 0.0f;

    text2d (image_win,
      word_bb.left () + shift,
      word_bb.bottom () + 0.25 * word_height,
      word->text (), 0, FALSE);
    if (strlen (word->text ()) > 0)
      displayed_something = TRUE;
  }

  if (!displayed_something)      //display BBox anyway
    word->bounding_box ().plot (image_win, INT_HOLLOW, TRUE,
      (COLOUR) ((INT32) editor_image_word_bb_color),
      (COLOUR) ((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
                      ) {
  BOX 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);
}