// boundary_fill.cpp : 
// This application demonstrates the boundary fill algorithm
//

#include <iostream>

#define SZ 10	// size of our "virtual shape" in pixels
int shape[SZ][SZ]; // our shape is a SZxSZ square

// These variables are declared & defined global because they are used by the recursive boundary fill algorithm.
int stackheight = 0;	// recursion depth; 0 initially
int pixel = 0; // number of the pixel to be filled

void InitShape();	// initializes the shapes boundary and interior
void bf4( int x, int y, int clrFill, int clrBorder ); // boundary fill algorithm

int main(int argc, char* argv[])
{
	InitShape();
	// 4-connected boundary fill
	bf4(3,3,1,0xffffffff); // x-init, y-init, fillColor, borderColor

	return 0;
}

// void InitShape()
// Initializes the interior and border pixel colors of a simulated shape to be filled
//
// Notes: The interior color is set to 0 initially.
void InitShape()
{
// xxxxxxxxxx 9
// x        x 8
// x        x 7
// x        x 6
// x        x 5
// x        x 4
// x        x 3
// x        x 2
// x        x 1
// xxxxxxxxxx 0
// 0123456789

	for( int ix=0; ix<SZ; ix++ )
	{
		for( int iy=0; iy<SZ; iy++ )
		{
			shape[ix][iy] = 0; // the initial interior color
			
			if( ix==0 || iy==0 )  // sets the color of the border
				shape[ix][iy] = 0xFFFFFFFF;
			if( ix==SZ-1 || iy==SZ-1 )
				shape[ix][iy] = 0xFFFFFFFF;
		}
	}
}

// void bf4( int x, int y, int clrFill, int clrBorder )
// 4-connected boundary fill, starting at given coordinates x, y
// Parameters:
//	x,y - the starting coordinates (0-based) for the fill process; must be interior to the boundary
// clrFill - a non-zero int representing the fill color
// clrBorder - a non-zero int representing the border color; can be the same as the fill color
//
// Notes: This algorithm fills the interior of a closed region bounded by a
// closed border defined by pixels whose color is clrBorder. Starting at (x,y), 
// the algorithm recursively searches for all pixels within the closed region whose color value is not
// already the fill color or the border color, and when found, changes those
// pixel values to the fill color. The initial interior color is 0, as set by InitShape().
void bf4( int x, int y, int clrFill, int clrBorder )
{
	// is the pixel at x,y empty?
	if( (shape[x][y] != clrBorder) && (shape[x][y] != clrFill) )
	{
		// print a msg informing where we are in the sequence
    std::cout << x << "," << y << " : " << pixel++ << " stk: " << stackheight++ << std::endl;
		shape[x][y] = clrFill; // set color of pixel to fill color
		
		// Next, recursively search for other adjacent pixels to be filled.
		bf4( x, y+1, clrFill, clrBorder ); // N recursion
		bf4( x, y-1, clrFill, clrBorder ); // S
		bf4( x-1, y, clrFill, clrBorder ); // W 
		bf4( x+1, y, clrFill, clrBorder ); // E
		
		// We get here when the recursions invoked above cannot proceed any further
		stackheight--;
    std::cout << "stack unwind" << std::endl;
	}
}