blread.cpp

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

          block_no++;
          tr = tr_it.data ();
          block_box = tr->bounding_box ();
          block = new BLOCK (name, TRUE, 0, 0,
            block_box->left (), block_box->bottom (),
            block_box->right (), block_box->top ());
          block->hand_block = tr;
          block->hand_poly = tr;
          block_it->add_after_then_move (block);
        }
      }
    }
    else if (current_block->type () == PB_WEIRD
      && !ignore_weird_blocks
    && ((WEIRD_BLOCK *) current_block)->id_no () > 0) {
      block_no++;
      block_box = current_block->bounding_box ();
      block = new BLOCK (name, TRUE, 0, 0,
        block_box->left (), block_box->bottom (),
        block_box->right (), block_box->top ());
      block->hand_block = NULL;
      block->hand_poly = current_block;
      block_it->add_after_then_move (block);
    }
    if (!current_block->child ()->empty ())
      scan_hpd_blocks (name, current_block->child (), block_no, block_it);
  }
}





/**********************************************************************
 * BLOCK::read_vec_file
 *
 * Read a whole vec file to make a list of blocks.
 * Return FALSE if the .vec fiel cannot be found
 **********************************************************************/

BOOL8 read_vec_file(                    //print list of sides
                    STRING name,        //basename of file
                    INT32 xsize,        //image size
                    INT32 ysize,        //image size
                    BLOCK_LIST *blocks  //output list
                   ) {
  FILE *pdfp;                    //file pointer
  BLOCK *block;                  //current block
  INT32 block_no;                //no of blocks
  INT32 block_index;             //current blocks
  INT32 vector_count;            //total vectors
  VEC_HEADER header;             //file header
  BLOCK_HEADER *vec_blocks;      //blocks from file
  VEC_ENTRY *vec_entries;        //vectors from file
  BLOCK_IT block_it = blocks;    //block iterator
  ICOORDELT_IT left_it;          //iterators
  ICOORDELT_IT right_it;

  name += VEC_EXT;               //add extension
  if ((pdfp = fopen (name.string (), "r")) == NULL) {
    return FALSE;                //can't find it
  }
  if (fread (&header, sizeof (header), 1, pdfp) != 1)
    READFAILED.error ("read_vec_file", EXIT, "Header");
                                 //from intel
  header.filesize = reverse32 (header.filesize);
  header.bytesize = reverse16 (header.bytesize);
  header.arraysize = reverse16 (header.arraysize);
  header.width = reverse16 (header.width);
  header.height = reverse16 (header.height);
  header.res = reverse16 (header.res);
  header.bpp = reverse16 (header.bpp);
  tprintf ("%d blocks in %s file:", header.arraysize, VEC_EXT);
  vector_count = header.filesize - header.arraysize * sizeof (BLOCK_HEADER);
  vector_count /= sizeof (VEC_ENTRY);
  vec_blocks =
    (BLOCK_HEADER *) alloc_mem (header.arraysize * sizeof (BLOCK_HEADER));
  vec_entries = (VEC_ENTRY *) alloc_mem (vector_count * sizeof (VEC_ENTRY));
  xsize = header.width;          //real image size
  ysize = header.height;
  if (fread (vec_blocks, sizeof (BLOCK_HEADER), header.arraysize, pdfp)
    != static_cast<size_t>(header.arraysize))
    READFAILED.error ("read_vec_file", EXIT, "Blocks");
  if (fread (vec_entries, sizeof (VEC_ENTRY), vector_count, pdfp)
    != static_cast<size_t>(vector_count))
    READFAILED.error ("read_vec_file", EXIT, "Vectors");
  for (block_index = 0; block_index < header.arraysize; block_index++) {
    vec_blocks[block_index].offset =
      reverse16 (vec_blocks[block_index].offset);
    vec_blocks[block_index].order =
      reverse16 (vec_blocks[block_index].order);
    vec_blocks[block_index].entries =
      reverse16 (vec_blocks[block_index].entries);
    vec_blocks[block_index].charsize =
      reverse16 (vec_blocks[block_index].charsize);
  }
  for (block_index = 0; block_index < vector_count; block_index++) {
    vec_entries[block_index].start =
      ICOORD (reverse16 (vec_entries[block_index].start.x ()),
      reverse16 (vec_entries[block_index].start.y ()));
    vec_entries[block_index].end =
      ICOORD (reverse16 (vec_entries[block_index].end.x ()),
      reverse16 (vec_entries[block_index].end.y ()));
  }
  for (block_no = 1; block_no <= header.arraysize; block_no++) {
    for (block_index = 0; block_index < header.arraysize; block_index++) {
      if (vec_blocks[block_index].order == block_no
      && vec_blocks[block_index].valid) {
        block = new BLOCK;
        left_it.set_to_list (&block->leftside);
        right_it.set_to_list (&block->rightside);
        block->box =
          convert_vec_block (&vec_entries
          [vec_blocks[block_index].offset],
          vec_blocks[block_index].entries, ysize,
          &left_it, &right_it);
        block->set_xheight (vec_blocks[block_index].charsize);
                                 //on end of list
        block_it.add_to_end (block);
        //                              tprintf("Block at (%d,%d)->(%d,%d) has index %d and order %d\n",
        //                                      block->box.left(),
        //                                      block->box.bottom(),
        //                                      block->box.right(),
        //                                      block->box.top(),
        //                                      block_index,vec_blocks[block_index].order);
      }
    }
  }
  free_mem(vec_blocks);
  free_mem(vec_entries);
  tprintf ("%d valid\n", block_it.length ());
  fclose(pdfp);
  return TRUE;                   //read one
}


