Algorithm:Boundary

 Boundary Fill is algorithm used for the purpose of coloring figures in computer graphics.
 It is so similar to Flood Fill that many are confused as to whether it is another variation 
 of it.Here area gets colored with pixels of a chosen color as boundary this giving the
 technique its name.One can see the difference in the conditions that are there for planting
 the seeds.Boundary fill fills the chosen area with a color until the given colored boundary 
 is found. 
 This algorithm is also recursive in nature as the function returns when the pixel to be
 colored
 is the boundary color or is already the fill color.

 If the boundary is specified in a single color, the fill algorithm proceeds outward pixel-by-pixel
 until the boundary color is encountered. This is called boundary fill algorithm


 Procedure for filling a Boundary Fill Algorithm 4-connected region: 

 Color is specified by parameter fill color (f-color) and boundary coloris specified
 by boundary color (b-color).getpixel() function gives the color of specified pixel 
 and putpixel() fills the pixel with particular color.

 Steps:

 Enter the fill color code(f_color) and border color(b_color) code.
 Call the procedure boundary_fill.
 boundary_ fill (x,y, f_color, b_color)
 {
 If  ( getpixel (x,y) != b_color &&  getpixel (x,y) != f_color)
 putpixel(x,y,f_color);
 boundary_fill( x+1, y, f_color, b_color);
 boundary_fill( x, y+1, f_color, b_color);
 boundary_fill( x-1, y, f_color, b_color);
 boundary_fill( x, y-1, f_color, b_color);
 }
 }

 
 
 C Program For Boundary Fill Algorithm

Source Code:


 #include<stdio.h>
 #include<graphics.h>
 #include<conio.h>
 #include&l;math.h>

 


 void show_screen( );

 void Boundary_fill(const int,const int,const int,const int);

 void Circle(const int,const int,const int);
 void Triangle(const int,const int,const int,const int,const int,const int);
 void Rectangle(const int,const int,const int,const int);
 void Polygon(const int,const int []);
 void Line(const int,const int,const int,const int);

 ------------------------------  main( )  ------------------------------


 int main( )
    {
       int driver=VGA;
       int mode=VGAHI;

       initgraph(&driver,&mode,"c:/tc/bgi");

       show_screen( );

       setcolor(15);
	 Circle(175,175,40);

	 Boundary_fill(175,175,10,15);

       setcolor(15);
       settextstyle(0,0,1);
	 outtextxy(150,225,"Circle");

       setcolor(15);
	 Rectangle(375,145,475,205);

	 Boundary_fill(400,175,9,15);

       setcolor(15);
       settextstyle(0,0,1);
	 outtextxy(390,215,"Rectangle");

       setcolor(15);
	 Triangle(135,360,215,360,175,290);

	 Boundary_fill(175,325,8,15);

       setcolor(15);
       settextstyle(0,0,1);
	 outtextxy(145,370,"Triangle");

       int polygon_points[14]={ 365,325, 400,290, 450,290, 485,325,
			        450,360, 400,360, 365,325 };

       setcolor(15);
	 Polygon(7,polygon_points);

	 Boundary_fill(425,325,12,15);

       setcolor(15);
       settextstyle(0,0,1);
	 outtextxy(395,370,"Polygon");

       getch( );
       return 0;
    }


 ------------------------  Funcion Definitions  ------------------------

 --------------------------  Boundary_fill( )  -------------------------


 void Boundary_fill(const int x,const int y,
			     const int fill_color,const int boundary_color)
    {
       if(getpixel(x,y)!=boundary_color && getpixel(x,y)!=fill_color)
	  {
	     putpixel(x,y,fill_color);

	     Boundary_fill((x+1),y,fill_color,boundary_color);
	     Boundary_fill((x-1),y,fill_color,boundary_color);
	     Boundary_fill(x,(y+1),fill_color,boundary_color);
	     Boundary_fill(x,(y-1),fill_color,boundary_color);
	  }
    }

 ------------------------------  Circle( )  ----------------------------


 void Circle(const int h,const int k,const int r)
    {
       int color=getcolor( );

       int x=0;
       int y=r;
       int p=(1-r);

       do
	  {
	     putpixel((h+x),(k+y),color);
	     putpixel((h+y),(k+x),color);
	     putpixel((h+y),(k-x),color);
	     putpixel((h+x),(k-y),color);
	     putpixel((h-x),(k-y),color);
	     putpixel((h-y),(k-x),color);
	     putpixel((h-y),(k+x),color);
	     putpixel((h-x),(k+y),color);

	     x++;

	     if(p<0)
		p+=((2*x)+1);

	     else
		{
		   y--;
		   p+=((2*(x-y))+1);
		}
	  }
       while(x<=y);
    }


 ----------------------------  Triangle( )  ----------------------------


 void Triangle(const int x_1,const int y_1,const int x_2,const int y_2,
				const int x_3,const int y_3)
    {
       Line(x_1,y_1,x_2,y_2);
       Line(x_2,y_2,x_3,y_3);
       Line(x_3,y_3,x_1,y_1);
    }


 ---------------------------  Rectangle( )  ----------------------------


 void Rectangle(const int x_1,const int y_1,const int x_2,const int y_2)
    {
       Line(x_1,y_1,x_2,y_1);
       Line(x_2,y_1,x_2,y_2);
       Line(x_2,y_2,x_1,y_2);
       Line(x_1,y_2,x_1,y_1);
    }


