textord/scanedg.h File Reference

#include "varable.h"
#include "grphics.h"
#include "img.h"
#include "pdblock.h"
#include "crakedge.h"

Go to the source code of this file.

Functions

• DLLSYM void block_edges (IMAGE *t_image, PDBLK *block, ICOORD page_tr)

  Extract edges from a PDBLK.
  

• void free_crackedges (CRACKEDGE *start)

  Really free them.
  

• CRACKEDGE * h_edge (INT16 x, INT16 y, INT8 sign, CRACKEDGE *join)

  Horizontal edge.
  

• void join_edges (CRACKEDGE *edge1, CRACKEDGE *edge2)

  Join edge fragments.
  

• void line_edges (INT16 x, INT16 y, INT16 xext, UINT8 uppercolour, UINT8 *bwpos, CRACKEDGE **prevline)

  Scan for edges.
  

• void make_margins (PDBLK *block, BLOCK_LINE_IT *line_it, UINT8 *pixels, UINT8 margin, INT16 left, INT16 right, INT16 y)

  Get a line.
  

• CRACKEDGE * v_edge (INT16 x, INT16 y, INT8 sign, CRACKEDGE *join)

  Vertical edge.
  

• void whiteout_block (IMAGE *t_image, PDBLK *block)

  Clean it.
  

---

Function Documentation

DLLSYM void block_edges	(	IMAGE *	t_image,
		PDBLK *	block,
		ICOORD	page_tr
	)

Extract edges from a PDBLK.

Parameters:

	t_image	Threshold image
	block	Block in image
	page_tr	Corner of page

Returns:

none (block modified)

Note:

Changed for v1.03

Definition at line 55 of file scanedg.cpp.

References free_crackedges(), free_cracks, IMAGE::get_line(), IMAGE::get_xsize(), IMAGELINE::init(), line_edges(), make_margins(), MAXIMAGEWIDTH, NULL, IMAGELINE::pixels, WHITE, and ICOORD::y().

Referenced by get_outlines().

                         {
  UINT8 margin;                  //margin colour
  INT16 x;                       //line coords
  INT16 y;                       //current line
  ICOORD bleft;                  //bounding box
  ICOORD tright;
  ICOORD block_bleft;            //bounding box
  ICOORD block_tright;
  int xindex;                    //index to pixel
  BLOCK_LINE_IT line_it = block; //line iterator
  IMAGELINE bwline;              //thresholded line
                                 //lines in progress
  CRACKEDGE *ptrlinemem[MAXIMAGEWIDTH];
  CRACKEDGE **ptrline = ptrlinemem;

  if (t_image->get_xsize()+1 > MAXIMAGEWIDTH) {
    ptrline = new CRACKEDGE*[t_image->get_xsize()+1];
  }

                                 //block box
  block->bounding_box (bleft, tright);
  block_bleft = bleft;
  block_tright = tright;
  for (x = tright.x () - bleft.x (); x >= 0; x--)
    ptrline[x] = NULL;           //no lines in progress

  bwline.init (t_image->get_xsize());

  margin = WHITE;

  for (y = tright.y () - 1; y >= bleft.y () - 1; y--) {
    if (y >= block_bleft.y () && y < block_tright.y ()) {
      t_image->get_line (bleft.x (), y, tright.x () - bleft.x (), &bwline,
        0);
      make_margins (block, &line_it, bwline.pixels, margin, bleft.x (),
        tright.x (), y);
    }
    else {
      x = tright.x () - bleft.x ();
      for (xindex = 0; xindex < x; xindex++)
        bwline.pixels[xindex] = margin;
    }
    line_edges (bleft.x (), y, tright.x () - bleft.x (),
      margin, bwline.pixels, ptrline);
  }

  free_crackedges(free_cracks);  //really free them
  free_cracks = NULL;
  if (ptrline != ptrlinemem) {
    delete [] ptrline;
  }
}

void free_crackedges

(

CRACKEDGE *

start

)

Really free them.

Really free the CRACKEDGEs by giving them back to delete.

Definition at line 554 of file scanedg.cpp.

References CRACKEDGE::next, and NULL.

Referenced by block_edges().

                      {
  CRACKEDGE *current;            //current edge to free
  CRACKEDGE *next;               //next one to free

  for (current = start; current != NULL; current = next) {
    next = current->next;
    delete current;              //delete them all
  }
}

CRACKEDGE* h_edge	(	INT16	x,
		INT16	y,
		INT8	sign,
		CRACKEDGE *	join
	)

Horizontal edge.

Create a new horizontal CRACKEDGE and join it to the given edge.

Definition at line 351 of file scanedg.cpp.

