Pixels Class Reference

Utility class for pixel manipulation. More...

#include <Pixels.h>

Collaboration diagram for Pixels:

Public Member Functions
	Pixels ()
	Single constructor. More...
int	countBlackPixelsAroundPoint (const QImage &image, int x, int y, int stopCountAt)
	Fill triangle between these three points. More...
void	fillHole (QImage &image, int row, int col, int thresholdCount) const
	Fill white hole encompassing (row,col) if number of pixels in that hole is below the threshold. More...
void	fillHoles (QImage &image, int thresholdCount)
	Fill in white holes, surrounded by black pixels, smaller than some threshold number of pixels. More...
void	fillIsolatedWhitePixels (QImage &image)
	Fill in white pixels surrounded by more black pixels than white pixels. More...

Static Public Member Functions
static bool	pixelIsBlack (const QImage &image, int x, int y)
	Return true if pixel is black in black and white image. More...

Detailed Description

Utility class for pixel manipulation.

Definition at line 30 of file Pixels.h.

Constructor & Destructor Documentation

Pixels()

Pixels::Pixels

(

)

Single constructor.

Definition at line 12 of file Pixels.cpp.

{
}

Member Function Documentation

countBlackPixelsAroundPoint()

int Pixels::countBlackPixelsAroundPoint	(	const QImage &	image,
		int	x,
		int	y,
		int	stopCountAt
	)

Fill triangle between these three points.

Definition at line 16 of file Pixels.cpp.

{
  int count = 0;
  QueuedPoints queuedPoints;
  HashLookup hashLookup; // Prevents reprocessing of already-processed pixels
 
  // First point
  if (pixelIsBlack (image, x, y)) {
    queuedPoints.push_back (QPoint (x, y));
  }
 
  while (queuedPoints.count () > 0) {
    
    // Pop off queue
    QPoint p = queuedPoints.front ();
    queuedPoints.pop_front ();
 
    QString hash = hashForCoordinates (p.x(),
                                       p.y());
 
    // Skip if out of bounds, processed already or not black
    bool inBounds = (0 <= p.x() &&
                     0 <= p.y() &&
                     p.x() < image.width () &&
                     p.y() < image.height ());
    if (inBounds &&
        !hashLookup.contains (hash) &&
        pixelIsBlack (image, p.x(), p.y())) {
 
      // Black pixel. Add to count, and remember to not reprocess later
      ++count;
      if (count == stopCountAt) {
        return count; // Reached limit. Stop immediately (probably for speed)
      }
      hashLookup [hash] = true;
 
      // Queue neighbors for processing
      for (int dx = -1; dx <= 1; dx++) {
        for (int dy = -1; dy <= 1; dy++) {
          if (dx != 0 || dy != 0) {
            queuedPoints.push_back (QPoint (p.x() + dx,
                                            p.y() + dy));
          }
        }
      }
    }
  }
 
  return count; // Did not reach limit
}

fillHole()

void Pixels::fillHole	(	QImage &	image,
		int	row,
		int	col,
		int	thresholdCount
	)		const

Fill white hole encompassing (row,col) if number of pixels in that hole is below the threshold.

Definition at line 70 of file Pixels.cpp.

{
  // Square of 1 pixel is surrounded by 3x3 box with indexes -1 to +2
  //           2-4 pixels               4x4                  -2 to +2
  //           5-9                      5x5                  -2 to +3
  //           10-16                    6x6                  -3 to +3
  int rowStart = qFloor (row - (1 + qSqrt (thresholdCount - 1))); // Inclusive
  int colStart = qFloor (col - (1 + qSqrt (thresholdCount - 1))); // Inclusive
  int rowStop = qFloor (row + (1 + qSqrt (thresholdCount))); // Exclusive
  int colStop = qFloor (col + (1 + qSqrt (thresholdCount))); // Exclusive
 
  // First pass is for counting
  int countWhite = 0;
  for (int rowIter = rowStart; rowIter < rowStop; rowIter++) {
    for (int colIter = colStart; colIter < colStop; colIter++) {
      if (!pixelIsBlack (image,
                         colIter,
                         rowIter)) {
        ++countWhite;
      }
    }
  }
 
  // Second pass fills in the hole
  if (countWhite < thresholdCount) {
    for (int rowIter = rowStart; rowIter < rowStop; rowIter++) {
      for (int colIter = colStart; colIter < colStop; colIter++) {
        image.setPixel (colIter,
                        rowIter,
                        Qt::black);
      }
    }
  }
}

