Computer Graphics Lab

ELinks - Full-Featured Text WWW Browser

2009-08-05T13:40:00.000-07:00

ELinks is an advanced and well-established feature-rich text mode web (HTTP/FTP/..) browser. ELinks can render both frames and tables, is highly customizable and can be extended via Lua or Guile scripts. It is quite portable and runs on a variety of platforms.

ELinks is an Open Source project covered by the GNU General Public License.

If you want to see ELinks in action check out the screenshots.

ELinks is a program for browsing the web in text mode. The goal of the project has from the beginning been to provide a feature-rich text mode browser with an open patches/features inclusion policy and active development. One of these features is that ELinks includes Links-Lua which adds scripting capabilities to ELinks.

Why text mode ?

It may seem strange that anyone would develop a text mode browser in a world where the power of computers keep improving and most people favor graphical applications. Most graphical browsers are slow (especially to start up) and eat a lot of memory. For some people, this is unacceptable, so avoiding these browsers to harvest your critical system resources when doing basic tasks on the net is one thing. Text browsers are also invaluable on servers without a graphical environment and over SSH (or similiar) text-only sessions. Besides, text mode browsing is fun and highly addictive when you get the hang of it. ;-)

ELinks is written in near-ANSI C and is quite portable. It has been reported to run at least on the following platforms:

AIX
BeOS
CygWin
For more see the official site
....

Read full story here http://blog.dipinkrishna.info/2009/08/elinks-full-featured-text-www-browser.html

Pendulam

2008-10-21T07:09:00.000-07:00

#include<graphics.h>
#include<conio.h>
#include<dos.h>
#include<process.h>

int cx=300,cy=100,r=300;
int x=0,y,p;

int path(int dtn)
{
int x1,y1;
setcolor(15);
if(x>=y)
{
return 0;
}
cleardevice();

if(dtn==1)
{
circle(cx+x,cy+y,20);
line(cx,cy,cx+x,cy+y);
}
else
{
circle(cx-x,cy+y,20);
line(cx,cy,cx-x,cy+y);
}
delay(10);
if(kbhit())
exit(0);
x++;
if(p<0)
p+=2*x+1;
else
{
y--;
p+=2*(x-y)+1;
}
x1=x;
y1=y;
path(dtn);

cleardevice();
if(dtn==1)
{
circle(cx+x1,cy+y1,20);
line(cx,cy,cx+x1,cy+y1);
}
else
{
circle(cx-x1,cy+y1,20);
line(cx,cy,cx-x1,cy+y1);
}
delay(10);
if(kbhit())
exit(0);
}

void main()
{
int gd=DETECT,gm=DETECT;
initgraph(&gd,&gm,"");
cleardevice();
putpixel(300,100,4);
while(1)
{
x=0;
y=r;
p=1-r;
path(1);
x=0;
y=r;
p=1-r;
path(0);
}
getch();
}

To start with graphics programming

2008-10-11T05:06:00.000-07:00

Turbo C has a good collection of graphics libraries. If you know the basics of C, you can easily learn graphics programming. To start programming, let us write a small program that displays a circle on the screen.

/* simple.c
example 1.0
*/
#include<graphics.h>
#include<conio.h>

void main()
{
int gd=DETECT, gm;

initgraph(&gd, &gm, "c:\\tc\\bgi " );
circle(200,100,150);

getch();
closegraph();
}

To run this program, you need graphics.h header file, graphics.lib library file and Graphics driver (BGI file) in the program folder. These files are part of Turbo C package. In all our programs we used 640x480 VGA monitor. So all the programs are according to that specification. You need to make necessary changes to your programs according to your screen resolution. For VGA monitor, graphics driver used is EGAVGA.BGI.

Here, initgraph() function initializes the graphics mode and clears the screen. We will study the difference between text mode and graphics mode in detail latter.

InitGraph:

Initializes the graphics system.

Declaration:
void far initgraph(int far *graphdriver, int far *graphmode, char far *pathtodriver);

Remarks: To start the graphics system, you must first call initgraph.

initgraph initializes the graphics system by loading a graphics driver from disk (or validating a registered driver) then putting the system into graphics mode.

initgraph also resets all graphics settings (color, palette, current position, viewport, etc.) to their defaults, then resets graphresult to 0.
Arguments:

