BioImager.QueueLinearFloodFiller Class Reference

Implements the QueueLinear flood fill algorithm using array-based pixel manipulation. More...

Inheritance diagram for BioImager.QueueLinearFloodFiller:

Public Member Functions
	QueueLinearFloodFiller (AbstractFloodFiller configSource)
override void	FloodFill (AForge.Point pt)
	Fills the specified point on the bitmap with the currently selected fill color. More...
Public Member Functions inherited from BioImager.AbstractFloodFiller
	AbstractFloodFiller (AbstractFloodFiller configSource)
abstract void	FloodFill (Point pt)

Protected Member Functions
bool	CheckPixel (ref int px)
int	CoordsToByteIndex (ref int x, ref int y)
int	CoordsToPixelIndex (int x, int y)
	Returns the linear index for a pixel, given its x and y coordinates. More...
Protected Member Functions inherited from BioImager.AbstractFloodFiller
void	PrepareForFloodFill (Point pt)

Additional Inherited Members
Protected Attributes inherited from BioImager.AbstractFloodFiller
Bitmap	bitmap
ColorS	tolerance = new ColorS(25, 25, 25)
ColorS	fillColor = ColorS.FromColor(Color.Black)
bool	fillDiagonally = false
bool	slow = false
int	bitmapWidth = 0
int	bitmapHeight = 0
int	bitmapStride = 0
int	bitmapPixelFormatSize = 0
byte[]	bitmapBits = null
PixelFormat	pixelFormat
bool[]	pixelsChecked
ColorS	byteFillColor
ColorS	startColor
Properties inherited from BioImager.AbstractFloodFiller
ColorS	FillColor [get, set]
bool	FillDiagonally [get, set]
ColorS	Tolerance [get, set]
Bitmap	Bitmap [get, set]

Detailed Description

Implements the QueueLinear flood fill algorithm using array-based pixel manipulation.

Definition at line 8 of file QueueLinearFloodFiller.cs.

Constructor & Destructor Documentation

QueueLinearFloodFiller()

BioImager.QueueLinearFloodFiller.QueueLinearFloodFiller

(

AbstractFloodFiller

configSource

)

Definition at line 16 of file QueueLinearFloodFiller.cs.

: base(configSource) { }

Member Function Documentation

CheckPixel()

bool BioImager.QueueLinearFloodFiller.CheckPixel ( ref int  px )

protected

summary>Calculates and returns the byte index for the pixel (x,y). param name="x">The x coordinate of the pixel whose byte index should be returned.

param name="y">The y coordinate of the pixel whose byte index should be returned.

Definition at line 207 of file QueueLinearFloodFiller.cs.

Referenced by BioImager.QueueLinearFloodFiller.FloodFill().

CoordsToByteIndex()

int BioImager.QueueLinearFloodFiller.CoordsToByteIndex ( ref int  x, ref int  y  )

protected

Definition at line 257 of file QueueLinearFloodFiller.cs.

        {
            return (bitmapStride * y) + (x * bitmapPixelFormatSize);
        }

CoordsToPixelIndex()

int BioImager.QueueLinearFloodFiller.CoordsToPixelIndex ( int  x, int  y  )

protected

Returns the linear index for a pixel, given its x and y coordinates.

Parameters

x	The x coordinate of the pixel.
y	The y coordinate of the pixel.

Returns

Definition at line 268 of file QueueLinearFloodFiller.cs.

        {
            return (bitmapWidth * y) + x;
        }

FloodFill()

override void BioImager.QueueLinearFloodFiller.FloodFill

(

AForge.Point

pt

)

Fills the specified point on the bitmap with the currently selected fill color.

Parameters

pt	The starting point for the fill.

Definition at line 22 of file QueueLinearFloodFiller.cs.

        {
            watch.Reset();
            watch.Start();
 
            //***Prepare for fill.
            PrepareForFloodFill(pt);
 
            ranges = new FloodFillRangeQueue(((bitmapWidth + bitmapHeight) / 2) * 5);//new Queue<FloodFillRange>();
 
            //***Get starting color.
            int x = (int)pt.X; int y = (int)pt.Y;
            int idx = CoordsToByteIndex(ref x, ref y);
            startColor = bitmap.GetPixel((int)pt.X,(int)pt.Y);
 
            bool[] pixelsChecked = this.pixelsChecked;
 
            //***Do first call to floodfill.
            LinearFill(ref x, ref y);
 
            //***Call floodfill routine while floodfill ranges still exist on the queue
            while (ranges.Count > 0)
            {
                //**Get Next Range Off the Queue
                FloodFillRange range = ranges.Dequeue();
 
                //**Check Above and Below Each Pixel in the Floodfill Range
                int downPxIdx = (bitmapWidth * (range.Y + 1)) + range.StartX;//CoordsToPixelIndex(lFillLoc,y+1);
                int upPxIdx = (bitmapWidth * (range.Y - 1)) + range.StartX;//CoordsToPixelIndex(lFillLoc, y - 1);
                int upY = range.Y - 1;//so we can pass the y coord by ref
                int downY = range.Y + 1;
                int tempIdx;
                for (int i = range.StartX; i <= range.EndX; i++)
                {
                    //*Start Fill Upwards
                    //if we're not above the top of the bitmap and the pixel above this one is within the color tolerance
                    tempIdx = CoordsToByteIndex(ref i, ref upY);
                    if (range.Y > 0 && (!pixelsChecked[upPxIdx]) && CheckPixel(ref tempIdx))
                        LinearFill(ref i, ref upY);
 
                    //*Start Fill Downwards
                    //if we're not below the bottom of the bitmap and the pixel below this one is within the color tolerance
                    tempIdx = CoordsToByteIndex(ref i, ref downY);
                    if (range.Y < (bitmapHeight - 1) && (!pixelsChecked[downPxIdx]) && CheckPixel(ref tempIdx))
                        LinearFill(ref i, ref downY);
                    downPxIdx++;
                    upPxIdx++;
                }
 
            }
 
            watch.Stop();
        }

References BioImager.QueueLinearFloodFiller.CheckPixel(), BioImager.FloodFillRangeQueue.Count, and BioImager.FloodFillRangeQueue.Dequeue().

---

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

• F:/repos/BioImager/BioImager/Graphics/QueueLinearFloodFiller.cs