References cprintf(), free_cracks, join(), list_rec::next, CRACKEDGE::next, NULL, CRACKEDGE::pos, CRACKEDGE::prev, ICOORD::set_x(), ICOORD::set_y(), CRACKEDGE::stepdir, CRACKEDGE::stepx, CRACKEDGE::stepy, and ICOORD::y().

Referenced by line_edges().

  {
  CRACKEDGE *newpt;              //return value

  //      check_mem("h_edge",JUSTCHECKS);
  if (free_cracks != NULL) {
    newpt = free_cracks;
    free_cracks = newpt->next;   //get one fast
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSC)
  cprintf("a"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  else {
    newpt = new CRACKEDGE;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSC)
  cprintf("b"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  newpt->pos.set_y (y + 1);      //coords of pt
  newpt->stepy = 0;              //edge is horizontal

  if (sign > 0) {
    newpt->pos.set_x (x + 1);    //start location
    newpt->stepx = -1;
    newpt->stepdir = 0;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSC)
  cprintf("c"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  else {
    newpt->pos.set_x (x);        //start location
    newpt->stepx = 1;
    newpt->stepdir = 2;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSC)
  cprintf("d"); // check under 'e' in ccmain/tessvars.h
#endif
  }

  if (join == NULL) {
    newpt->next = newpt;         //ptrs to other ends
    newpt->prev = newpt;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSC)
  cprintf("f"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  else {
    if (newpt->pos.x () + newpt->stepx == join->pos.x ()
    && newpt->pos.y () == join->pos.y ()) {
      newpt->prev = join->prev;  //update other ends
      newpt->prev->next = newpt;
      newpt->next = join;        //join up
      join->prev = newpt;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSC)
  cprintf("g"); // check under 'e' in ccmain/tessvars.h
#endif
    }
    else {
      newpt->next = join->next;  //update other ends
      newpt->next->prev = newpt;
      newpt->prev = join;        //join up
      join->next = newpt;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSC)
  cprintf("h"); // check under 'e' in ccmain/tessvars.h
#endif
    }
  }
  return newpt;
}

void join_edges	(	CRACKEDGE *	edge1,
		CRACKEDGE *	edge2
	)

Join edge fragments.

Join two edges together & send the outline for approximation when a closed loop is formed.

Definition at line 510 of file scanedg.cpp.

References complete_edge(), cprintf(), free_cracks, CRACKEDGE::next, CRACKEDGE::pos, CRACKEDGE::prev, CRACKEDGE::stepx, CRACKEDGE::stepy, and ICOORD::y().

Referenced by line_edges().

                 {
  CRACKEDGE *tempedge;           //for exchanging

  if (edge1->pos.x () + edge1->stepx != edge2->pos.x ()
  || edge1->pos.y () + edge1->stepy != edge2->pos.y ()) {
    tempedge = edge1;
    edge1 = edge2;               //swap around
    edge2 = tempedge;
  }

  //      tprintf("Joining %x=(%d,%d)+(%d,%d)->%x<-%x ",
  //              edge1,edge1->pos.x(),edge1->pos.y(),edge1->stepx,edge1->stepy,
  //              edge1->next,edge1->prev);
  //      tprintf("to %x=(%d,%d)+(%d,%d)->%x<-%x\n",
  //              edge2,edge2->pos.x(),edge2->pos.y(),edge2->stepx,edge2->stepy,
  //              edge2->next,edge2->prev);
  if (edge1->next == edge2) {
#if defined(TEXT_VERBOSE) && !defined(TV_FOCUSE)
  cprintf("c"); // gets a 'e', see ccmain/tessvars.h
#endif
                                 //already closed
    complete_edge(edge1);  //approximate it
                                 //attach freelist to end
    edge1->prev->next = free_cracks;
    free_cracks = edge1;         //and free list
  }
  else {
                                 //update opposite ends
    edge2->prev->next = edge1->next;
    edge1->next->prev = edge2->prev;
    edge1->next = edge2;         //make joins
    edge2->prev = edge1;
  }
}

void line_edges	(	INT16	x,
		INT16	y,
		INT16	xext,
		UINT8	uppercolour,
		UINT8 *	bwpos,
		CRACKEDGE **	prevline
	)

Scan for edges.

Parameters:

	x	Coord of line start
	y	Coord of line start
	xext	Width of line
	uppercolour	Start of previous line
	bwpos	Thresholded line
	prevline	Edges in progress
	prevline	Edges in progress

Scan a line for edges and update prevline (edges in progress). When edges close into loops, send them for approximation.

See the glossary under Edge Detection for all the gory details (that used to be here!)

Definition at line 218 of file scanedg.cpp.

References cprintf(), FLIP_COLOUR, h_edge(), join_edges(), NULL, v_edge(), and WHITE_PIX.

Referenced by block_edges().

  {
  int xpos;                      //current x coord
  int xmax;                      //max x coord
  int colour;                    //of current pixel
  int prevcolour;                //of previous pixel
  CRACKEDGE *current;            //current h edge
  CRACKEDGE *newcurrent;         //new h edge

#if defined(TEXT_VERBOSE)
#if defined(TV_FOCUSE)
  cprintf("\n"); // breaks up copious output into rows
#endif
  cprintf("e"); // gets a 'e', see ccmain/tessvars.h
#endif
  xmax = x + xext;               //max allowable coord
  prevcolour = uppercolour;      //forced plain margin
  current = NULL;                //nothing yet

                                 //do each pixel
  for (xpos = x; xpos < xmax; xpos++, prevline++) {
    colour = *bwpos++;           //current pixel
    if (*prevline != NULL) {
                                 //changed above
                                 //change colour
      uppercolour = FLIP_COLOUR (uppercolour);
      if (colour == prevcolour) {
        if (colour == uppercolour) {
                                 //finish a line
          join_edges(current, *prevline);
          current = NULL;        //no edge now
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("C"); // check under 'e' in ccmain/tessvars.h
#endif
        }
        else {
                                 //new horiz edge
          current = h_edge (xpos, y, uppercolour - colour, *prevline);
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("L"); // check under 'e' in ccmain/tessvars.h
#endif
      }
        *prevline = NULL;        //no change this time
      }
      else {
        if (colour == uppercolour) {
          *prevline = v_edge (xpos, y, colour - prevcolour, *prevline);
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("K"); // check under 'e' in ccmain/tessvars.h
#endif
      }
                                 //8 vs 4 connection
        else if (colour == WHITE_PIX) {
          join_edges(current, *prevline);
          current = h_edge (xpos, y, uppercolour - colour, NULL);
          *prevline = v_edge (xpos, y, colour - prevcolour, current);
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("J"); // check under 'e' in ccmain/tessvars.h
#endif
        }
        else {
          newcurrent = h_edge (xpos, y, uppercolour - colour, *prevline);
          *prevline = v_edge (xpos, y, colour - prevcolour, current);
          current = newcurrent;  //right going h edge
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("H"); // check under 'e' in ccmain/tessvars.h
#endif
        }
        prevcolour = colour;     //remember new colour
      }
    }
    else {
      if (colour != prevcolour) {
        *prevline = current =
          v_edge (xpos, y, colour - prevcolour, current);
        prevcolour = colour;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("D"); // check under 'e' in ccmain/tessvars.h
#endif
      }
      if (colour != uppercolour) {
        current = h_edge (xpos, y, uppercolour - colour, current);
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("E"); // check under 'e' in ccmain/tessvars.h
#endif
     }
      else {
        current = NULL;          //no edge now
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("="); // check under 'e' in ccmain/tessvars.h
#endif
     }
    }
  }//for xpos
  if (current != NULL) {
                                 //out of block
    if (*prevline != NULL) {     //got one to join to?
      join_edges(current, *prevline);
      *prevline = NULL;          //tidy now
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("M"); // check under 'e' in ccmain/tessvars.h
#endif
    }
    else {
                                 //fake vertical
      *prevline = v_edge (xpos, y, FLIP_COLOUR(prevcolour)-prevcolour, current);
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("N"); // check under 'e' in ccmain/tessvars.h
#endif
    }
  }
  else if (*prevline != NULL) {
                                 //continue fake
    *prevline = v_edge (xpos, y, FLIP_COLOUR(prevcolour)-prevcolour, *prevline);
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSE)
  cprintf("O"); // check under 'e' in ccmain/tessvars.h
#endif
  }
}