fillHoles()

void Pixels::fillHoles	(	QImage &	image,
		int	thresholdCount
	)

Fill in white holes, surrounded by black pixels, smaller than some threshold number of pixels.

Originally this was recursive but the high recursion levels (for big regions) overflowed the stack

Definition at line 108 of file Pixels.cpp.

{
  int height = image.height();
  int width = image.width();
 
  // 2d matrix, indexed as 1d vector, of pixel states
  QVector<PixelFillState> states (image.width() * image.height());
  states.fill (PIXEL_FILL_STATE_UNPROCESSED);
 
  // Search for unprocessed pixels
  for (int col = 0; col < width; col++) {
    for (int row = 0; row < height; row++) {
      if (states [indexCollapse (row, col, width)] == PIXEL_FILL_STATE_UNPROCESSED) {
 
        // Found an unprocessed pixel so process it
        if (pixelIsBlack (image, col, row)) {
 
          // Black pixel needs no processing
          states [indexCollapse (row, col, width)] = PIXEL_FILL_STATE_PROCESSED;
 
        } else {
 
          // Get this pixel and all of its white neighbors
          int pixelsInRegion = fillPass (image,
                                         states,
                                         row,
                                         col,
                                         PIXEL_FILL_STATE_UNPROCESSED,
                                         PIXEL_FILL_STATE_IN_PROCESS,
                                         NO_FILL);
 
          FillIt fillIt = (pixelsInRegion < thresholdCount) ? YES_FILL : NO_FILL;
 
          fillPass (image,
                    states,
                    row,
                    col,
                    PIXEL_FILL_STATE_IN_PROCESS,
                    PIXEL_FILL_STATE_PROCESSED,
                    fillIt);
        }
      }
    }
  }
}

fillIsolatedWhitePixels()

void Pixels::fillIsolatedWhitePixels

(

QImage &

image

)

Fill in white pixels surrounded by more black pixels than white pixels.

This is much faster than fillHoles and effectively as good

Definition at line 155 of file Pixels.cpp.

{
  const int BORDER = 1;
  const int HALF_NUMBER_NEIGHBORS = 4; // 8 neighbors in each direction from (col,row)
 
  int height = image.height();
  int width = image.width();
 
  // 2d matrix, indexed as 1d vector, of neighbor counts
  QVector<bool> pixelsAreBlack (image.width() * image.height());
 
  // Replace slow QImage addressing by faster QVector addressing
  for (int col = 0; col < width; col++) {
    for (int row = 0; row < height; row++) {
      pixelsAreBlack [indexCollapse (row, col, width)] = pixelIsBlack (image, col, row);
    }
  }
 
  // Search for white pixels. Black pixels will be ignored, and also pixels along the four
  // borders are ignored so we do not need to worry about going out of bounds
  for (int col = BORDER; col < width - BORDER; col++) {
    for (int row = BORDER; row < height - BORDER; row++) {
      int count = 0;
      count += pixelsAreBlack [indexCollapse (row - 1, col - 1, width)] ? 1 : 0;
      count += pixelsAreBlack [indexCollapse (row - 1, col    , width)] ? 1 : 0;
      count += pixelsAreBlack [indexCollapse (row - 1, col + 1, width)] ? 1 : 0;
      count += pixelsAreBlack [indexCollapse (row    , col - 1, width)] ? 1 : 0;
      count += pixelsAreBlack [indexCollapse (row    , col + 1, width)] ? 1 : 0;
      count += pixelsAreBlack [indexCollapse (row + 1, col - 1, width)] ? 1 : 0;
      count += pixelsAreBlack [indexCollapse (row + 1, col    , width)] ? 1 : 0;
      count += pixelsAreBlack [indexCollapse (row + 1, col + 1, width)] ? 1 : 0;
      if (count > HALF_NUMBER_NEIGHBORS) {
        image.setPixel (col,
                          row,
                          Qt::black);
      }
    }
  }
}

pixelIsBlack()

bool Pixels::pixelIsBlack ( const QImage &  image, int  x, int  y  )

static

Return true if pixel is black in black and white image.

Definition at line 286 of file Pixels.cpp.

{
  QRgb rgb = image.pixel (x, y);
  return qGray (rgb) < 128;
}

---

The documentation for this class was generated from the following files:

• util/Pixels.h
• util/Pixels.cpp