-----------------------------  Polygon( )  ----------------------------


 void Polygon(const int n,const int coordinates[])
    {
       if(n>=2)
	  {
	     Line(coordinates[0],coordinates[1],
					     coordinates[2],coordinates[3]);

	     for(int count=1;count<(n-1);count++)
		Line(coordinates[(count*2)],coordinates[((count*2)+1)],
					    coordinates[((count+1)*2)],
					    coordinates[(((count+1)*2)+1)]);
	  }
    }


-------------------------------  Line( )  -----------------------------

 void Line(const int x_1,const int y_1,const int x_2,const int y_2)
    {
       int color=getcolor( );

       int x1=x_1;
       int y1=y_1;

       int x2=x_2;
       int y2=y_2;

       if(x_1>x_2)
	  {
	     x1=x_2;
	     y1=y_2;

	     x2=x_1;
	     y2=y_1;
	  }

       int dx=abs(x2-x1);
       int dy=abs(y2-y1);
       int inc_dec=((y2>=y1)?1:-1);

       if(dx>dy)
	  {
	     int two_dy=(2*dy);
	     int two_dy_dx=(2*(dy-dx));
	     int p=((2*dy)-dx);

	     int x=x1;
	     int y=y1;

	     putpixel(x,y,color);

	     while(x<x2)
		{
		   x++;

		   if(p<0)
		      p+=two_dy;

		   else
		      {
			 y+=inc_dec;
			 p+=two_dy_dx;
		      }

		   putpixel(x,y,color);
		}
	  }

       else
	  {
	     int two_dx=(2*dx);
	     int two_dx_dy=(2*(dx-dy));
	     int p=((2*dx)-dy);

	     int x=x1;
	     int y=y1;

	     putpixel(x,y,color);

	     while(y!=y2)
		{
		   y+=inc_dec;

		   if(p<0)
		      p+=two_dx;

		   else
		      {
			 x++;
			 p+=two_dx_dy;
		      }

		   putpixel(x,y,color);
		}
	  }
    }


 --------------------------  show_screen( )  ---------------------------


 void show_screen( )
    {
       setfillstyle(1,1);
	 bar(220,26,420,38);

       settextstyle(0,0,1);
	 setcolor(15);

	 setcolor(11);
	   outtextxy(228,29,"Boundary Fill Algorithm");

	 setcolor(15);

	   for(int count=0;count<=30;count++)

	 setcolor(12);
	   outtextxy(229,450,"Press any Key to exit.");
    }