*graphdriver: Integer that specifies the graphics driver to be used. You can give graphdriver a value using a constant of the graphics drivers enumeration type.

*graphmode : Integer that specifies the initial graphics mode (unless *graphdriver = DETECT). If *graphdriver = DETECT, initgraph sets *graphmode to the highest resolution available for the detected driver. You can give *graphmode a value using a constant of the graphics_modes enumeration type.

pathtodriver : Specifies the directory path where initgraph looks for graphics drivers (*.BGI) first. If they're not there, initgraph looks in the current directory. If pathtodriver is null, the driver files must be in the current directory. This is also the path settextstyle searches for the stroked character font files (*.CHR).

closegraph() function switches back the screen from graphcs mode to text mode. It clears the screen also. A graphics program should have a closegraph function at the end of graphics. Otherwise DOS screen will not go to text mode after running the program. Here, closegraph() is called after getch() since screen should not clear until user hits a key.

If you have the BGI file in the same folder of your program, you can just leave it as "" only. you need not mention *graphmode if you give *graphdriver as DETECT.

In graphics mode, all the screen co-ordinates are mentioned in terms of pixels. Number of pixels in the screen decides resolution of the screen. In the example 1.0, circle is drawn with x-coordinate of the center 200, y-coordinate 100 and radius 150 pixels. All the coordinates are mentioned with respect to top-left corner of the screen.

Basic Shapes and Colors:

Now let us write a program to draw some basic shapes.

/*
shapes.c
example 1.1
*/

#include<graphics.h>
#include<conio.h>

void main()
{
int gd=DETECT, gm;
int poly[12]={350,450, 350,410, 430,400, 350,350, 300,430, 350,450 };
initgraph(&gd, &gm, "");

circle(100,100,50);
outtextxy(75,170, "Circle");
rectangle(200,50,350,150);
outtextxy(240, 170, "Rectangle");
ellipse(500, 100,0,360, 100,50);
outtextxy(480, 170, "Ellipse");
line(100,250,540,250);
outtextxy(300,260,"Line");

sector(150, 400, 30, 300, 100,50);
outtextxy(120, 460, "Sector");
drawpoly(6, poly);
outtextxy(340, 460, "Polygon");
getch();
closegraph();
}

Here is the screenshot of output:

Here, circle() function takes x, y coordinates of the circle with respect to left top of the screen and radius of the circle in terms of pixels as arguments. Not that, in graphics, almost all the screen parameters are measured in terms of pixels.

Function outtextxy() displays a string in graphical mode. You can use different fonts, text sizes, alignments, colors and directions of the text that we will study later. Parameters passed are x and y coordinates of the position on the screen where text is to be displayed. There is another function outtext() that displayes a text in the current position. Current position is the place where last drawing is ended. These functions are declared as follows:

void far outtextxy(int x, int y, char *text);
void far outtext(char *text);

Circle, arc, pieslice are declared as follows:

Declaration:

void far arc(int x, int y, int stangle, int endangle, int radius);
void far circle(int x, int y, int radius);
void far pieslice(int x, int y, int stangle, int endangle, int radius);

Remarks:

arc draws a circular arc in the current drawing color.
circle draws a circle in the current drawing color.
pieslice draws a pie slice in the current drawing color, then fills it using
the current fill pattern and fill color.

Arguments:

(x,y): Center point of arc, circlew, or pie slice
stangle: Start angle in degrees
endangle: End angle in degrees
radius: Radius of arc, circle, and pieslice

Here, stangle and endangle are in degrees starting from the +ve x-axis in the polar coordinate system in the anti-clockwise direction. if stangle is 0, endangle is 360, it will draw a full circle. Refer this figure for clear idea: For the details of current color, fill color and fill patterns, refer the sections Lines and Colors.

Another basic shape that we come across is a rectangle. To draw a border, use rectangle with the coordinates of outline, to draw a square use rectangle with same height and width. drawpoly() and fillpoly() are two functions useful to draw any polygons. To use these functions, store coordinates of the shape in an array and pass the address of array as an argument to the function. By looking at the output of the previous program, you can understand what drawpoly is. fillpoly is similar except that it fills in the shape with current fill color.

Declaration:

void far rectangle(int left, int top, int right, int bottom);
void far drawpoly(int numpoints, int far *polypoints);
void far fillpoly(int numpoints, int far *polypoints);

