Bio.Graphics.QueueLinearFloodFiller Class Reference

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

Inheritance diagram for Bio.Graphics.QueueLinearFloodFiller:

Public Member Functions
	QueueLinearFloodFiller (AbstractFloodFiller configSource)
override void	FloodFill (Point pt)
	Fills the specified point on the bitmap with the currently selected fill color.
Public Member Functions inherited from Bio.Graphics.AbstractFloodFiller
	AbstractFloodFiller (AbstractFloodFiller configSource)
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.
Protected Member Functions inherited from Bio.Graphics.AbstractFloodFiller
void	PrepareForFloodFill (Point pt)

Additional Inherited Members
Protected Attributes inherited from Bio.Graphics.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
Package Attributes inherited from Bio.Graphics.AbstractFloodFiller
Properties inherited from Bio.Graphics.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.

Constructor & Destructor Documentation

QueueLinearFloodFiller()

Bio.Graphics.QueueLinearFloodFiller.QueueLinearFloodFiller

(

AbstractFloodFiller

configSource

)

: base(configSource) { }

Member Function Documentation

CheckPixel()

bool Bio.Graphics.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.

CoordsToByteIndex()

int Bio.Graphics.QueueLinearFloodFiller.CoordsToByteIndex ( ref int x, ref int y )

protected

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

CoordsToPixelIndex()

int Bio.Graphics.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

        {
            return (bitmapWidth * y) + x;
        }

FloodFill()

override void Bio.Graphics.QueueLinearFloodFiller.FloodFill

(

Point

pt

)

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

Parameters

pt	The starting point for the fill.

        {
            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();
        }

---

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

• Graphics/QueueLinearFloodFiller.cs