pageblk.cpp

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

    background.set_bit (i, backg[i]);
}


void TEXT_BLOCK::add_a_region(TEXT_REGION *newchild) { 
  TEXT_REGION_IT c;

  c.set_to_list (&text_regions);

  c.move_to_first ();
  c.add_to_end (newchild);
}


/**********************************************************************
 * TEXT_BLOCK::rotate
 *
 * Rotate the TEXT_BLOCK and its children
 **********************************************************************/

void TEXT_BLOCK::rotate(  //cos,sin
                        FCOORD rotation) {
                                 //sub block iterator
  TEXT_REGION_IT child_it = &text_regions;
  TEXT_REGION *child;            //child block

  for (child_it.mark_cycle_pt (); !child_it.cycled_list ();
  child_it.forward ()) {
    child = child_it.data ();
    child->rotate (rotation);
  }
  POLY_BLOCK::rotate(rotation); 
}


/**********************************************************************
 * TEXT_BLOCK::move
 *
 * Move the TEXT_BLOCK and its children
 **********************************************************************/

void TEXT_BLOCK::move(ICOORD shift  //amount to move
                     ) {
                                 //sub block iterator
  TEXT_REGION_IT child_it = &text_regions;
  TEXT_REGION *child;            //child block

  for (child_it.mark_cycle_pt (); !child_it.cycled_list ();
  child_it.forward ()) {
    child = child_it.data ();
    child->move (shift);
  }
  POLY_BLOCK::move(shift); 
}


/**********************************************************************
 * TEXT_BLOCK::serialise_asc()  Convert to ascii file.
 *
 **********************************************************************/

void TEXT_BLOCK::serialise_asc(         //convert to ascii
                               FILE *f  //file to use
                              ) {
  ((PAGE_BLOCK *) this)->internal_serialise_asc (f);
  serialise_INT32 (f, background.val);
  text_regions.serialise_asc (f);
}


/**********************************************************************
 * TEXT_BLOCK::de_serialise_asc()  Convert from ascii file.
 *
 **********************************************************************/

void TEXT_BLOCK::de_serialise_asc(         //convert from ascii
                                  FILE *f  //file to use
                                 ) {
  ((PAGE_BLOCK *) this)->de_serialise_asc (f);
  background.val = de_serialise_INT32 (f);
  text_regions.de_serialise_asc (f);
}


#ifndef GRAPHICS_DISABLED
void TEXT_BLOCK::plot(WINDOW window,
                      COLOUR colour,
                      COLOUR region_colour,
                      COLOUR subregion_colour) {
  TEXT_REGION_IT t = &text_regions, tc;

  PAGE_BLOCK::basic_plot(window, colour); 

  if (!t.empty ())
  for (t.mark_cycle_pt (); !t.cycled_list (); t.forward ()) {
    t.data ()->plot (window, region_colour, t.data ()->id_no ());
    tc.set_to_list (t.data ()->regions ());
    if (!tc.empty ())
      for (tc.mark_cycle_pt (); !tc.cycled_list (); tc.forward ())
        tc.data ()->plot (window, subregion_colour, -1);
  }
}
#endif


void TEXT_BLOCK::show_attrs(DEBUG_WIN *f) { 
  TEXT_REGION_IT it;

  f->dprintf ("TEXT BLOCK\n");
  print_background(f, background); 
  if (!text_regions.empty ()) {
    f->dprintf ("containing text regions:\n");
    it.set_to_list (&text_regions);
    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
      it.data ()->show_attrs (f);
    f->dprintf ("end of regions\n");
  }
}


DLLSYM void show_all_tr_in(TEXT_BLOCK *tblock,
                           POLY_BLOCK *show_area,
                           DEBUG_WIN *f) {
  TEXT_REGION_IT t, tc;
  INT16 i, tnum, j, ttnum;

  t.set_to_list (tblock->regions ());
  tnum = tblock->regions ()->length ();
  for (i = 0; i < tnum; i++, t.forward ()) {
    if (show_area->contains (t.data ()))
      t.data ()->show_attrs (f);
    else if (show_area->overlap (t.data ())) {
      tc.set_to_list (t.data ()->regions ());
      ttnum = t.data ()->regions ()->length ();
      for (j = 0; j < ttnum; j++, tc.forward ())
        if (show_area->contains (tc.data ()))
          tc.data ()->show_attrs (f);
    }
  }
}