Remarks:

rectangle draws a rectangle in the current line style, thickness, and drawing color.
drawpoly draws a polygon using the current line style and color.
fillpoly draws the outline of a polygon using the current line style and color, then fills the polygon using the current fill pattern and fill color.

Arguments:

(left,top) is the upper left corner of the rectangle, and (right,bottom) is its lower right corner.
numpoints: Specifies number of points
*polypoints: Points to a sequence of (numpoints x 2) integers. Each pair of integers gives the x and y coordinates of a point on the polygon.

To draw a closed polygon with N points, numpoints should be N+1 and the array polypoints[] should contain 2(N+1) integers with first 2 integers equal to last 2 integers.

Let us study more about shapes latter. Here is some idea about colors. There are 16 colors declared in graphics.h as listed bellow.

BLACK: 0
BLUE: 1
GREEN: 2
CYAN: 3
RED: 4
MAGENTA: 5
BROWN: 6
LIGHTGRAY: 7
DARKGRAY: 8
LIGHTBLUE: 9
LIGHTGREEN: 10
LIGHTCYAN: 11
LIGHTRED: 12
LIGHTMAGENTA: 13
YELLOW: 14
WHITE: 15

To use these colors, use functions setcolor(), setbkcolor() and setfillstyle(). setcolor() function sets the current drawing color. If we use setcolor(RED); and draw any shape, line or text after that, the drawing will be in red color. You can either use color as defined above or number like setcolor(4);. setbkcolor() sets background color for drawing. Setfillstyle sets fill pattern and fill colors. After calling setfillstyle, if we use functions like floodfill, fillpoly, bar etc, shpes will be filled with fill color and pattern set using setfillstyle. These function declarations are as follows.

Declaration:

void far setfillstyle(int pattern, int color);
void far setcolor(int color);
void far setbkcolor(int color);

Remarks:

setfillstyle sets the current fill pattern and fill color.
setcolor sets the current drawing color to color, which can range from 0 to getmaxcolor.
setbkcolor sets the background to the color specified by color.

The parameter pattern in setfillstyle is as follows:

Names	Value	Means Fill With...
EMPTY_FILL	0	Background color
SOLID_FILL	1	Solid fill
LINE_FILL	2	---
LTSLASH_FILL	3	///
SLASH_FILL	4	///, thick lines
BKSLASH_FILL	5	\\\, thick lines
LTBKSLASH_FILL	6	\\\
HATCH_FILL	7	Light hatch
XHATCH_FILL	8	Heavy crosshatch
INTERLEAVE_FILL	9	Interleaving lines
WIDE_DOT_FILL	10	Widely spaced dots
CLOSE_DOT_FILL	11	Closely spaced dots
USER_FILL	12	User-defined fill pattern

Here is an example program with colors, pixels, bar, cleardevice etc. stdlib.h is used for random number generation. We have a function random(no), it returns a random number between 0 an no. The effect is by drawing random radius, random color circles with same center and random pixels. kbhit() function(defined in conio.h) returns a nonzero value when a key is pressed in the keyboard. So, the loop will continue until a key is pressed.

/*
random.c
some graphics effects using random numbers.
example 1.2
by HarshaPerla, http://eharsha.tk
*/

#include "graphics.h"
#include "conio.h"
#include "stdlib.h"

void main()
{
int gd,gm;
gd=DETECT;

initgraph(&gd, &gm, "");
setcolor(3);
setfillstyle(SOLID_FILL,RED);
bar(50, 50, 590, 430);

setfillstyle(1, 14);
bar(100, 100, 540, 380);

while(!kbhit())
{
putpixel(random(439)+101, random(279)+101,random(16));
setcolor(random(16));
circle(320,240,random(100));
}
getch();
closegraph();
}

Moving Wheel

2008-10-18T20:33:00.000-07:00

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
#include<dos.h>

int l=1;

void ddaline(int x1,int y1,int x2,int y2)
{

int s,dx,dy,m;
float xi,yi,x,y;

dx=x2-x1;
dy=y2-y1;

if(abs(dx)>abs(dy))
s=abs(dx);
else
s=abs(dy);

xi=dx/(float)s;
yi=dy/(float)s;

x=x1;
y=y1;

putpixel(x1+0.5,y1+0.5,15);

for(m=0;m<s;m++)
{
x+=xi;
y+=yi;
putpixel(x+0.5,y+0.5,15);
}
}

