scanedg.cpp File Reference

#include "scanedg.h"
#include <memory>
#include "allheaders.h"
#include "edgloop.h"

Go to the source code of this file.

Macros
#define	WHITE_PIX   1 /*thresholded colours */
#define	BLACK_PIX   0
#define	FLIP_COLOUR(pix)   (1-(pix))

Functions
void	block_edges (Pix *t_pix, PDBLK *block, C_OUTLINE_IT *outline_it)
void	make_margins (PDBLK *block, BLOCK_LINE_IT *line_it, uint8_t *pixels, uint8_t margin, int16_t left, int16_t right, int16_t y)
void	line_edges (int16_t x, int16_t y, int16_t xext, uint8_t uppercolour, uint8_t *bwpos, CRACKEDGE **prevline, CRACKEDGE **free_cracks, C_OUTLINE_IT *outline_it)
CRACKEDGE *	h_edge (int sign, CRACKEDGE *join, CrackPos *pos)
CRACKEDGE *	v_edge (int sign, CRACKEDGE *join, CrackPos *pos)
void	join_edges (CRACKEDGE *edge1, CRACKEDGE *edge2, CRACKEDGE **free_cracks, C_OUTLINE_IT *outline_it)
void	free_crackedges (CRACKEDGE *start)

Macro Definition Documentation

BLACK_PIX

#define BLACK_PIX   0

Definition at line 26 of file scanedg.cpp.

FLIP_COLOUR

#define FLIP_COLOUR

(

pix

)

(1-(pix))

Definition at line 28 of file scanedg.cpp.

WHITE_PIX

#define WHITE_PIX   1 /*thresholded colours */

Definition at line 25 of file scanedg.cpp.

Function Documentation

block_edges()

void block_edges	(	Pix *	t_pix,
		PDBLK *	block,
		C_OUTLINE_IT *	outline_it
	)