void delete_all_tr_in(TEXT_BLOCK *tblock, POLY_BLOCK *delete_area) { 
  TEXT_REGION_IT t, tc;
  INT16 i, tnum, j, ttnum;

  t.set_to_list (tblock->regions ());
  tnum = tblock->regions ()->length ();
  for (i = 0; i < tnum; i++, t.forward ()) {
    if (delete_area->contains (t.data ()))
      delete (t.extract ());
    else if (delete_area->overlap (t.data ())) {
      tc.set_to_list (t.data ()->regions ());
      ttnum = t.data ()->regions ()->length ();
      for (j = 0; j < ttnum; j++, tc.forward ())
        if (delete_area->contains (tc.data ()))
          delete (tc.extract ());
    }
  }
}


RULE_BLOCK::RULE_BLOCK (ICOORDELT_LIST * points, INT8 sing, INT8 colo):PAGE_BLOCK (points,
PB_RULES) {
  multiplicity = sing;
  colour = colo;
}


void RULE_BLOCK::set_attrs(INT8 sing, INT8 colo) { 
  multiplicity = sing;
  colour = colo;
}


void RULE_BLOCK::show_attrs(DEBUG_WIN *f) { 
  f->dprintf ("RULE BLOCK with attributes %s, %s\n",
    blabel[R_START][multiplicity], blabel[R_START + 1][colour]);
}


/**********************************************************************
 * RULE_BLOCK::serialise_asc()  Convert to ascii file.
 *
 **********************************************************************/

void RULE_BLOCK::serialise_asc(         //convert to ascii
                               FILE *f  //file to use
                              ) {
  ((PAGE_BLOCK *) this)->internal_serialise_asc (f);
  serialise_INT32(f, multiplicity); 
  serialise_INT32(f, colour); 
}


/**********************************************************************
 * RULE_BLOCK::de_serialise_asc()  Convert from ascii file.
 *
 **********************************************************************/

void RULE_BLOCK::de_serialise_asc(         //convert from ascii
                                  FILE *f  //file to use
                                 ) {
  ((PAGE_BLOCK *) this)->de_serialise_asc (f);
  multiplicity = de_serialise_INT32 (f);
  colour = de_serialise_INT32 (f);
}


GRAPHICS_BLOCK::GRAPHICS_BLOCK (ICOORDELT_LIST * points, BOOL8 backg[NUM_BACKGROUNDS], INT8 foreg):PAGE_BLOCK (points,
PB_GRAPHICS) {
  int
    i;

  for (i = 0; i < NUM_BACKGROUNDS; i++)
    background.set_bit (i, backg[i]);

  foreground = foreg;
}


void
GRAPHICS_BLOCK::set_attrs (BOOL8 backg[NUM_BACKGROUNDS], INT8 foreg) {
  int i;

  for (i = 0; i < NUM_BACKGROUNDS; i++)
    background.set_bit (i, backg[i]);

  foreground = foreg;
}


void GRAPHICS_BLOCK::show_attrs(DEBUG_WIN *f) { 
  f->dprintf ("GRAPHICS BLOCK with attribute %s\n",
    blabel[G_START][foreground]);
  print_background(f, background); 
}


/**********************************************************************
 * GRAPHICS_BLOCK::serialise_asc()  Convert to ascii file.
 *
 **********************************************************************/

void GRAPHICS_BLOCK::serialise_asc(         //convert to ascii
                                   FILE *f  //file to use
                                  ) {
  ((PAGE_BLOCK *) this)->internal_serialise_asc (f);
  serialise_INT32 (f, background.val);
  serialise_INT32(f, foreground); 
}


/**********************************************************************
 * GRAPHICS_BLOCK::de_serialise_asc()  Convert from ascii file.
 *
 **********************************************************************/

void GRAPHICS_BLOCK::de_serialise_asc(         //convert from ascii
                                      FILE *f  //file to use
                                     ) {
  ((PAGE_BLOCK *) this)->de_serialise_asc (f);
  background.val = de_serialise_INT32 (f);
  foreground = de_serialise_INT32 (f);
}


IMAGE_BLOCK::IMAGE_BLOCK (ICOORDELT_LIST * points, INT8 colo, INT8 qual):PAGE_BLOCK (points,
PB_IMAGE) {
  colour = colo;
  quality = qual;
}


void IMAGE_BLOCK::set_attrs(INT8 colo, INT8 qual) { 
  colour = colo;
  quality = qual;
}


void IMAGE_BLOCK::show_attrs(DEBUG_WIN *f) { 
  f->dprintf ("IMAGE BLOCK with attributes %s, %s\n", blabel[I_START][colour],
    blabel[I_START + 1][quality]);
}


/**********************************************************************
 * IMAGE_BLOCK::serialise_asc()  Convert to ascii file.
 *
 **********************************************************************/