void plotpoints1(int x,int y,int cx,int cy)
{
putpixel(cx+x,cy+y,15);
putpixel(cx-x,cy-y,15);
putpixel(cx-y,cy+x,15);
putpixel(cx+y,cy-x,15);
if(l%20==0)
{
ddaline(cx-x,cy-y,cx+x,cy+y);
ddaline(cx-y,cy+x,cx+y,cy-x);
}
l++;
}

void plotpoints2(int x,int y,int cx,int cy)
{

putpixel(cx-x,cy+y,15);
putpixel(cx+x,cy-y,15);
putpixel(cx+y,cy+x,15);
putpixel(cx-y,cy-x,15);
if(l%20==0)
{
ddaline(cx+x,cy-y,cx-x,cy+y);
ddaline(cx-y,cy-x,cx+y,cy+x);
}
l++;
}

void mcircle(int cx,int cy,int r)
{
int x=0,y,p;

y=r;
p=1-r;

while(x<y)
{
plotpoints1(x,y,cx,cy);
x++;
if(p<0)
p+=2*x+1;
else
{
y--;
p+=2*(x-y)+1;
}
}

x=y+1;
while(abs(x)>0)
{
plotpoints2(x,y,cx,cy);
x--;
if(p>=0)
p =p-2*x-1;
else
{
y++;
p=p-2*(x-y)-1;
}
}
}

void main()
{
int gd=DETECT,gm=DETECT;
initgraph(&gd,&gm,"");

int i=0;

while(i<300)
{
cleardevice();
mcircle(100+(i++),200,100);
delay(90);
i++;
}
getch();
}

Fill a bucket with water from a pipe.

2008-10-18T10:20:00.000-07:00

#include<conio.h>
#include<dos.h>
#include<graphics.h>

void main()
{
int gd=DETECT,gm=DETECT,i,j;
initgraph(&gd,&gm,"");
ellipse(300,200,0,360,50,25);
ellipse(300,300,0,360,50,25);
line(250,200,250,300);
line(350,200,350,300);
ellipse(300,100,180,360,5,2);
line(295,100,295,80);
line(305,100,305,86);
arc(300,80,90,180,5);
putpixel(306,85,15);
putpixel(307,84,15);
line(308,84,630,84);
line(300,75,303,75);
line(314,75,630,75);
putpixel(304,74,15);
putpixel(305,73,15);
line(306,72,306,65);
line(311,72,311,65);
putpixel(312,73,15);
putpixel(313,74,15);
pieslice(309,62,0,360,5);
setfillstyle(SOLID_FILL,BLUE);
setcolor(BLUE);
for(i=0;i<7;i++)
{
line(297+i,103,297+i,300);
}
for(i=1;i<100;i++)
{
setcolor(LIGHTBLUE);
ellipse(300,300-i,180,360,4,2);
delay(30);
fillellipse(300,300-i,49,25);
setcolor(1);
line(297,275-i,303,275-i);
setcolor(15);
ellipse(300,200,180,360,50,25);
delay(50);
}
ellipse(300,200,0,360,50,25);
setcolor(0);
for(i=0;i<7;i++)
line(297+i,103,297+i,174);
getch();
}

DDA Line Drawing Algorithm

2008-10-06T23:58:00.000-07:00

#include < graphics.h >
#include < stdio.h >
#include < conio.h >
#include < math.h >

void main()
{

int gd=DETECT,gm=DETECT,s,dx,dy,m,x1,y1,x2,y2;
float xi,yi,x,y;

clrscr();

printf("Enter the sarting point x1 & y1n");
scanf("%d%d",&x1,&y1);

printf("Enter the end point x2 & y2n");
scanf("%d%d",&x2,&y2);

initgraph(&gd,&gm,"");
cleardevice();

dx=x2-x1;
dy=y2-y1;

if(abs(dx)>abs(dy))
s=abs(dx);
else
s=abs(dy);

xi=dx/(float)s;
yi=dy/(float)s;

x=x1;
y=y1;

putpixel(x1+0.5,y1+0.5,4);

for(m=0; m << s; m++)
{
x+=xi;
y+=yi;
putpixel(x+0.5,y+0.5,4);
}
getch();
}