Definition at line 35 of file scanedg.cpp.

                                           {
  ICOORD bleft;                  // bounding box
  ICOORD tright;
  BLOCK_LINE_IT line_it = block; // line iterator
 
  int width = pixGetWidth(t_pix);
  int height = pixGetHeight(t_pix);
  int wpl = pixGetWpl(t_pix);
                                 // lines in progress
  std::unique_ptr<CRACKEDGE*[]> ptrline(new CRACKEDGE*[width + 1]);
  CRACKEDGE *free_cracks = nullptr;
 
  block->bounding_box(bleft, tright);  // block box
  ASSERT_HOST(tright.x() <= width);
  ASSERT_HOST(tright.y() <= height);
  int block_width = tright.x() - bleft.x();
  for (int x = block_width; x >= 0; x--)
    ptrline[x] = nullptr;           //  no lines in progress
 
  std::unique_ptr<uint8_t[]> bwline(new uint8_t[width]);
 
  const uint8_t margin = WHITE_PIX;
 
  for (int y = tright.y() - 1; y >= bleft.y() - 1; y--) {
    if (y >= bleft.y() && y < tright.y()) {
      // Get the binary pixels from the image.
      l_uint32* line = pixGetData(t_pix) + wpl * (height - 1 - y);
      for (int x = 0; x < block_width; ++x) {
        bwline[x] = GET_DATA_BIT(line, x + bleft.x()) ^ 1;
      }
      make_margins(block, &line_it, bwline.get(), margin, bleft.x(), tright.x(), y);
    } else {
      memset(bwline.get(), margin, block_width * sizeof(bwline[0]));
    }
    line_edges(bleft.x(), y, block_width,
               margin, bwline.get(), ptrline.get(), &free_cracks, outline_it);
  }
 

free_crackedges()

void free_crackedges

(

CRACKEDGE *

start

)

Definition at line 353 of file scanedg.cpp.

                                       {

h_edge()

CRACKEDGE* h_edge	(	int	sign,
		CRACKEDGE *	join,
		CrackPos *	pos
	)

Definition at line 220 of file scanedg.cpp.

                                 {
  CRACKEDGE *newpt;              // return value
 
  if (*pos->free_cracks != nullptr) {
    newpt = *pos->free_cracks;
    *pos->free_cracks = newpt->next;  // get one fast
  } else {
    newpt = new CRACKEDGE;
  }
  newpt->pos.set_y(pos->y + 1);       // coords of pt
  newpt->stepy = 0;              // edge is horizontal
 
  if (sign > 0) {
    newpt->pos.set_x(pos->x + 1);     // start location
    newpt->stepx = -1;
    newpt->stepdir = 0;
  } else {
    newpt->pos.set_x(pos->x);        // start location
    newpt->stepx = 1;
    newpt->stepdir = 2;
  }
 
  if (join == nullptr) {
    newpt->next = newpt;         // ptrs to other ends
    newpt->prev = newpt;
  } 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;
    } else {
      newpt->next = join->next;  // update other ends
      newpt->next->prev = newpt;
      newpt->prev = join;        // join up

join_edges()

void join_edges	(	CRACKEDGE *	edge1,
		CRACKEDGE *	edge2,
		CRACKEDGE **	free_cracks,
		C_OUTLINE_IT *	outline_it
	)

Definition at line 321 of file scanedg.cpp.

                                          {
  if (edge1->pos.x() + edge1->stepx != edge2->pos.x()
  || edge1->pos.y() + edge1->stepy != edge2->pos.y()) {
    CRACKEDGE *tempedge = edge1;
    edge1 = edge2;  // swap around
    edge2 = tempedge;
  }
 
  if (edge1->next == edge2) {
                                 // already closed
    complete_edge(edge1, outline_it);
                                 // attach freelist to end
    edge1->prev->next = *free_cracks;
    *free_cracks = edge1;         // and free list
  } else {

line_edges()

void line_edges	(	int16_t	x,
		int16_t	y,
		int16_t	xext,
		uint8_t	uppercolour,
		uint8_t *	bwpos,
		CRACKEDGE **	prevline,
		CRACKEDGE **	free_cracks,
		C_OUTLINE_IT *	outline_it
	)

Definition at line 138 of file scanedg.cpp.

                                          {
  CrackPos pos = {free_cracks, x, y };
  int xmax;                      // max x coord
  int prevcolour;                // of previous pixel
  CRACKEDGE *current;            // current h edge
  CRACKEDGE *newcurrent;         // new h edge
 
  xmax = x + xext;               // max allowable coord
  prevcolour = uppercolour;      // forced plain margin
  current = nullptr;                // nothing yet
 
                                 // do each pixel
  for (; pos.x < xmax; pos.x++, prevline++) {
    const int colour = *bwpos++; // current pixel
    if (*prevline != nullptr) {
                                 // changed above
                                 // change colour
      uppercolour = FLIP_COLOUR(uppercolour);
      if (colour == prevcolour) {
        if (colour == uppercolour) {
                                 // finish a line
          join_edges(current, *prevline, free_cracks, outline_it);
          current = nullptr;        // no edge now
        } else {
                                 // new horiz edge
          current = h_edge(uppercolour - colour, *prevline, &pos);
        }
        *prevline = nullptr;        // no change this time
      } else {
        if (colour == uppercolour)
          *prevline = v_edge(colour - prevcolour, *prevline, &pos);
                                 // 8 vs 4 connection
        else if (colour == WHITE_PIX) {
          join_edges(current, *prevline, free_cracks, outline_it);
          current = h_edge(uppercolour - colour, nullptr, &pos);
          *prevline = v_edge(colour - prevcolour, current, &pos);
        } else {
          newcurrent = h_edge(uppercolour - colour, *prevline, &pos);
          *prevline = v_edge(colour - prevcolour, current, &pos);
          current = newcurrent;  // right going h edge
        }
        prevcolour = colour;     // remember new colour
      }
    } else {
      if (colour != prevcolour) {
        *prevline = current = v_edge(colour - prevcolour, current, &pos);
        prevcolour = colour;
      }
      if (colour != uppercolour)
        current = h_edge(uppercolour - colour, current, &pos);
      else
        current = nullptr;          // no edge now
    }
  }
  if (current != nullptr) {
                                 // out of block
    if (*prevline != nullptr) {     // got one to join to?
      join_edges(current, *prevline, free_cracks, outline_it);
      *prevline = nullptr;          // tidy now
    } else {
                                 // fake vertical
      *prevline = v_edge(FLIP_COLOUR(prevcolour)-prevcolour, current, &pos);
    }
  } else if (*prevline != nullptr) {

make_margins()

void make_margins	(	PDBLK *	block,
		BLOCK_LINE_IT *	line_it,
		uint8_t *	pixels,
		uint8_t	margin,
		int16_t	left,
		int16_t	right,
		int16_t	y
	)

Definition at line 84 of file scanedg.cpp.

                   {
  ICOORDELT_IT seg_it;
  int32_t start;                   //of segment
  int16_t xext;                    //of segment
  int xindex;                    //index to pixel
 
  if (block->poly_block () != nullptr) {
    std::unique_ptr<PB_LINE_IT> lines(new PB_LINE_IT (block->poly_block ()));
    const std::unique_ptr</*non-const*/ ICOORDELT_LIST> segments(
        lines->get_line(y));
    if (!segments->empty ()) {
      seg_it.set_to_list(segments.get());
      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;
    }
  }
  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++)

v_edge()

CRACKEDGE* v_edge	(	int	sign,
		CRACKEDGE *	join,
		CrackPos *	pos
	)

Definition at line 270 of file scanedg.cpp.

                                 {
  CRACKEDGE *newpt;              // return value
 
  if (*pos->free_cracks != nullptr) {
    newpt = *pos->free_cracks;
    *pos->free_cracks = newpt->next;  // get one fast
  } else {
    newpt = new CRACKEDGE;
  }
  newpt->pos.set_x(pos->x);           // coords of pt
  newpt->stepx = 0;              // edge is vertical
 
  if (sign > 0) {
    newpt->pos.set_y(pos->y);         // start location
    newpt->stepy = 1;
    newpt->stepdir = 3;
  } else {
    newpt->pos.set_y(pos->y + 1);     // start location
    newpt->stepy = -1;
    newpt->stepdir = 1;
  }
 
  if (join == nullptr) {
    newpt->next = newpt;         //ptrs to other ends
    newpt->prev = newpt;
  } 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;
    } else {
      newpt->next = join->next;  // update other ends
      newpt->next->prev = newpt;