void make_margins	(	PDBLK *	block,
		BLOCK_LINE_IT *	line_it,
		UINT8 *	pixels,
		UINT8	margin,
		INT16	left,
		INT16	right,
		INT16	y
	)

Get a line.

Get an image line and set to margin non-text pixels.

Definition at line 118 of file scanedg.cpp.

References BLOCK_LINE_IT::get_line(), PB_LINE_IT::get_line(), and NULL.

Referenced by block_edges().

                   {
  PB_LINE_IT *lines;
  ICOORDELT_LIST *segments;      //bits of a line
  ICOORDELT_IT seg_it;
  INT32 start;                   //of segment
  INT16 xext;                    //of segment
  int xindex;                    //index to pixel

  if (block->poly_block () != NULL) {
    lines = new PB_LINE_IT (block->poly_block ());
    segments = lines->get_line (y);
    if (!segments->empty ()) {
      seg_it.set_to_list (segments);
      seg_it.mark_cycle_pt ();
      start = seg_it.data ()->x ();
      xext = seg_it.data ()->y ();
      for (xindex = left; xindex < right; xindex++) {
        if (xindex >= start && !seg_it.cycled_list ()) {
          xindex = start + xext - 1;
          seg_it.forward ();
          start = seg_it.data ()->x ();
          xext = seg_it.data ()->y ();
        }
        else
          pixels[xindex - left] = margin;
      }
    }
    else {
      for (xindex = left; xindex < right; xindex++)
        pixels[xindex - left] = margin;
    }
    delete segments;
    delete lines;
  }
  else {
    start = line_it->get_line (y, xext);
    for (xindex = left; xindex < start; xindex++)
      pixels[xindex - left] = margin;
    for (xindex = start + xext; xindex < right; xindex++)
      pixels[xindex - left] = margin;
  }
}