RankStat.com

A man walking in the rain.

2008-10-07T01:32:00.000-07:00

#include<stdio.h>
#include<dos.h>
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>

void rain(int x1,int y1,int x2,int y2)
{
int s,dx,dy,m,c=0,t=1;
float xi,yi,x,y;

dx=x2-x1;
dy=y2-y1;

if(abs(dx)>abs(dy))
s=abs(dx);
else
s=abs(dy);

xi=dx/(float)s;
yi=dy/(float)s;

x=x1;
y=y1;

putpixel(x1+0.5,y1+0.5,9);

for(m=0;m<s;m++)
{
c++;
x+=xi;
y+=yi;
if(getpixel(x,y)==4)
break;
if(c%10==0)
t++;
putpixel(x+0.5,y+0.5,0);
if(t%2==0)
putpixel(x+0.5,y+0.5,9);

}

}

void main()
{
int gd=DETECT,gm=DETECT,c=-200,i=0,x=40,l=15,h=15,ht=0;
initgraph(&gd,&gm,"");
cleardevice();
setcolor(BROWN);
line(0,201,600,201);

cont:

while(!kbhit())
{
setcolor(4);
ellipse(x,100,0,180,50,30);
line(x-50,100,x+50,100);
line(x,100,x,150);
circle(x-20,115,15);
line(x-20,130,x-20,175);
line(x-20,175,x-20-l,200);
line(x-20,175,x-20+l,200);
line(x-20,140,x,150);
line(x-20,140,x-20-h,160);

for(i=0;i<620;i+=20)
{
rain(i,c,i,200);
}
c++;
if(c==0)
c=-100;
setcolor(0);
delay(50);
ellipse(x,100,0,180,50,30);
line(x-50,100,x+50,100);
line(x,100,x,150);
circle(x-20,115,15);
line(x-20,130,x-20,175);
line(x-20,175,x-20-l,200);
line(x-20,175,x-20+l,200);
line(x-20,140,x,150);
line(x-20,140,x-20-h,160);

line(x+50,100,x+50,200);
x++;
l--;
if(l==-15)
l=15;
if(ht==1)
h++;
else h--;

if(h==15)
ht=0;
else if(h==-15)
ht=1;

}
if(getch()==' ')
{
while(!kbhit());
getch();
goto cont;
}

}

Car Movement

2008-10-07T00:45:00.001-07:00

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>

int scan,ascii;

void getkey()
{
union REGS ii,oo;
ii.h.ah=0;
int86(22,&ii,&oo);
scan=oo.h.ah;
ascii=oo.h.al;
}

void car(int x,int c)
{
setcolor(c);
line(x+150,100,x+242,100);
ellipse(x+242,105,0,90,10,5);
line(x+150,100,x+120,150);
line(x+252,105,x+280,150);
line(x+100,150,x+320,150);
line(x+100,150,x+100,200);
line(x+320,150,x+320,200);
line(x+100,200,x+110,200);
line(x+320,200,x+310,200);
arc(x+130,200,0,180,20);
arc(x+290,200,0,180,20);
line(x+270,200,x+150,200);
circle(x+130,200,17);
circle(x+290,200,17);

}

void main()
{
int gd=DETECT,gm=DETECT,i=0,c=1,prev=80;
initgraph(&gd,&gm,"");

cleardevice();

car(0,15);

while(!kbhit());

while(1)
{
getkey();
if(scan==72)
{ c++; scan=prev; }

if(scan==80)
{ if(c!=1)c--; scan=prev; }

if(ascii==13)
break;
if(scan == 77)
{
prev=77;
while(!kbhit())
{
car(i,0);
i+=c;
car(i,15);
delay(20);
}
}
if(scan == 75)
{
prev=75;
while(!kbhit())
{
car(i,0);
i-=c;
car(i,15);
delay(20);
}

}
if(ascii == 32 )
{
prev=80;
car(i,15);
while(!kbhit());
}
}

getch();
}

Car movement during Traffic Signal

2008-10-07T00:39:00.000-07:00

#include<conio.h>
#include<dos.h>
#include<graphics.h>