/**********************************************************************
 * BLOCK::convert_vec_block
 *
 * Read a whole vec file to make a list of blocks.
 * Return FALSE if the .vec fiel cannot be found
 **********************************************************************/

static BOX convert_vec_block(                        //make non-rect block
                             VEC_ENTRY *entries,     //vectors
                             UINT16 entry_count,     //no of entries
                             INT32 ysize,            //image size
                             ICOORDELT_IT *left_it,  //block sides
                             ICOORDELT_IT *right_it) {
  BOX block_box;                 //bounding box
  BOX vec_box;                   //box of vec
  ICOORD box_point;              //expanded coord
  ICOORD shift_vec;              //for box expansion
  ICOORD prev_pt;                //previous coord
  ICOORD end_pt;                 //end of vector
  INT32 vertex_index;            //boundary vertices

  for (vertex_index = 0; vertex_index < entry_count; vertex_index++) {
    entries[vertex_index].start = ICOORD (entries[vertex_index].start.x (),
      ysize - 1 -
      entries[vertex_index].start.y ());
    entries[vertex_index].end =
      ICOORD (entries[vertex_index].end.x (),
      ysize - 1 - entries[vertex_index].end.y ());
    vec_box = BOX (entries[vertex_index].start, entries[vertex_index].end);
    block_box += vec_box;        //find total bounds
  }

  for (vertex_index = 0; vertex_index < entry_count
    && (entries[vertex_index].start.y () != block_box.bottom ()
    || entries[vertex_index].end.y () != block_box.bottom ());
    vertex_index++);
  ASSERT_HOST (vertex_index < entry_count);
  prev_pt = entries[vertex_index].start;
  end_pt = entries[vertex_index].end;
  do {
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found start of vertical
    ASSERT_HOST (vertex_index < entry_count);
    box_point = entries[vertex_index].start;
    if (box_point.x () <= prev_pt.x ())
      shift_vec = ICOORD (-BLOCK_EXPANSION, -BLOCK_EXPANSION);
    else
      shift_vec = ICOORD (-BLOCK_EXPANSION, BLOCK_EXPANSION);
    left_it->add_to_end (new ICOORDELT (box_point + shift_vec));
    prev_pt = box_point;
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found horizontal
    ASSERT_HOST (vertex_index < entry_count);
    end_pt = entries[vertex_index].end;
  }
  while (end_pt.y () < block_box.top ());
  shift_vec = ICOORD (-BLOCK_EXPANSION, BLOCK_EXPANSION);
  left_it->add_to_end (new ICOORDELT (end_pt + shift_vec));

  for (vertex_index = 0; vertex_index < entry_count
    && (entries[vertex_index].start.y () != block_box.top ()
    || entries[vertex_index].end.y () != block_box.top ());
    vertex_index++);
  ASSERT_HOST (vertex_index < entry_count);
  prev_pt = entries[vertex_index].start;
  end_pt = entries[vertex_index].end;
  do {
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found start of vertical
    ASSERT_HOST (vertex_index < entry_count);
    box_point = entries[vertex_index].start;
    if (box_point.x () < prev_pt.x ())
      shift_vec = ICOORD (BLOCK_EXPANSION, -BLOCK_EXPANSION);
    else
      shift_vec = ICOORD (BLOCK_EXPANSION, BLOCK_EXPANSION);
    right_it->add_before_then_move (new ICOORDELT (box_point + shift_vec));
    prev_pt = box_point;
    for (vertex_index = 0; vertex_index < entry_count
      && entries[vertex_index].start != end_pt; vertex_index++);
                                 //found horizontal
    ASSERT_HOST (vertex_index < entry_count);
    end_pt = entries[vertex_index].end;
  }
  while (end_pt.y () > block_box.bottom ());
  shift_vec = ICOORD (BLOCK_EXPANSION, -BLOCK_EXPANSION);
  right_it->add_before_then_move (new ICOORDELT (end_pt + shift_vec));

  shift_vec = ICOORD (BLOCK_EXPANSION, BLOCK_EXPANSION);
  box_point = block_box.botleft () - shift_vec;
  end_pt = block_box.topright () + shift_vec;
  return BOX (box_point, end_pt);
}


/**********************************************************************
 * read_unlv_file
 *
 * Read a whole unlv zone file to make a list of blocks.
 **********************************************************************/

BOOL8 read_unlv_file(                    //print list of sides
                     STRING name,        //basename of file
                     INT32 xsize,        //image size
                     INT32 ysize,        //image size
                     BLOCK_LIST *blocks  //output list
                    ) {
  FILE *pdfp;                    //file pointer
  BLOCK *block;                  //current block
  int x;                         //current top-down coords
  int y;
  int width;                     //of current block
  int height;
  BLOCK_IT block_it = blocks;    //block iterator

  name += UNLV_EXT;              //add extension
  if ((pdfp = fopen (name.string (), "r")) == NULL) {
    return FALSE;                //didn't read one
  }
  else {
    while (fscanf (pdfp, "%d %d %d %d %*s", &x, &y, &width, &height) >= 4) {
                                 //make rect block
      block = new BLOCK (name.string (), TRUE, 0, 0, (INT16) x, (INT16) (ysize - 1 - y - height), (INT16) (x + width), (INT16) (ysize - 1 - y));
                                 //on end of list
      block_it.add_to_end (block);
    }
    fclose(pdfp);
  }
  return true;
}