CRACKEDGE* v_edge	(	INT16	x,
		INT16	y,
		INT8	sign,
		CRACKEDGE *	join
	)

Vertical edge.

Create a new vertical CRACKEDGE and join it to the given edge.

Definition at line 431 of file scanedg.cpp.

References cprintf(), free_cracks, join(), list_rec::next, CRACKEDGE::next, NULL, CRACKEDGE::pos, CRACKEDGE::prev, ICOORD::set_x(), ICOORD::set_y(), CRACKEDGE::stepdir, CRACKEDGE::stepx, CRACKEDGE::stepy, and ICOORD::y().

Referenced by line_edges().

  {
  CRACKEDGE *newpt;              //return value

  if (free_cracks != NULL) {
    newpt = free_cracks;
    free_cracks = newpt->next;   //get one fast
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSD)
  cprintf("j"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  else {
    newpt = new CRACKEDGE;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSD)
  cprintf("k"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  newpt->pos.set_x (x);          //coords of pt
  newpt->stepx = 0;              //edge is vertical

  if (sign > 0) {
    newpt->pos.set_y (y);        //start location
    newpt->stepy = 1;
    newpt->stepdir = 3;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSD)
  cprintf("l"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  else {
    newpt->pos.set_y (y + 1);    //start location
    newpt->stepy = -1;
    newpt->stepdir = 1;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSD)
  cprintf("m"); // check under 'e' in ccmain/tessvars.h
#endif
  }

  if (join == NULL) {
    newpt->next = newpt;         //ptrs to other ends
    newpt->prev = newpt;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSD)
  cprintf("n"); // check under 'e' in ccmain/tessvars.h
#endif
  }
  else {
    if (newpt->pos.x () == join->pos.x ()
    && newpt->pos.y () + newpt->stepy == join->pos.y ()) {
      newpt->prev = join->prev;  //update other ends
      newpt->prev->next = newpt;
      newpt->next = join;        //join up
      join->prev = newpt;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSD)
  cprintf("o"); // check under 'e' in ccmain/tessvars.h
#endif
    }
    else {
      newpt->next = join->next;  //update other ends
      newpt->next->prev = newpt;
      newpt->prev = join;        //join up
      join->next = newpt;
#if defined(TEXT_VERBOSE) && defined(TV_FOCUSD)
  cprintf("p"); // check under 'e' in ccmain/tessvars.h
#endif
    }
  }
  return newpt;
}

void whiteout_block	(	IMAGE *	t_image,
		PDBLK *	block
	)

Clean it.

Extract edges from a PDBLK.

Definition at line 175 of file scanedg.cpp.

References BOX::bottom(), IMAGE::get_line(), BLOCK_LINE_IT::get_line(), IMAGELINE::pixels, IMAGE::put_line(), and BOX::top().

                     {
  INT16 x;                       //line coords
  INT16 y;                       //current line
  INT16 xext;                    //line width
  int xindex;                    //index to pixel
  UINT8 *dest;                   //destination pixel
  BOX block_box;                 //bounding box
  BLOCK_LINE_IT line_it = block; //line iterator
  IMAGELINE bwline;              //thresholded line

  block_box = block->bounding_box ();
  for (y = block_box.bottom (); y < block_box.top (); y++) {
                                 //find line limits
    x = line_it.get_line (y, xext);
    t_image->get_line (x, y, xext, &bwline, 0);
    dest = bwline.pixels;        //destination pixel
    for (xindex = 0; xindex < xext; xindex++)
      *dest++ = 1;
    t_image->put_line (x, y, xext, &bwline, 0);
  }
}

---