void car(int x,int c)
{
setcolor(c);
line(x+150,100,x+242,100);
ellipse(x+242,105,0,90,10,5);
line(x+150,100,x+120,150);
line(x+252,105,x+280,150);
line(x+100,150,x+320,150);
line(x+100,150,x+100,200);
line(x+320,150,x+320,200);
line(x+100,200,x+110,200);
line(x+320,200,x+310,200);
arc(x+130,200,0,180,20);
arc(x+290,200,0,180,20);
line(x+270,200,x+150,200);
circle(x+130,200,17);
circle(x+290,200,17);

}

void main()
{
int gd=DETECT,gm=DETECT,i=-200;
int ch='g';
initgraph(&gd,&gm,"");

line(0,70,300,70);
line(450,70,630,70);
line(300,70,300,0);
line(450,70,450,0);
line(0,230,300,230);
line(450,230,630,230);
line(300,230,300,500);
line(450,230,450,500);
circle(280,50,10);
setfillstyle(SOLID_FILL,GREEN);
floodfill(280,50,15);
car(i,15);
while(1)
{
while(!kbhit())
{
if(ch=='r')
{
setfillstyle(SOLID_FILL,RED);
floodfill(280,50,15);
do{
while(!kbhit())
{
if(i<-20 || i>-10)
{
car(i++,0);
car(i,15);
delay(50);
}
}
ch=getch();
if(ch=='y')
{
setfillstyle(SOLID_FILL,YELLOW);
floodfill(280,50,15);
}
if(ch=='g')
{
setfillstyle(SOLID_FILL,GREEN);
floodfill(280,50,15);
}
}while(ch!='g'&&ch!=13);
}
else
{
car(i++,0);
car(i,15);
delay(50);
}
}
ch=getch();
if(ch==13)
break;
}

getch();
}

Boundary Fill

2008-10-07T00:33:00.001-07:00

The boundary fill algorithm fills a region with the given fill color until the given boundary color is found. Here i have used the 8-point technique to color a region. The program is using a recurssive function. The function return when the pixel to be colored is the boundary color or is already the fill color.

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

void boundary_fill(int x,int y, int fcolor,int bcolor)
{

if((getpixel(x,y) != fcolor) && (getpixel(x,y) != bcolor))
{
putpixel(x,y,fcolor);
boundary_fill(x+1,y,fcolor,bcolor);
boundary_fill(x-1,y,fcolor,bcolor);
boundary_fill(x,y-1,fcolor,bcolor);
boundary_fill(x,y+1,fcolor,bcolor);
boundary_fill(x+1,y-1,fcolor,bcolor);
boundary_fill(x+1,y+1,fcolor,bcolor);
boundary_fill(x-1,y-1,fcolor,bcolor);
boundary_fill(x-1,y+1,fcolor,bcolor);
}
}

void main()
{
int x,y,fcolor,bcolor;

clrscr();
printf("Enter the seed pointn");
scanf("%d%d",&x,&y);
printf("Enter boundary color : ");
scanf("%d",&bcolor);
printf("Enter new color : ");
scanf("%d",&fcolor);

int gd=DETECT,gm=DETECT;
initgraph(&gd,&gm,"");
cleardevice();

/*
plase ceate your own shapes
to make a closed area.
*/

boundary_fill(x,y,fcolor,bcolor);

getch();
}

Bouncing Ball

2008-10-07T00:35:00.000-07:00

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>

void main()
{
int gd=DETECT,gm=DETECT;
int x,y=0,j,t=400,c=1;
initgraph(&gd,&gm,"");
setcolor(RED);
setfillstyle(SOLID_FILL,RED);
for(x=40;x<602;x++)
{
cleardevice();
circle(x,y,30);
floodfill(x,y,RED);
delay(40);

if(y>=400)
{
c=0;
t-=20;
}
if(y<=(400-t))
c=1;
y=y+(c?15:-15);

}

getch();
}

Flood Fill

2008-10-07T00:31:00.000-07:00

The flood fill algorithm replaces a current color with a new color.Here i have used the 8-point technique to color a region. The program is using a recurssive function. The function return when the pixel to be replaced is not the given old color.

#include<stdio.h>
#include<conio.h>
#include<graphics.h>