void IMAGE_BLOCK::serialise_asc(         //convert to ascii
                                FILE *f  //file to use
                               ) {
  ((PAGE_BLOCK *) this)->internal_serialise_asc (f);
  serialise_INT32(f, colour); 
  serialise_INT32(f, quality); 
}


/**********************************************************************
 * IMAGE_BLOCK::de_serialise_asc()  Convert from ascii file.
 *
 **********************************************************************/

void IMAGE_BLOCK::de_serialise_asc(         //convert from ascii
                                   FILE *f  //file to use
                                  ) {
  ((PAGE_BLOCK *) this)->de_serialise_asc (f);
  colour = de_serialise_INT32 (f);
  quality = de_serialise_INT32 (f);
}


SCRIBBLE_BLOCK::SCRIBBLE_BLOCK (ICOORDELT_LIST * points, BOOL8 backg[NUM_BACKGROUNDS], INT8 foreg):PAGE_BLOCK (points,
PB_SCRIBBLE) {
  int
    i;

  for (i = 0; i < NUM_BACKGROUNDS; i++)
    background.set_bit (i, backg[i]);

  foreground = foreg;
}


void
SCRIBBLE_BLOCK::set_attrs (BOOL8 backg[NUM_BACKGROUNDS], INT8 foreg) {
  int i;

  for (i = 0; i < NUM_BACKGROUNDS; i++)
    background.set_bit (i, backg[i]);

  foreground = foreg;
}


void SCRIBBLE_BLOCK::show_attrs(DEBUG_WIN *f) { 
  f->dprintf ("SCRIBBLE BLOCK with attributes %s\n",
    blabel[S_START][foreground]);
  print_background(f, background); 
}


/**********************************************************************
 * SCRIBBLE_BLOCK::serialise_asc()  Convert to ascii file.
 *
 **********************************************************************/

void SCRIBBLE_BLOCK::serialise_asc(         //convert to ascii
                                   FILE *f  //file to use
                                  ) {
  ((PAGE_BLOCK *) this)->internal_serialise_asc (f);
  serialise_INT32 (f, background.val);
  serialise_INT32(f, foreground); 
}


/**********************************************************************
 * SCRIBBLE_BLOCK::de_serialise_asc()  Convert from ascii file.
 *
 **********************************************************************/

void SCRIBBLE_BLOCK::de_serialise_asc(         //convert from ascii
                                      FILE *f  //file to use
                                     ) {
  ((PAGE_BLOCK *) this)->de_serialise_asc (f);
  background.val = de_serialise_INT32 (f);
  foreground = de_serialise_INT32 (f);
}


WEIRD_BLOCK::WEIRD_BLOCK (ICOORDELT_LIST * points, INT32 id_no):PAGE_BLOCK (points,
PB_WEIRD) {
  id_number = id_no;
}


#ifndef GRAPHICS_DISABLED
void WEIRD_BLOCK::plot(WINDOW window, COLOUR colour) { 
  PAGE_BLOCK_IT c = this->child ();

  POLY_BLOCK::plot(window, colour, id_number); 

  if (!c.empty ())
    for (c.mark_cycle_pt (); !c.cycled_list (); c.forward ())
      c.data ()->plot (window, colour);
}
#endif


void WEIRD_BLOCK::set_id(INT32 id_no) { 
  id_number = id_no;
}


void WEIRD_BLOCK::show_attrs(DEBUG_WIN *f) { 
  f->dprintf ("WEIRD BLOCK with id number %d\n", id_number);
}


/**********************************************************************
 * WEIRD_BLOCK::serialise_asc()  Convert to ascii file.
 *
 **********************************************************************/

void WEIRD_BLOCK::serialise_asc(         //convert to ascii
                                FILE *f  //file to use
                               ) {
  ((PAGE_BLOCK *) this)->internal_serialise_asc (f);
  serialise_INT32(f, id_number); 
}


/**********************************************************************
 * WEIRD_BLOCK::de_serialise_asc()  Convert from ascii file.
 *
 **********************************************************************/

void WEIRD_BLOCK::de_serialise_asc(         //convert from ascii
                                   FILE *f  //file to use
                                  ) {
  ((PAGE_BLOCK *) this)->de_serialise_asc (f);
  id_number = de_serialise_INT32 (f);
}


void print_background(DEBUG_WIN *f, BITS16 background) { 
  int i;

  f->dprintf ("Background is \n");
  for (i = 0; i < NUM_BACKGROUNDS; i++) {
    if (background.bit (i))
      f->dprintf ("%s, ", backlabel[i]);
  }

  f->dprintf ("\n");

}