void flood_fill(int x,int y, int ncolor,int ocolor)
{
if(getpixel(x,y) == ocolor)
{
putpixel(x,y,ncolor);
flood_fill(x+1,y,ncolor,ocolor);
flood_fill(x+1,y-1,ncolor,ocolor);
flood_fill(x+1,y+1,ncolor,ocolor);
flood_fill(x,y-1,ncolor,ocolor);
flood_fill(x,y+1,ncolor,ocolor);
flood_fill(x-1,y,ncolor,ocolor);
flood_fill(x-1,y-1,ncolor,ocolor);
flood_fill(x-1,y+1,ncolor,ocolor);
}
}

void main()
{
int x,y,ncolor,ocolor;

clrscr();
printf("Enter the seed pointn");
scanf("%d%d",&x,&y);
printf("Enter old color : ");
scanf("%d",&ocolor);
printf("Enter new color : ");
scanf("%d",&ncolor);

int gd=DETECT,gm=DETECT;
initgraph(&gd,&gm,"");
cleardevice();

/*

Draw some figures
to create closed shapes
you can use any biut-in functions.
Please everyone make their own figures.

*/

flood_fill(x,y,ncolor,ocolor);

getch();
}

Ellipse

2008-10-07T00:29:00.000-07:00

#include<graphics.h>
#include<conio.h>
#include<stdio.h>

void plotpoints(int cx,int cy, int x,int y)
{
putpixel(cx + x, cy + y,4);
putpixel(cx - x, cy + y,4);
putpixel(cx + x, cy - y,4);
putpixel(cx - x, cy - y,4);
}

void main()
{
int cx,cy,rx,ry;

printf("Enter the center ");
scanf("%d%d",&cx,&cy);
printf("x radius : ");
scanf("%d",&rx);
printf("y radius : ");
scanf("%d",&ry);

long rx2 = (long)rx*rx;
long ry2 = (long)ry*ry;
long trx2 = 2*rx2;
long try2 = 2*ry2;
long p,x=0, y=ry;
long px=0;
long py = trx2 * y;

p = (long) ( ( ry2 - (rx2 * ry) + (0.25 * rx2) ) + 0.5 );

int gd=DETECT,gm=DETECT;
initgraph(&gd,&gm,"");
cleardevice();

putpixel(cx,cy,15);

while(px<py)
{
plotpoints(cx,cy,x,y);
x++;
px += try2;
if(p < 0)
p += ry2 + px;
else
{
y--;
py -= trx2;
p += ry2 + px -py;
}
}
py=trx2*y;
px=try2*x;
p = (long) ( (ry2*(x+0.5)*(x+0.5) + rx2*(y-1)*(y-1) - rx2*ry2) + 0.5 );
while(y>=0)
{
plotpoints(cx,cy,x,y);
y--;
py -= trx2;
if(p > 0)
p += rx2 - py;
else
{
x++;
px += try2;
p += rx2 - py + px;
}
}

getch();
}

Wheel

2008-10-07T00:28:00.000-07:00

#include<conio.h>
#include<graphics.h>
#include<math.h>

int L=0;

void ddaline(int x1,int y1,int x2,int y2)
{

int s,dx,dy,m,c=0;
float xi,yi,x,y;

dx=x2-x1;
dy=y2-y1;

if(abs(dx)>abs(dy))
s=abs(dx);
else
s=abs(dy);

xi=dx/(float)s;
yi=dy/(float)s;

x=x1;
y=y1;

putpixel(x1+0.5,y1+0.5,15);
for(m=0;m<s;m++)
{
x+=xi;
y+=yi;
if(getpixel(x+0.5,y+0.5)==4)
{
c++;
continue;
}
if(c%2==0)
{
putpixel(x+0.5,y+0.5,15);
}
}
}

void plotpoints(int x,int y,int cx,int cy,int s)
{
if(s==0)
{
if(L%20==0)
{
ddaline(cx-x,cy-y,cx+x,cy+y);
ddaline(cx-y,cy+x,cx+y,cy-x);
ddaline(cx-y,cy-x,cx+y,cy+x);
ddaline(cx-x,cy+y,cx+x,cy-y);
}
L++;
}
putpixel(cx+x,cy+y,4);
putpixel(cx-x,cy+y,4);
putpixel(cx+x,cy-y,4);
putpixel(cx-x,cy-y,4);
putpixel(cx+y,cy+x,4);
putpixel(cx-y,cy+x,4);
putpixel(cx+y,cy-x,4);
putpixel(cx-y,cy-x,4);
}

void mcircle(int cx,int cy,int r,int s)
{
int x=0,y,p;

y=r;
p=1-r;

while(x<=y)
{
plotpoints(x,y,cx,cy,s);
x++;
if(p<0)
p+=2*x+1;
else
{
y--;
p+=2*(x-y)+1;
}
}

}

void main()
{
int gd=DETECT,gm=DETECT;
initgraph(&gd,&gm,"");

mcircle(300,250,20,1);
mcircle(300,250,100,0);

getch();
}

Circle using Mid-Point Algorithm

2008-10-07T00:22:00.000-07:00

#include<graphics.h>
#include<conio.h>
#include<stdio.h>

void plotpoints(int x,int y,int cx,int cy)
{
putpixel(cx+x,cy+y,4);
putpixel(cx-x,cy+y,4);
putpixel(cx+x,cy-y,4);
putpixel(cx-x,cy-y,4);
putpixel(cx+y,cy+x,4);
putpixel(cx-y,cy+x,4);
putpixel(cx+y,cy-x,4);
putpixel(cx-y,cy-x,4);
}

void main()
{
int cx,cy,x=0,y,r,p;
int gd=DETECT,gm=DETECT;

clrscr();

printf("Enter the center n");
scanf("%d%d",&cx,&cy);
printf("Enter the radius : ");
scanf("%d",&r);

y=r;
p=1-r;

initgraph(&gd,&gm,"");
cleardevice();

while(x<y)
{
plotpoints(x,y,cx,cy);
x++;
if(p<0)
p+=2*x+1;
else
{
y--;
p+=2*(x-y)+1;
}
}

getch();

}

Chess Board using DDA line drawing algorithm

2008-10-07T00:20:00.000-07:00

#include<conio.h>
#include<graphics.h>
#include<math.h>

void ddaline(int x1,int y1,int x2,int y2)
{
int s,m,dx,dy;
float xi,yi,x,y;

dx=x2-x1;
dy=y2-y1;

if(abs(dx)>abs(dy))
s=abs(dx);
else
s=abs(dy);

xi=dx/(float)s;
yi=dy/(float)s;

x=x1;
y=y1;

putpixel(x1+0.5,y1+0.5,15);

for(m=0;m<s;m++)
{
x+=xi;
y+=yi;
putpixel(x+0.5,y+0.5,15);
}
}

void fill(int x,int y)
{
int i,j;
for(i=x;i<(x+50);i++)
ddaline(i,y,i,y+50);
}

void main()
{
int i,j,c=0;
int gd=DETECT,gm=DETECT;

initgraph(&gd,&gm,"");
cleardevice();

ddaline(100,50,100,450);
ddaline(100,50,500,50);
ddaline(500,50,500,450);
ddaline(100,450,500,450);

for(i=100;i<500;i+=50)
{
for(j=50;j<450;j+=50)
{
if(c%2==0)
fill(i,j);
c++;
}
c++;
}
getch();
}

Bressenham's Line Drawing Algorithm

2008-10-07T00:16:00.000-07:00

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>

void swap(int &x,int &y)
{
int k=x;
x=y;
y=k;
}

void main()
{
int gd=DETECT,gm=DETECT,x1,x2,y1,y2,dx,dy,p,k;
float m=0;

clrscr();

printf("Enter the sarting point x1 & y1n");
scanf("%d%d",&x1,&y1);

printf("Enter the end point x2 & y2n");
scanf("%d%d",&x2,&y2);

dx=abs(x2-x1);
dy=abs(y2-y1);
m=(float)(y2-y1)/(x2-x1);

initgraph(&gd,&gm,"");
cleardevice();

if(fabs(m)>1)
{
swap(x1,y1);
swap(x2,y2);
swap(dx,dy);
}

if((x1>x2))
{
x1=x2;
y1=y2;
}
p=2*dy-dx;
for(k=0;k<abs(dx);k++)
{
if(p<0)
{
p=p+2*dy;
}
else
{
if(m<0) y1--;
else y1++;
p=p+(2*dy)-(2*dx);
}
if(fabs(m)<=1)putpixel(x1++,y1,15);
else putpixel(y1,x1++,15);
}

getch();
}