ANAND INSTITUTE OF HIGHER TECHNOLOGY

OLD MAHABALIPURAM ROAD, KALASALINGAM NAGAR

KAZHIPATTUR, CHENNAI-603 103.

DEPARTMENT OF COMPUTER SCIENCE AND

ENGINEERING

CS2405-COMPUTER GRAPHICS LABORATORY

LAB MANUAL

Prepared by,
Ms.R.Femila Goldy,AP/CSE

ANAND INSTITUTE OF HIGHER TECHNOLOGY

OLD MAHABALIPURAM ROAD, KALASALINGAM NAGAR
KAZHIPATTUR, NEAR CHENNAI-603 103.

CS2405-COMPUTER GRAPHICS LABORATORY

List of Experiments

1. Write a program to draw the line using DDA algorithm.

2. Write a program to draw the line using Bresenhams algorithm.
3. Develop a program to draw the circle using midpoint circle algorithm.
4. Develop a program to draw the ellipse using midpoint ellipse algorithm.
5. Program to implement the various attributes of output primitives.
6. Program to implement the 2D transformation.
7. Program to implement the 2D Composite transformation.
8. Develop a program to clip a line using Cohen Sutherland line clipping algorithm.
9. Develop a program to clip a polygon using Sutherland Hodgeman Polygon clipping
algorithm.
10. Write a simple opengl program to create a 3D object.
11. Write a simple opengl program to create a 3D scene.
12. Program to implement the 3D transformation.
13. Write a Program to implement 3D Composite Transformation.
14. Develop a fractal image using blender.

Ex. No. 1

DDA LINE DRAWING ALGORITHM

AIM:
To write a C program for drawing a line and to display the pixel positions using digital
differential Analyser (DDA) algorithm.
DESCRIPTION:
The digital differential analyzer (DDA) is a scan-conversion line algorithm based
on calculation either y or x.The line at unit intervals in one coordinate and determine
corresponding integer values nearest the line path for the other coordinate.

Straight line Segment with five sampling positions along the x axis between x1 and x2.
A line with positive slope (Left-right), if the slope is less than or equal to 1, at unit x
intervals (x=1) and compute each successive y values as
xk+1 = xk + 1
yk+1 = yk + m
For lines with a positive slope (Left-right), greater than 1 (y=1) and calculate each
succeeding x value as
yk+1 = yk + 1
xk+1 = xk + (1/m)
A line with positive slope (Right-Left), if the slope is less than or equal to 1, at unit x
intervals (x=-1) and compute each successive y values as
xk+1 = xk - 1
yk+1 = yk - m
For lines with a positive slope (Right-left), greater than 1 (y=-1) and calculate each
succeeding x value as
yk+1 = yk - 1
xk+1 = xk - (1/m)

ADVANTAGES:

It is a faster method than the direct use of the line equation.

It eliminates the floating point multiplication by making use of raster characteristics, so

increments are applied in x or y direction to step to pixel position along the line path.

DISADVANTAGES:

It drifts away from the actual line path because of rounding off float values to integer.

It is time consuming since floating point arithmetic and rounding operations are done to
calculate pixel position.

ALGORITHM:
Step 1: Accept Input as two endpoint pixel positions
Step 2: Horizontal and vertical differences between the endpoint positions are assigned to
parameters dx and dy (Calculate dx=xb-xa and dy=yb-ya).
Step 3: The difference with the greater magnitude determines the value of parameter steps.
Step 4: Starting with pixel position (xa, ya), determine the offset needed at each step to generate
the next pixel position along the line path.
Step 5: loop the following process for steps number of times
a. Use a unit of increment or decrement in the x and y direction
b. i f xa is less than xb the values of increment in the x and y directions are 1 and m c.If
xa is greater than xb then the decrements -1 and m are used.
CODING:
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<graphics.h>
int round(float m)
{
int n;
if((m-0.5)>floor(m))
n=ceil(m);
else
n=floor(m);
return n;
}
void main()

{
int x1,x2,y1,y2;
int gdriver=DETECT,gmode;
void lineDDA(int xa,int ya,int xb,int yb);
initgraph(&gdriver,&gmode,"E:\\TC\\BGI");
setbkcolor(GREEN);
printf("enter starting point coordinates\n");
scanf("%d%d",&x1,&y1);
printf("enter end point coordinates\n");
scanf("%d%d",&x2,&y2);
lineDDA(x1,y1,x2,y2);
getch();
closegraph();
}
void lineDDA(int xa,int ya,int xb,int yb)
{
int dx=xb-xa,dy=yb-ya,steps,k;
float xincr,yincr,X=xa,Y=ya;
if(abs(dx)>abs(dy))
steps=abs(dx);
else steps=abs(dy);
xincr=dx/(float)steps;
yincr=dy/(float)steps;
putpixel(round(X),round(Y),2);
printf("\nk\tX\t\tY\tround(X)\tround(Y)\tcoord(X,Y)");
for(k=0;k<steps;k++)
{
X=X+xincr;
Y=Y+yincr;
putpixel(round(X),round(Y),2);
printf("\n%d\t%f\t%f\t%d\t%d\t\t(%d,%d)",k,X,Y,round(X),round(Y),round(X),round(Y));
}
}

OUTPUT:

RESULT:
Thus the program for DDA line drawing algorithm is implemented and executed
successfully.

Ex. No. 2

BRESENHAM LINE DRAWING ALGORITHM

AIM:
To write a C program for drawing a line and to display the pixel positions using
Bresenham line drawing algorithm.
DESCRIPTION:
An accurate and efficient raster line generating algorithm developed by Bresenhams that uses
only incremental integer calculations.
Pixel positions along a line path are then determined by sampling at unit

intervals.

Starting from the left end point (x 0, y0) of a given line, we step to each successive column (x
position) and plot the pixel whose scan line y value is closest to the line path. Assuming we have
determined that the pixel at (xk, yk) is to be displayed, we next need to decide which pixel to plot
in column xk+1.Our choices are the pixels at positions (x k+l, yk) and (xk+l, yk+l).

ALGORITHM:
Step 1: Input the two line endpoints and store the left end point in (x 0, y0)
Step 2: Load (x0, y0) into frame buffer, ie. Plot the first point.

Step 3: Calculate the constants x, y, 2y and obtain the starting value for the
decision parameter as P 0 = 2y-x
Step 4: At each x k along the line, starting at k=0 perform the following test
If P k < 0, the next point to plot is(x k+1,yk) and
Pk+1 = Pk + 2y
otherwise, the next point to plot is (x k+1,yk+1) and
Pk+1 = Pk + 2y - 2x
Step 5: Perform step4 x times.
CODING:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void main()
{
int xa,ya,xb,yb;
int gdriver=DETECT,gmode;
void bres(int xa,int ya,int xb,int yb);
initgraph(&gdriver,&gmode,"D:\\TC\\BGI");
setbkcolor(LIGHTRED);
printf("enter the starting point coords");
scanf("%d%d",&xa,&ya);
printf("enter the endpoints coords");
scanf("%d%d",&xb,&yb);
bres(xa,ya,xb,yb);
getch();closegraph();
}
void bres(int xa,int ya,int xb,int yb)
{
int dx,dy,p,twody,twodydx,x,y,xend,k=0;
dx=abs(xa-xb);
dy=abs(ya-yb);
p=2*dy-dx;
twody=2*dy;
twodydx=2*(dy-dx);
if(xa>xb)
{
x=xb;y=yb;
xend=xa;
}
else
{

x=xa;y=ya;
xend=xb;
}
printf("k\tp\tcoors\n");
putpixel(x,y,2);
while(x<xend)
{ x++;
k++;
if(p<0)
p=p+twody;
else
{ y++;
p=p+twodydx;
} putpixel(x,y,2);
printf("\n%d\t%d\t(%d,%d)",k,p,x,y);
}}
OUTPUT:

RESULT:
Thus the program for Bresenham line drawing algorithm is implemented and executed
successfully.

Ex. No. 3

MIDPOINT CIRCLE ALGORITHM

AIM:
To write a C program for drawing a circle using midpoint circle algorithm.
DESCRIPTION:
A circle is defined as a set of points that are all the given distance (xc,yc).

In the raster line algorithm at unit intervals and determine the closest pixel position to
the specified circle path at each step for a given radius r and screen. center position (xc,yc) set
up our algorithm to calculate pixel positions around a circle path centered at the coordinate
position by adding x c to x and yc to y.
Circle function is fcircle(x,y) = x2+y2-r2
Any point (x,y) on the boundary of the circle with radius r satisfies the equation fcircle (x,y)=0.
If the point is in the interior of the circle, the circle function is negative. And if the point is
outside the circle the, circle function is positive
fcircle (x,y) =

<0, if (x,y) is inside the circle boundary

=0, if (x,y) is on the circle boundary
>0, if (x,y) is outside the circle boundary

ALGORITHM:
Step 1: Input radius r and circle center (x c,yc) and obtain the first point on the
circumference of the circle centered on the origin as

(x0,y0) = (0, r)
Step 2: Calculate the initial value of the decision parameter as P0= (5/4)-r=1-r
Step 3: At each x k position, starting at k=0, perform the following test. If P k <0 the next point
along the circle centered on (0,0) is (x k+1, yk) and Pk+1=Pk+2xk+1+1
Otherwise the next point along the circle is (x k+1, yk-1) and Pk+1=Pk+2xk+1+1-2 yk+1
Where 2xk+1=2xk+2 and 2yk+1=2yk-2
Step 4: Determine symmetry points in the other seven octants.
Step 5: Move each calculated pixel position (x,y) onto the circular path centered at (x c,yc) and
plot the coordinate values.
x=x+xc

y=y+yc

Step 6: Repeat step 3 through 5 until x>=y.

CODINGS:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main()
{
int radius,xcenter,ycenter,x,y,p,k=0;
int gdriver=DETECT,gmode;
clrscr();
initgraph(&gdriver,&gmode,"C:\\TC\\BGI");
setbkcolor(LIGHTRED);
printf("enter circle center");
scanf("%d%d",&xcenter,&ycenter);
printf("enter the radius");
scanf("%d",&radius);
x=0;
y=radius;
p=1-radius;putpixel(x,y,5); printf("k\tp\t
coords(x,y)\t\n");
printf("%d\t%d\t(%d,%d)\n",k,p,xcenter,ycenter);
while(x<y)
{ x++;
k++;
if(p<0)

{
p=p+2*x+1;
delay(200);
}
else
{
y--;
p=p+2*(x-y)+1;
delay(200);
}
putpixel(xcenter+x,ycenter+y,3);
putpixel(xcenter-x,ycenter+y,3);
putpixel(xcenter+x,ycenter-y,3);
putpixel(xcenter-x,ycenter-y,3);
putpixel(xcenter+y,ycenter+x,3);
putpixel(xcenter-y,ycenter+x,3);
putpixel(xcenter+y,ycenter-x,3);
putpixel(xcenter-y,ycenter-x,3);
printf("%d\t%d\t(%d,%d)\n",k,p,x+xcenter,y+ycenter);
}
getch();
}
OUTPUT:

RESULT:
Thus the program for midpoint circle algorithm is implemented and executed
successfully.

Ex. No.4

MIDPOINT ELLIPSE ALGORITHM

AIM:
To write a C program for drawing an ellipse using midpoint ellipse algorithm.
DESCRIPTION:
An ellipse can be given in terms of the distances from any point on the ellipse
to two fixed positions called the foci of the ellipse. The sum of these two distances is the same
values for all points on the ellipse.

The sum of the two distances d1 and d2, between the fixed positions F1 and F2 (called
the foci of the ellipse) to any point P on the ellipse, is the same value, i.e.
d1 + d2 = constant
The midpoint ellipse method is applied throughout the first quadrant in two parts and
then obtain positions in the remaining 3 quadrants by symmetry.
f ellipse (,x )y ry2 x 2 rx2 y 2 rx2 ry2

0 if (,x )y is inside the ellipse

f ellipse (,x )y0 if(, ) is oxn tyhe ellipse

0 if (,x )y is outside the ellipse

In the x direction where the slope of the curve has a magnitude less than 1 and unit steps
in the y direction where the slope has a magnitude greater than 1.

Starting at (0, ry) we take unit steps in the x direction until we reach the boundary
between region 1 and region 2. Then we take unit steps in the y direction over the remainder of
the curve in the first quadrant.

At the boundary
dy
1 2ry2 x 2rx2 y
dx
therefore, we move out of region 1 whenever
2ry2 x 2rx2 y

Region 1:(Choose (x i+1,yi ) or (xi+1,yi-1))

Region 2: (Choose (xi, yi-1) or (xi+1,yi-1))

Step in the negative y direction and midpoint is taken between horizontal pixels at each
step.

ALGORITHM :
Step 1: Input rx,ry and ellipse center (xc,yc) and obtain the first point on an ellipse centered on
the origin as
(x0,y0) = (0,ry)
Step 2: Calculate the initial value of the decision parameter in region 1 as

Step 3: At each x k position in region1 starting at k=0 perform the following test. If P1k<0, the
next point along the ellipse centered on (0,0) is(xk+1, yk) and

Otherwise the next point along the ellipse is (x k+1, yk-1) and

And continue until 2ry2 x>=2rx2 y

Step 4: Calculate the initial value of the decision parameter in region 2 using the last point
(x0,y0) is the last position calculated in region 1.

Step 5: At each position yk in region 2, starting at k=0 perform the following test, If
p2 k>0 the next point along the ellipse centered on (0,0) is (xk,yk-1) and

Otherwise the next point along the ellipse is (x k+1,yk-1) and

Using the same incremental calculations for x any y as in region 1.

Step 6: Determine symmetry points in the other three quadrants.
Step 7: Move each calculate pixel position (x,y) onto the elliptical path centered on (xc,yc)
and plot the coordinate values x=x+xc,y=y+yc
Step 8: Repeat the steps for region1 until 2ry 2x>=2rx 2y
CODING:
#include<stdio.h>
#include<conio.h>

#include<graphics.h>
#include<math.h>
#include<stdlib.h>
int round(float m)
{
int n;
if((m-0.5)>floor(m))
n=ceil(m);
else
n=floor(m);
return n;
}
void ellipseplotpoints(int,int,int,int);
void main()
{
int gdriver=DETECT,gmode;
int xc,yc,rx,ry;
int p,k=0,k1=0,x,y,px,py,rx1,ry1,rx2,ry2;
initgraph(&gdriver,&gmode,"C:\\TC\\BGI");
printf("enter the radius\n");
scanf("%d%d",&rx,&ry);
printf("enter the xcenter and ycenter\n");
scanf("%d%d",&xc,&yc);
ry1=ry*ry;
rx1=rx*rx;
ry2=2*ry1;
rx2=2*rx1;
x=0;
y=ry; ellipseplotpoints(xc,yc,x,y);
p=round(ry1-rx1*ry+(0.25*rx1));
px=0;
py=rx2*y;
printf("\nregion1\n");
printf("\nk\tx,y\tp\tpx\tpy\n");
printf("\n%d\t(%d,%d)\t%d\t%d\t%d",k,x,y,p,px,py);
while(px<py)
{
x=x+1;
k++;

px=px+ry2;
if(p>=0)
{
y=y-1; py=pyrx2;
p=p+ry1+px-py;
} else
p=p+ry1+px;
ellipseplotpoints(xc,yc,x,y);
printf("\n%d\t(%d,%d)\t%d\t%d\t%d",k,x,y,p,px,py);
} printf("\nregion2\n");
printf("\nk1\tx,y\tp\tpx\tpy\n");
p=round(ry1*(x+0.5)*(x+0.5)+rx1*(y-1)*(y-1)-rx1*ry1);
//p=(round(ry1*((x*x)+(2*x*0.5)+0.25))+(rx1*((y*y)-(2*y*1)+1))-(rx1*ry1));
printf("\n%d\t(%d,%d)\t%d\t%d\t%d",k1,x,y,p,px,py);
while(y>0)
{
y=y-1;
k1++;
py=py-rx2;
if(p<=0)
{ x=x+1;
px=px+ry2;
} if(p>0)
p=p+rx1-py;
else
p=p+rx1-py+px; ellipseplotpoints(xc,yc,x,y);
printf("\n%d\t(%d,%d)\t%d\t%d\t%d",k1,x,y,p,px,py);
} getch();
closegraph();
}
void ellipseplotpoints(int xc,int yc,int x,int y)
{
putpixel(xc+x,yc+y,2);

putpixel(xc-x,yc+y,2);
putpixel(xc+x,yc-y,2);
putpixel(xc-x,yc-y,2);
}
OUTPUT:

RESULT:
Thus the program for midpoint ellipse algorithm is implemented and executed
successfully.

Ex. No. 5

ATTRIBUTES OF OUTPUT PRIMITIVES

AIM:
To write a C program to set attributes to line, circle and ellipse.
DESCRIPTION:
Output primitives have geometric and non-geometric attributes. A parameter that affects
the way a primitive is to be displayed is referred to as an attribute parameter. Some attribute
parameters, such as color and size, determine the fundamental characteristics of a primitive. The
output primitives Such as Line, Circle and Ellipse are associated with set of attributes such as
Line (color and Line Style), Circle (Color) and Ellipse (Color and Patterns).
initgraph() Initialize the Graphics System
initgraph() is a graphics system control function. It is used to initialize the graphics
system. It should be the first graphics function called. initgraph() loads the graphics driver,
after allocating memory for it, then puts the system in graphics mode. 'gdriver' is set to DETECT
(autodetection), it calls detectgraph() and automatically selects the highest resolution graphics
mode for 'gmode'.

'dpath' names the directory path where the graphic driver files are located.
Syntax:
initgraph(&gdriver,&gmode,"C:\\TC\\BGI");
closegraph():
It is used to close graphics mode. When you exit from graphics mode, you should
restore the system to the previous display (text) mode. closegraph() function restores the
previous display mode. If you do not use this function and still you exit from graphics mode,
system gives some undesirable effects such as loss of cursor or off-sine characters. It is because
system tries to write text in graphics mode.
Syntax:
closegraph();
Shapes:

Computer graphics has many in-built commands, which can be used either to draw a
shape and/or for filling a color in any bounded shape.
lineto():
This command draws a line on screen from current cursor position to the (x,y) position
mentioned in command.
Syntax:
lineto(x,y);
Where, (x,y) are co-ordinates of end point of line.
line():
This command draws a line on screen.
Syntax:
line(x1,y1,x2,y2);
Where, (x1,y1) are co-ordinates of starting point of line and (x2,y2) are co- ordinates of end
point of line.
Example: line(10,10,100,100);
It will draw a line from point (10,10) to point (100,100).
Output: It draws only a line not a box on screen.

circle():
This command draws a circle on screen.
Syntax:
circle(x,y,r);
(x, y) are co-ordinates of centre of circle

r is radius of circle.
Example: circle(50,50,10);
It draws a circle with centre (50,50) and radius 10.
Output:

rectangle():
draws a rectangle on screen.
Syntax:
rectangle(x1,y1,x2,y2);
(x1,y1) are co-ordinates of top-left corner point of rectangle
(x2,y2) are co-ordinates of bottom-right corner point of rectangle.
Example: rectangle(10,10,100,100);
It will draw a rectangle as shown in following output.
Output:

ellipse():
draws an ellipse on screen.
Syntax:
void ellipse(int x, int y, int stangle, int endangle, int xradius, int yradius);

Argument What It Is
(x,y)

Center of ellipse

xradius

Horizontal axis

yradius

Vertical axis

stangle

Starting angle

endangle

Ending angle

The ellipse or sector travels from stangle to endangle.

If stangle = 0 and endangle = 360, the call to ellipse draws a complete ellipse.
Angle for ellipse, fillellipse, and sector (counter-clockwise)
90 degrees

180

0 degrees,
360 degrees
270 degrees

The linestyle parameter does not affect arcs, circles, ellipses, or pie slices. Only the thickness
parameter is used.
For full ellipse, the start and end should be 0 and 360 else it will draw an arc on screen.
Example: ellipse(100,100,0,360,20,10);
Output:

Example: ellipse(100,100,0,360,10,20);
Output:

fillellipse draws an ellipse, then fills the ellipse with the current fill color and fill pattern.
Syntax:
void far fillellipse(int x, int y,int xradius, int yradius);
Sector
draws and fills an elliptical pie slice in the current drawing color, then fills it using the pattern
and color defined by setfillstyle or setfillpattern.
Syntax:
void far sector(int x, int y, int stangle, int endangle,int xradius, int yradius);
bar
Syntax:
void bar(int left, int top, int right, int bottom); Remarks:
bar draws a filled-in, rectangular, two-dimensional bar.
The bar is filled using the current fill pattern and fill color. bar does not outline the bar.
To draw an outlined two-dimensional bar, use bar3d with depth = 0.
Parameter What It Is
(left, top)

the rectangle's upper left corner

(right,

the rectangle's lower right corner

bottom)

The coordinates are in pixels.

setcolor():
draws any subsequent graphics in a color given in command.
Syntax:
setcolor(color);
color is either color constant or color name
Example:
setcolor(RED);
line(10,10,100,100);
It will draw a line in red color.
If it is,
line(10,10,100,100);
setcolor(RED);

It will not draw line in red color.

setfillstyle():
decides the filling pattern and the filling color but it do not actually fill.
Syntax:
setfillstyle(pattern,color);
Pattern can be either pattern constant or patter name. These pattern constants are given in
following table.Color is the color constant or color name.
Pattern
Constant

Pattern Name

0
1
2
3
4
5
6
7
8
9
10
11

EMPTY_FILL
SOLID_FILL
LINE_FILL
LTSLASH_FILL
SLASH_FILL
BKSLASH_FILL
LTBKSLASH_FILL
HATCH_FILL
XHATCH_FILL
INTELEAVE_FILL
WIDE_DOT_FILL
CLOSE_DOT_FILL

setlinestyle():
specifies the thickness of the line to be drawn. These styles are not used for the circles.
Syntax:
setlinestyle(linestyle,user_defined_style,line_width);
Constant
0
1
2
3
4

Line
SOLID_LINE
DOTTED_LINE
CENTRE_LINE
DASHED_LINE
USERBIT_LINE

User_defined_style is user defined style and if ignored set to zero.

Line_width is tickness of line as given below
0 -NORM_WIDTH
3- THICK_WIDTH
Example:
setlinestyle(2,0,3);

getbkcolor
returns the current background color.
Syntax:
int getbkcolor(void);
setbkcolor
setbkcolor sets the background to the color specified by color.
Syntax:
setbkcolor(color name);
floodfill
floodfill fills an enclosed area on bitmap devices.
The area bounded by the color border is flooded with the current fill pattern and fill color.
Syntax:
void far floodfill(int x, int y, int border);
(x,y) is a "seed point".
o If the seed is within an enclosed area, the inside will be filled.
o If the seed is outside the enclosed area, the exterior will be filled.
Use fillpoly instead of floodfill whenever possible so you can maintain code compatibility with
future versions.
textheight
textheight takes the current font size and multiplication factor, and determines the height
of textstring in pixels.
Syntax:
int far textheight(char far *textstring);
textwidth
textwidth takes the string length, current font size, and multiplication factor, and
determines the width of textstring in pixels

Syntax:
int far textwidth(char far *textstring);
settextstyle
settextstyle sets the text font, the direction in which text is displayed, and the size of the
characters.
Syntax:
void far settextstyle(int font, int direction, int charsize);

A call to settextstyle affects all text output by outtext and outtextxy.

Enum: Names for BGI fonts
Meaning
Name
Value
0
DEFAULT_FONT
8x8 bit-mapped font
1
TRIPLEX_FONT
Stroked triplex font
2
SMALL_FONT
Stroked small font
3
SANS_SERIF_FONT
Stroked sans-serif font
4
GOTHIC_FONT
Stroked gothic font
Direction
Font directions supported are horizontal text (left to right) and vertical text
(rotated 90 degrees counterclockwise). The default direction is HORIZ_DIR.
Name :
Value : Direction
HORIZ_DIR 0 : Left to right
VERT_DIR 1 : Bottom to top
CODING:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main()
{
int a,b,c,d,e,f,i=10;
int gdriver=DETECT, gmode;
initgraph(&gdriver,&gmode,"E:\\TC\\BGI");
do
{
printf("1.line\n2.circle\n3.sector\n4.ellipse\n5.exit\n");
printf("enter choice\n");
scanf("%d",&a);
setbkcolor(LIGHTRED);
switch(a)
{
case 1:

setcolor(GREEN); printf("line\n");
printf("0.SOLID_LINE\n1.DOTTED_LINE\n2.DASHED_LINE\n");
printf("enter choice\n");
scanf("%d",&b);
setlinestyle(b,0,3);
line(200,200,100,100);
break;
case 2:
setcolor(RED);
printf("circle\n");
circle(100,100,50);
break;
case 3:
setcolor(BLUE);
printf("sector\n");
printf("1.LIGHTGREEN\n2.LIGHTRED\n3.YELLOW\n");
printf("0.EMPTY_FILL\n1.SOLID_FILL\n2.LINE_FILL\n3.LTSLASH_FILL\n4.HATCH_FIL
L\n5.BKSLASH_FILL\n6.LTBSLASH_FILL\n7.HATCH_FILL\n8.XHATCH_FILL\n9.INTER
LEAVE_FILL\n10.WIDE_DOT_FILL\n11.CLOSE_FILL\n12.USER_FILL\n");
printf("enter choice\n");
scanf("%d",&c);
scanf("%d",&f);
setfillstyle(c,f);
sector(300,300,0,360,50,30);
break;
case 4:
setcolor(GREEN);
printf("ellipse\n");
printf("enter choice\n");
scanf("%d",&d);

scanf("%d",&e);
ellipse(300,300,0,360,50,30);
settextstyle(d,e,25);
outtext("ellipse");
break;
case 5:
exit();
break;
}
}while(i<=10);
closegraph();
getch();
}
OUTPUT:

RESULT:
Thus the program for attributes of output primitive is implemented and executed
successfully.

Ex. No.6

IMPLEMENTATION OF 2D TRANSFORMATION

AIM:
To write a C-Program to perform various 2D-Transformations including Translations,
Scaling, Rotations, Reflection, Shear.
DESCRIPTION:
Changes in orientations, size and shape are accomplished with geometric transformations
that alter the coordinate description of objects.
Basic transformation:
Translation
Rotation
Scaling
Other transformation:
Reflection
Shear
Translation:
A translation moves all points in an object along the same straight-line path to new
positions.To translate a 2D position, we add translation distances tx and ty to the original
coordinates (x,y) to obtain the new coordinate position (x,y).The path is represented by a vector,
called the translation or shift vector.
x= x + tx , y= y + ty
x x t x
t
y y y

P P T
Rotation:
A rotation repositions all points in an object along a circular path in the plane
centered at the pivot point.

The original coordinates are:

x r cos(
)cos cosr
sin sinr
y r sin(
)cos sinr
sin cosr

x r cos(
)
y r sin(
)
Substituting
x x cos y sin
y x sin y cos

Matrix form
x cos sin x

y sin cos y

P R P

Scaling
Altering the size of an object. Sx and Sy are the scaling factors.
Values less than 1 reduce the size of the objects
Values greater than 1 produce an enlarged object.
Uniform scaling it is necessary to assign same value for sx and sy.
Unequal values for Sx and Sy result in a non uniform scaling.
Matrix form

x S x
0
y

x xS x
y yS y
0 x

S y y

P S P

Scaling relative to fixed point (xf, yf)

x x f ()x x f S x
y y f ()y y f S y

Reflection:
A reflection is a transformation that produces a mirror image of an object. The mirror
image for a two-dimensional reflection is generated relative to an axis of reflection by rotating
the object 180 o about the reflection axis.
Reflection about x axis:
x 1 0 0 x


y 0 1 0 y
1 0 0 1 1

Reflection about y axis:

Relative to the coordinate origin

With respect to the line y = x

x 1 0 0 x
y 0 1 0 y


1 0 0 1 1

x 1 0 0 x


y 0 1 0 y
1 0 0 1 1

x 0 1 0 x
y 1 0 0 y


1 0 0 1 1

Shear:
A transformation that distorts the shape of an object such that the transformed shape
appears as if the object were composed of internal layers that had been caused to slide over each
other is called a shear. Two common shearing transformations are those that shift coordinate x
values and those that shift y values.
x-direction shear
x x shx y
y y
Matrix form

x 1 shx
y 0 1

1 0 0

0 x
0 y
1 1

x-direction relative to other reference line

x x shx ()y yref
y y
Matrix form
x 1 shx
y 0 1

1 0 0

shx yref x

0
y

1
1

y-direction shear
x x
y y shy x
Matrix form

x 1

y shy
1 0

0 0 x

1 0 y

0 1 1

y-direction relative to other reference line

x x
Matrix form y y shy ()x xref
x 1

y shx

1 0

0
0
x

1 shy xref y

0
1
1

ALGORITHM :
Step 1 : Start the program.
Step 2 : Get the choice from the user about the transformation to the performed after
Including necessary header files and Initializing necessary variables with initgraph()
function.
Step 3 : In case of translation get the translation factors and add then with the old
coordinates of the triangle and Draw the triangle now with the new coordinates.
Step 4 : In case of scaling get the scaling factors and multiply them with the old
coordinates and draw the triangle with new coordinates.
Step 5 : For Rotation get the rotation angle and the fixed point is obtained from the user and
add the calculated values to the old coordinates and draw the triangle with new
coordinates.
Step 6 : For shearing get the shearing constants and reference
About x and y axis,
(i) For shearing about x axis keep x coordinate as it in and after and change y
coordinate.
(ii) For shearing about y axis keep y coordinate as it in and after x axis
coordinate.
Draw the triangle with new calculated coordinates.
Step 7 : Stop the program.
CODING:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
#define COL 2
int a[]={245,45,260,60,220,60};
int ROUND(float a)
{
return (int)(a>0)?a+.5:a-.5;
}
void draw(int *temp)

{
line(temp[0],temp[1],temp[2],temp[3]);
line(temp[0],temp[1],temp[4],temp[5]);
line(temp[2],temp[3],temp[4],temp[5]);
}
void translate(int tx,int ty)
{
int temp[6],i;
for(i=0;i<6;i++)
{
temp[i]=a[i]+tx;
i++;
temp[i]=a[i]+ty;
}
draw(temp);
}
void scale(int sx,int sy)
{
int temp[6],i;
for(i=0;i<6;i++)
{
temp[i]=a[i]*sx;
i++;
temp[i]=a[i]*sy;
}
draw(temp);
}
void rotate(int tde)
{
int i,temp[6]; float
t,cx,cy;
cx=(a[0]+a[2]+a[4]/3);
cy=(a[1]+a[3]+a[5]/3);
t=tde*M_PI/180;
for(i=0;i<6;i++)
{
temp[i]=ROUND((a[i]-cx)*cos(t)-(a[i+1]-cy)*sin(t)+cx);
temp[i+1]=ROUND((a[i]-cx)*sin(t)+(a[i+1]-cy)*cos(t)+cy);
}
draw(temp);

setcolor(0);
line(a[0],a[1],a[2],a[3]);
line(a[0],a[1],a[4],a[5]);
line(a[2],a[3],a[4],a[5]);
setcolor(3);
}
void reflect()
{
int i,temp[6],tde=45;
float t,cx,xy;
for(i=0;i<6;i++)
{
temp[i]=a[i+1];
temp[i+1]=a[i];
}
draw(temp);
getch();
setcolor(0);
line(temp[0],temp[1],temp[2],temp[3]);
line(temp[0],temp[1],temp[4],temp[5]);
line(temp[2],temp[3],temp[4],temp[5]);
setcolor(3);
t=tde*M_PI/180;
for(i=0;i<6;i+=2)
{
temp[i]=ROUND((a[i]*cos(t))-(a[i+1]*sin(t)));
temp[i+1]=ROUND((a[i]*sin(t))+(a[i+1]*cos(t)));
} setcolor(4);
line(temp[0],temp[1],temp[2],temp[3]);
line(temp[0],temp[1],temp[4],temp[5]);
line(temp[2],temp[3],temp[4],temp[5]);
}
void shear()
{
int sh,i,temp[6];
printf("enter the shear value");
scanf("%d",&sh);
for(i=0;i<6;i+=2)
{

temp[i]=(a[i]+(sh*a[i+1]));
temp[i+1]=a[i+1];
}
draw(temp);
}
void main()
{
int x,y,gd=DETECT,gm,phi,d;
clrscr();
initgraph(&gd,&gm,"C:\\TC\\BGI");
setcolor(COL);
printf("initial primitive");
draw(a);
printf("translation \n enter tx and ty");
scanf("%d%d",&x,&y);
translate(x,y);
printf("scaling \n enter sx and sy");
scanf("%d%d",&x,&y);
scale(x,y);
printf("rotation \n enter rotation angle(in degree):");
scanf("%d",&phi);
rotate(phi);
printf("reflection about line x=y");
reflect();
printf("sheared image");
shear();
getch();
closegraph();
}
OUTPUT:

Ex. No.7

IMPLEMENTATION OF 2D COMPOSITE TRANSFORMATION

AIM:
To write a C-Program to perform various 2D composite transformations.
Algorithm
Step 1 : Start the program
Step 2 : Include all header files and Initialize the variables that are necessary for the execution
of the program.
Step 3 : To perform Translation, get coordinates of line and translate it, again translate the
translated line.
Step 4 : To perform scaling, get the scaling factor and change the lines length, again scale the
changed one to the Original position.
Step 5 : To perform rotation, get the angle and rotate the line, again get the angle and rotate the
already rotated line.
Step 6 : To perform the general fixed point scaling, first translate the line, scale it and perform
reverse translation.
Step 7 : Stop the program.
CODING:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void translate();
void scale();
void rotate();
void main()
{
int ch;
int gd=DETECT,gm;
initgraph(&gd,&gm,"d:\\tc\\bgi");
setcolor(6);
outtextxy(100,88,"object");
rectangle(100,150,150,100);

printf("MENU");
printf("\n1.translation\n2.scale\n3.rotate");
printf("\nenter choice");
scanf("%d",&ch);
cleardevice();
switch(ch)
{
case 1:
translate();
break;
case 2:
scale();
break;
case 3:
rotate();
break;
default:printf("you have entered the wrong choice");
break;
} getch();
closegraph();
}
void translate()
{
int tx,ty,tx1,ty1,tx2,ty2; setcolor(2);
outtextxy(240,10,"TRANSLATION");
outtextxy(238,20,"--------");
printf("\nenter tx and ty for translation1");
scanf("%d%d",&tx1,&ty1);
printf("\nenter tx and ty for translation2");
scanf("%d%d",&tx2,&ty2);
tx=tx1+tx2;ty=ty1+ty2;
cleardevice(); rectangle(100,150,150,100);
rectangle(100+tx1,150+ty1,150+tx1,100+ty1);
printf("\n after translation");
rectangle(100+tx,150+ty,150+tx,100+ty);
}
void scale()

{
int sx,sy,sx1,sy1,sx2,sy2; setcolor(2);
outtextxy(240,10,"SCALING");
outtextxy(238,20,"--------");
printf("\nenter sx and sy for scaling1");
scanf("%d%d",&sx1,&sy1);
printf("\nenter sx and sy for scaling2");
scanf("%d%d",&sx2,&sy2);
sx=sx1+sx2;sy=sy1+sy2;
cleardevice(); rectangle(100,150,150,100);
rectangle(100*sx1,150*sy1,150*sx1,100*sy1);
printf("\n after scaling");
rectangle(100*sx,150*sy,150*sx,100*sy);
}
void rotate()
{
float theta,theta1,theta2;
int x1,x2,x3,x4;
int y1,y2,y3,y4;
int ax1,ax2,ax3,ax4;
int ay1,ay2,ay3,ay4;
int refx,refy;
printf("\nenter the 1st angle");
scanf("%f",&theta1);
printf("\nenter the 2nd angle");
scanf("%f",&theta2);
theta=theta1+theta2;
theta=theta*(3.14/180);
cleardevice();
setcolor(2);
outtextxy(240,10,"ROTATE");
outtextxy(238,20,"--------");
refx=100;refy=100;
x1=100;y1=100;
x2=150;y2=100;
x3=150;y3=150;
x4=100;y4=150;
ax1=refy+(x1-refx)*cos(theta1)-(y1-refy)*sin(theta1);

ay1=refy+(x1-refx)*sin(theta1)+(y1-refy)*cos(theta1);
ax2=refy+(x2-refx)*cos(theta1)-(y2-refy)*sin(theta1);
ay2=refy+(x2-refx)*sin(theta1)+(y2-refy)*cos(theta1);
ax3=refy+(x3-refx)*cos(theta1)-(y3-refy)*sin(theta1);
ay3=refy+(x3-refx)*sin(theta1)+(y3-refy)*cos(theta1);
ax4=refy+(x4-refx)*cos(theta1)-(y4-refy)*sin(theta1);
ay4=refy+(x4-refx)*sin(theta1)+(y4-refy)*cos(theta1);
rectangle(100,150,150,100);
line(ax1,ay1,ax2,ay2);
line(ax2,ay2,ax3,ay3);
line(ax3,ay3,ax4,ay4);
line(ax4,ay4,ax1,ay1);
ax1=refy+(x1-refx)*cos(theta)-(y1-refy)*sin(theta);
ay1=refy+(x1-refx)*sin(theta)+(y1-refy)*cos(theta);
ax2=refy+(x2-refx)*cos(theta)-(y2-refy)*sin(theta);
ay2=refy+(x2-refx)*sin(theta)+(y2-refy)*cos(theta);
ax3=refy+(x3-refx)*cos(theta)-(y3-refy)*sin(theta);
ay3=refy+(x3-refx)*sin(theta)+(y3-refy)*cos(theta);
ax4=refy+(x4-refx)*cos(theta)-(y4-refy)*sin(theta);
ay4=refy+(x4-refx)*sin(theta)+(y4-refy)*cos(theta);
line(ax1,ay1,ax2,ay2);
line(ax2,ay2,ax3,ay3);
line(ax3,ay3,ax4,ay4);
line(ax4,ay4,ax1,ay1);
}
OUTPUT:

SCALING:

ROTATION:

RESULT:
Thus the program for 2D composite transformation is implemented and executed
successfully.

Ex. No. 8

IMPLEMENTATION OF CLIPPING A LINE USING COHEN

SUTHERLAND LINE CLIPPING ALGORITHM

AIM:
To write a C-program to perform line clipping using Cohen Sutherland line clipping
algorithm.
DESCRIPTION:
Any procedure that identifies those portion of a picture that are either inside or outside of
a specified region of space is referred as Clipping Algorithm or Clipping. The region against
which an object is to clipped is called a clip window.
Cohen Sutherland line clipping algorithm is one of the oldest and most popular lineclipping procedures. The method speeds up the processing of line segments by performing
initial tests that reduce the number of intersections that must be calculated. It quickly detects and
dispenses with two common and trivial cases.
To clip a line, we need to consider only its endpoints. If both endpoints of a line lie inside
the window, the entire line lies inside the window. It is trivially accepted and needs no clipping.
On the other hand, if both endpoints of a line lie entirely to one side of the window, the line must
lie entirely outside of the window. It is trivially rejected and needs to be neither clipped nor
displayed.

Every line endpoint in a picture is assigned a four digit binary code called a region code that
identifies the location of the point relative to the boundaries of the clipping rectangle.

ALGORITHM:
1. Assign a region code for each endpoints.
2. If both endpoints have a region code 0000 --- trivially accept these line.
3. Else, perform the logical AND operation for both region codes.
3.1 if the result is not 0000 - trivially reject the line.
3.2 else (result = 0000, need clipping)
3.2.1. Choose an endpoint of the line that is outside
the window.
3.2.2. Find the intersection point at the window
boundary (base on regioncode).
To find intersection point, use line equation
intersection with LEFT or RIGHT boundary.
x = xwmin (LEFT)

x = xwmax (RIGHT)

y = y1 + m(x x1)
intersection with BOTTOM or TOP boundary.
y = ywmin (BOTTOM)

y = ywmax (TOP)

x = x1 + (y y1)/m

3.2.3. Replace endpoint with the intersection point and update the region code.
3.2.4. Repeat step 2 until we find a clipped line either trivially accepted or trivially
rejected.
4. Repeat step 1 for other lines.

CODING:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#include<graphics.h>
typedef unsigned intoutcode;
enum
{top=0x8,bottom=0x4,right=0x2,left=0x1};
void cohen(double,double,double,double,double,double,double,double);
outcodecompoutcode(double,double,double,double,double,double);
int main(void)
{intgd=DETECT,gm;
int x6,y6,x7,y7,x0,y0,x1,y1,xmax,ymax,xmin,ymin,x2,y2,x3,y3,x4,y4,x5,y5;
initgraph(&gd,&gm,"C:\\TC\\BGI"); printf("enter the
rectangle coordinates");
scanf("%d%d%d%d",&xmin,&ymin,&xmax,&ymax);
printf("enter the 1st line coordinates");
scanf("%d%d%d%d",&x0,&y0,&x1,&y1);
printf("enter the 2nd line coordinates");
scanf("%d%d%d%d",&x2,&y2,&x3,&y3);
printf("enter the 3rd line coordinates");
scanf("%d%d%d%d",&x4,&y4,&x5,&y5);
printf("enter the 4th line coordinates");
scanf("%d%d%d%d",&x6,&y6,&x7,&y7);
getch();

setlinestyle(0,1,3); setcolor(1);
rectangle(xmin,ymin,xmax,ymax);
setcolor(2);
line(x0,y0,x1,y1);
setcolor(3);
line(x2,y2,x3,y3);
setcolor(4);
line(x4,y4,x5,y5);
setcolor(5);
line(x6,y6,x7,y7);
getch();
cleardevice();
printf("\n after clipping"); setcolor(6);
cohen(x0,y0,x1,y1,xmin,ymin,xmax,ymax);
setcolor(7);
cohen(x2,y2,x3,y3,xmin,ymin,xmax,ymax);
setcolor(8);
cohen(x4,y4,x5,y5,xmin,ymin,xmax,ymax);
setcolor(9);
cohen(x6,y6,x7,y7,xmin,ymin,xmax,ymax);
getch();
closegraph();
return 0;}
voidcohen(double x0,double y0,double x1,double y1,double xmin,doubleymin,doubleymax)

{doublex,y;
outcode outcode0,outcode1,outcodeout; int
accept=0,done=0;
outcode0=compoutcode(x0,y0,xmin,ymin,xmax,ymax);
outcode1=compoutcode(x1,y1,xmin,ymin,xmax,ymax);
do
{if(!(outcode0|outcode1))
{accept=1;
done=1;}
else if(outcode0&outcode1)
done=1;
else
{outcodeout=outcode0?outcode0:outcode1;
if(outcodeout&top)
{x=x0+(x1-x0)*(ymax-y0)/(y1-y0);
y=ymax;}
else if(outcodeout&bottom)
{x=x0+(x1-x0)*(ymin-y0)/(y1-y0);
y=ymin;}
else if(outcodeout&right)
{y=y0+(y1-y0)*(xmax-x0)/(x1-x0);
x=xmax;}
else
{y=y0+(y1-y0)*(xmin-x0)/(x1-x0);
x=xmin;}
if(outcodeout==outcode0)

{x0=x; y0=y;
outcode0=compoutcode(x0,y0,xmin,ymin,xmax,ymax);
}
else
{x1=x; y1=y;
outcode1=compoutcode(x1,y1,xmin,ymin,xmax,ymax);
}}}while(done==0);
if(accept)
{rectangle(xmin,ymin,xmax,ymax);
line(x0,y0,x1,y1);
}}
outcodecompoutcode(double x,doubley,doublexmin,doubleymin,doublexmax,doubleymax)
{
outcode code=0;
if(y>ymax)
code|=top;
else if(y<ymin)
code|=bottom;
if(x>xmax)
code|=right;
if(x<xmin)
code|=left;
return code;
}

OUTPUT:

RESULT:
Thus the program for Cohen Sutherland line clipping algorithm is implemented and
executed successfully.

Ex. No. 9

IMPLEMENTATION OF CLIPPING A POLYGON USING

SUTHERLAND HODGEMAN POLYGON CLIPPING
ALGORITHM

AIM:
To write a C-program to perform polygon clipping using Sutherland Hodgeman polygon
clipping algorithm.
DESCRIPTION:
The Sutherland Hodgeman Polygon Clipping Algorithm works by extending each line
of the convex clip polygon in turn and selecting only vertices from the subject polygon that is on
the visible side. It accepts an ordered sequence of vertices v1, v2, v3... vn and puts out a set of
vertices defining the clipped polygon.

Clip the polygon by processing the polygon boundary as a whole against each
window.

Process all polygon vertices against each clip rectangle boundary in turn.

First clip the polygon against the left boundary to produce a new sequence of
vertices.

The new sequence of vertices is then successive passed to right, bottom and top
boundary clipper.

At each step a new sequence of output vertices is generated and passed to the next
boundary clipper

Rule for each edge for each clipper:

Input each edge (vertex pair) successively.
Output is a new list of vertices.

Each edge goes through 4 clippers.

If first input vertex is outside, and second is inside, output the intersection and the
second vertex

If both input vertices are inside, then just output second vertex

If first input vertex is inside, and second is outside, output is the intersection

If both vertices are outside, output is nothing.

The last vertex in the list is always added to the first vertex

CODING:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#define round(a)((int)(a+0.5))
int k;
float xmin,xmax,ymin,ymax,arr[20],m;
void clipl(float x1,float y1,float x2,float y2)
{
if(x2-x1)
m=(y2-y1)/(x2-x1);
else m=100000;
if(x1>=xmin&&x2>=xmin)
{ arr[k]=x2;
arr[k+1]=y2;
k+=2;
}
if(x1<xmin&&x2>=xmin)
{
arr[k]=xmin;

arr[k+1]=y1+m*(xmin-x1);
arr[k+2]=x2;
arr[k+3]=y2;
k+=4;
}
if(x1>=xmin&&x2<xmin)
{ arr[k]=xmin;
arr[k+1]=y1+m*(xmin-x1);
k+=2;
}
}
void clipt(float x1,float y1,float x2,float y2)
{
if(y2-y1)
m=(x2-x1)/(y2-y1);
else
m=100000;
if(y1<=ymax&&y2<=ymax)
{ arr[k]=x2;
arr[k+1]=y2;
k+=2;
}
if(y1>ymax&&y2<=ymax)
{
arr[k]=x1+m*(ymax-y1);
arr[k+1]=ymax;
arr[k+2]=x2;
arr[k+3]=y2;
k+=4;
}
if(y1<=ymax&&y2>ymax)
{
arr[k]=x1+m*(ymax-y1);
arr[k+1]=ymax;
k+=2;
}}
void clipr(float x1,float y1,float x2,float y2)
{
if(x2-x1)
m=(y2-y1)/(x2-x1);
else
m=100000;

if(x1<=xmax&&x2<=xmax)
{ arr[k]=x2;
arr[k+1]=y2;
k+=2;
}
if(x1>xmax&&x2<=xmax)
{ arr[k]=xmax;
arr[k+1]=y1+m*(xmax-x1);
arr[k+2]=x2;
arr[k+3]=y2;
k+=4;
}
if(x1<=xmax&&x2>xmax)
{ arr[k]=xmax;
arr[k+1]=y1+m*(xmax-x1);
k+=2;
}}
void clipb(float x1,float y1,float x2,float y2)
{
if(y2-y1)
m=(x2-x1)/(y2-y1);
else m=100000;
if(y1>=ymin&&y2>=ymin)
{ arr[k]=x2;
arr[k+1]=y2;
k+=2;
}
if(y1<ymin&&y2>=ymin)
{
arr[k]=x1+m*(ymin-y1);
arr[k+1]=ymin;
arr[k+2]=x2;
arr[k+3]=y2;
k+=4; }
if(y1>=ymin&&y2<ymin)
{
arr[k]=x1+m*(ymin-y1);
arr[k+1]=ymin;
k+=2;

}}
void main()
{
int i,n,p[20],gd=DETECT,gm; float
xi,yi,xf,yf,py[20];
initgraph(&gd,&gm,"C:\\TC\\BGI");
clrscr();
printf("\nenter the coords of rectangular clip window\n xmin,ymin");
scanf("%f%f",&xmin,&ymin);
printf("\nxmax,ymax");
scanf("%f%f",&xmax,&ymax);
printf("\npolygon to be clipped\n no of sides:");
scanf("%d",&n);
printf("\nenter coords");
for(i=0;i<2*n;i++)
scanf("%f",&py[i]);
py[i]=py[0];
py[i+1]=py[1];
for(i=0;i<2*n;i++)
p[i]=round(py[i]);
setcolor(14);
rectangle(xmin,ymax,xmax,ymin);
printf("\nunclipped polygon");
setcolor(13);
fillpoly(n,p);
getch();
cleardevice();
k=0;
for(i=0;i<2*n;i+=2)
clipl(py[i],py[i+1],py[i+2],py[i+3]);
n=k/2;
for(i=0;i<k;i++)
py[i]=arr[i];
py[i]=py[0];
py[i+1]=py[1];
k=0;
for(i=0;i<2*n;i+=2)
clipt(py[i],py[i+1],py[i+2],py[i+3]);
n=k/2;
for(i=0;i<k;i++)
py[i]=arr[i];
py[i]=py[0];
py[i+1]=py[1];
k=0;
for(i=0;i<2*n;i+=2)

clipr(py[i],py[i+1],py[i+2],py[i+3]);
n=k/2;
for(i=0;i<k;i++)
py[i]=arr[i];
py[i]=py[0];
py[i+1]=py[1];
k=0;
for(i=0;i<2*n;i+=2)
clipb(py[i],py[i+1],py[i+2],py[i+3]);
for(i=0;i<k;i++)
p[i]=round(arr[i]);
if(k)
fillpoly(k/2,p);
setcolor(12);
rectangle(xmin,ymax,xmax,ymin);
printf("\nclipped polygon");
getch();
closegraph();
}

OUTPUT:

RESULT:
Thus the program for Sutherland Hodgemen Polygon clipping algorithm is implemented
and executed successfully.

Ex. No.10

BASIC OPENGL PROGRAMS

DESCRIPTION:
OpenGL is a software interface that allows you to access the graphics hardware without
taking care of the hardware details or which graphics adapter is in the system. It is device
Independent Graphics Programming language and application programming interface.
ADVANTAGE OF OPENGL
Cross platform (Windows, Linux, Mac, even some handheld devices).
Fast
Portable
Easy to use
Well-documented
OPENGL LIBRARIES
Basic GL- Fundamental Library
Starts With gl
GLUT- Graphics Library Utility Toolkit

Opening Windows

Developing and managing Menus

Managing Events

GLU- Utility Library

Matrix Operation

Drawing Primitives

GLUI- User Interface Library

Works along GLUT

controls such as buttons, checkboxes, radio buttons.

DYNAMICALLY-LINKED LIBRARIES

opengl32.dll

glu32.dll

glut32.dll

LIBRARIES

opengl32.lib

glu32.lib

glut32.lib

INCLUDE FILES

gl.h

glu.h

glut.h

OPENING A WINDOW FOR DRAWING

The First task in making pictures is to open a screen window for drawing. The following
initialize and display the screen window in the program.
1. glutInit(&argc, argv)
It should be called before any other GLUT routine because it initializes the
GLUT library.
2. glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
Specify the display mode for a window.
3. glutInitWindowSize(640,480)
To specify the size, in pixels, of our inital window. The arguments indicate the
height and width (in pixels) of the requested window.
4. glutInitWindowPosition(100,15)
To specify the screen location for the upper- left corner of our initial window.
This function positioned the screen 100 pixels over from the left edge and 150 pixels
down from the top.
5. glutCreateWindow(Example)
The command takes a string as a parameter which may appear in the title bar.
6. glutMainLoop()
The window is not actually displayed until the glutMainLoop() is entered.
EVENT DRIVEN PROGRAMMING
The method of associating a call back function with a particular type of event is called as
event driven programming. OpenGL provides tools to assist with the event management.

There are four Glut functions available

1. glutDisplayFunc(mydisplay)
Redraws screen when window opened or another window moved off it.
2. glutReshapeFunc(myreshape)
Reports new window width and height for reshaped window. (Moving a window
does not produce a reshape event.
3. glutKeyboardFunc(mykeyboard)
To run the callback function specified and pass as parameters, the ASCII code of
the pressed key, and the x and y coordinates of the mouse cursor at the time of the event.
4. glutMouseFunc(mymouse)
GLUT supports interaction with the computer mouse that is triggered when one
of the three typical buttons is presses. A mouse callback function can be initiated when
a given mouse button is pressed or released. The command glutMouseFunc() is used to
specify the callback function to use when a specified button is a given state at
a certain location.
OPENGL SYNTAX
void glBegin(GLenum mode)
glvertex2i(arguments);
glvertex2i(arguments);
void glEnd(void)

FORMAT OF glVertex COMMAND

EXAMPLE:

//the following code plots three dots

glBegin(GL_POINTS);
glVertex2i(100, 50);
glEnd( );

OPENGL DATATYPES

OPEN GL-SETUP
PROCEDURE:
Before executing the programs you have to place three header files (dll, Header, Lib) in the
following locations
Header:
C:\Program Files\Microsoft Visual Studio\VC98\Include\GL
Lib:
C:\Program Files\Microsoft Visual Studio\VC98\Lib
Dll:
C:\WINDOWS\system32
Go to StartPrograms Microsoft Visual Studio 6.0 Microsoft Visual C++ 6.0
FileNew...

 New dialog boxes opens in that select the win32console application from the projects tab
and give the name for the project and click on the ok and finish button.

Now select Tools menu and select options from it.

In that select the directories tab and select the browse button as given in the below
screenshot.

 Select the path for the three header files that you have pasted in different locations and
click on the ok button.

FileNew...

Select the C++ source file from the files tab and give the name for the file and click ok
button .

 Now select project menu and select the settings from the drop down menu.

In the project settings dialog box click on the link tab and type the three file names at the
end of the object/library modules text box.
File names: opengl32.lib glu32.lib glut32.lib

 And then click on the General tab and select Not Using MFC in Microsoft Foundation
Classes option

Then click on the C/C++ tab and select C++ Language from the category drop down list
and click on the ok button

 After performing these steps type the required program code save the program and click
on the build button.
Then click on the Execute program button
CODING:
Drawing a Teapot
#include glut.h
void display();
void reshape(GLsizei, GLsizei);
void main(intargc, char** argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("sample");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
}
void display(){
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
glutSolidTeapot(1.0);

glFlush();
}void reshape(GLsizei w, GLsizei h){
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-0.5, 0.5, -0.5, 0.5, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
OUTPUT

Drawing Sample
#include glut.h
void display();
void reshape(GLsizei w, GLsizei h);
void main(intargc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(250, 250);
glutInitWindowPosition(100, 100);
glutCreateWindow("Drawing sample");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
}
void reshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glOrtho(-2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void display()
{
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glColor3d(1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, -1.0f, 0.0f);
glColor3d(1.0f, 0.0f, 0.0f);
glVertex3f(1.0f, -1.0f, 0.0f);
glColor3d(0.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glColor3d(0.0f, 0.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, 0.0f);
glEnd();
glFlush();
}
OUTPUT:

RESULT:
Thus the program for drawing a teapot is implemented and executed successfully.

Ex. No. 11

IMPLEMENTATION OF 3D OBJECTS USING OPENGL

AIM :
To write a program using OPENGL for displaying a three dimensional objects.
DESCRIPTION:

OpenGL has separate transformation matrices for different graphics features

glMatrixMode(GLenum mode)
GLMODELVIEW - for manipulating model in scene
GL_PROJECTION - perspective orientation
GL_TEXTURE - texture map orientation
glLoadIdentity()
Loads a 4-by-4 identity matrix into the current matrix
glPushMatrix()
Push current matrix stack
glPopMatrix()
Pop the current matrix stack
glMultMatrix ()
Multiply the current matrix with the specified matrix
glViewport()
Set the viewport
Example :
glViewport(0, 0, width, height);
gluPerspective()
Sets up a perspective projection matrix.
Syntax :
gluPerspective(angle, asratio, ZMIN, ZMAX);
Example :
gluPerspective(60.0, width/height, 0.1, 100.0);
gluLookAt()

view volume that is centered on a specified eyepoint

Example :
gluLookAt(3.0, 2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glutSwapBuffers () :
glutSwapBuffers swaps the buffers of the current window if double buffered.
OPENGL FUNCTIONS FOR DRAWING 3D OBJECTS

glutWireCube(double size);

glutSolidCube(double size);

glutWireSphere(double radius, int slices, int stacks);

glutSolidSphere(double radius, int slices, int stacks);

glutWireCone(double radius, double height, int slices, int stacks);

glutSolidCone(double radius, double height, int slices, int stacks);

glutWireTorus(double inner_radius, double outer_radius, int sides, int rings);

glutSolidTorus(double inner_radius, double outer_radius, int sides, int rings);

glutWireTeapot(double size);

glutSolidTeapot(double size);

CODING:
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<GL/glut.h>
static GLfloat rot=0,a=1.0,b=1.0,c=1.0,as,tx,tz,ty,sx,sy,sz,rx,ry,rz,an,ang;
static GLint op, p, pr, pd, ch, key;
void mydisp()
{
glClear (GL_COLOR_BUFFER_BIT);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective (80.0, (GLdouble)4/(GLdouble)3, 0.1, 30.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0,10.0,20.0,1.0,0.0,1.0,0.0,1.0,0.0);
if (pr==1)
{
glColor3f(0.5, 0.5, 1.0);
glutWireTeapot(8);
}

if (pr==2)
{
glColor3f (0.0, 0.2, 1.0);
glutWireSphere (12, 20, 40);
}
if (pr==3)
{
glColor3f(1.0, 0.0, 0.0);
glutWireTorus (4, 8, 20, 40);
}
if (pr==4)
{
glColor3f (1.0, 0.4, 0.0);
glutWireCube(10);
}
if (pr==5)
{
glColor3f (1.0, 0.0, 0.0);
glutWireCone (8.0, 15.0, 10, 20);
}
if (pr==6)
{
glColor3f(1.0, 0.0, 1.0);
glScalef(8,12,7);
glutWireTetrahedron();
}
if (pr==7)
{
glColor3f(1.0, 0.0, 1.0);
glScalef(14,12,8);
glutWireOctahedron();
}
glutSwapBuffers();
}
void myidle()
{
rot=rot + 1.0;
glutPostRedisplay();
}
void myKey(unsigned char pd, int x, int y)
{
switch(pd)
{
case 'p': case 'P':
printf("1.Teapot\n2.Sphere\n3.Torus\n4.Cube\n5.Cone\n6.Tetrahedron\n7.Octahedron");

printf ("\n Enter the Option :");

scanf("%d",&p);
switch(p)
{
case 1:
pr=1;
break;
case 2:
pr=2;
break;
case 3:
pr=3;
break;
case 4:
pr=4;
break;
case 5:
pr=5;
break;
case 6:
pr=6;
break;
case 7:
pr=7;
break;
}
break;
}
}
void main (int argc, char** argv)
{
glutInit (&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowSize(420,360);
glutInitWindowPosition(0,0);
glutCreateWindow("3D PROGRAM");
glClearColor (1, 1, 1, 0);
glutDisplayFunc(mydisp);
glutKeyboardFunc(myKey);
glutIdleFunc(myidle);
glutMainLoop();
}
OUTPUT:
1.Teapot
2.Sphere

3.Torus
4.Cube
5.Cone
6.Tetrahedron
7.Octahedron
Enter the Option : 1

If Choice is 2

If Choice is 3

If Choice is 4

If Choice is 5

If Choice is 6

If Choice is 7

RESULT:
Thus the OpenGL program for 3D objects is implemented and executed successfully.

Ex. No. 12

IMPLEMENTATION OF 3D SCENES USING OPENGL

AIM :
To write a program using OPENGL concept for displaying a three dimensional scenes.
ALGORITHM:
Step 1: Start the program
Step 2: Include the header files gl/GL.h, gl/GLO.h,gl/glut.h that are necessary for the
execution of the program.
Step 3: Define the function wall with thickness parameter call the pushmatrix, translated,
scaled, popmatrix function.
Step 4: Define the function tableleg with thick and len parameters with pushmatrix, translated,
scaled, popmatrix function.
Step 5: Define the function jackpart with pushmatrix, scaled,translated, popmatrix function.
Step 6: Define the function jackpart with pushmatrix, jackpart(), glrotated, popmatrix
function.
Step 7: Define display solid with mat-ambient[] and mat-diffuse [] arrays with pushmatrix,
wall Rotated function. Finally call the flush function.
Step 8: Define the main function with argc and argv parameters with Init display mode
function, define windwosize and window position, color functions.
Step 9: call the glutmainloop function
Step 10: Stop the program.
CODING:
#include"windows.h"
#include"iostream.h"
#include"gl/Gl.h"
#include"gl/Glu.h"
#include"gl/Glut.h"
void tableLeg(double thick,double len)
{
glPushMatrix();
glTranslated(0,len/2,0);
glScaled(thick,len,thick);

glutSolidCube(1.0);
glPopMatrix();
}
void table(double topWid,double topThick,double legThick,double legLen)
{
glPushMatrix();
glTranslated(0,legLen,0);
glScaled(topWid,topThick,topWid);
glutSolidCube(1.0);
glPopMatrix();
double dist=0.95*topWid/2.0-legThick/2.0;
glPushMatrix();
glTranslated(dist,0,dist);
tableLeg(legThick,legLen);
glTranslated(0,0,-2*dist);
tableLeg(legThick,legLen);
glTranslated(-2*dist,0,2*dist);
tableLeg(legThick,legLen);
glTranslated(0,0,-2*dist);
tableLeg(legThick,legLen);
glPopMatrix();
}
void displaySolid(void)
{
GLfloat mat_ambient[]={0.7f,0.7f,0.7f,1.0f};
GLfloat mat_diffuse[]={0.6f,0.6f,0.6f,1.0f};
GLfloat mat_specular[]={1.0f,1.0f,1.0f,1.0f};
GLfloat mat_shininess[]={50.0f};
glMaterialfv(GL_FRONT,GL_AMBIENT,mat_ambient);
glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_diffuse);
glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular);
glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);
GLfloat lightIntensity[]={0.7f,0.7f,0.7f,1.0f};
GLfloat light_position[]={2.0f,6.0f,3.0f,0.0f};
glLightfv(GL_LIGHT0,GL_POSITION,light_position);
glLightfv(GL_LIGHT0,GL_DIFFUSE,lightIntensity);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
double winHt=1.0;
glOrtho(-winHt*64/48.0,winHt*64/48.0,-winHt,winHt,0.1,100.0);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(2.3,1.3,2,0,0.25,0,0.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslated(0.5,0.40,0.30);
glRotated(30,0,1,0);
glutSolidSphere(0.1,15,15);
glPopMatrix();
glPushMatrix();
glTranslated(0.4,0,0.4);
table(0.6,0.02,0.02,0.3);
glPopMatrix();
glFlush();
}
void main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(640,480);
glutInitWindowPosition(100,100);
glutCreateWindow("3D scenes");
glutDisplayFunc(displaySolid);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glClearColor(0.1f,0.1f,0.1f,0.0f);
glViewport(0,0,640,480);
glutMainLoop();
}

OUTPUT:

RESULT:
Thus the OpenGL program for 3D scenes is implemented and executed successfully.

Ex. No. 13

IMPLEMENTATION OF 3D TRANSFORMATION USING

OPENGL

AIM:
To write a c program for performing 3D transformation using opengl.
DESCRIPTION:
glTranslate ()
Multiply the current matrix by a translation matrix glTranslated(GLdouble x, GLdouble
y, GLdouble z);
Syntax:
void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
x, y, z - Specify the x, y, and z coordinates of a translation vector.
glRotate()
Multiply the current matrix by a rotation matrix
Syntax:
void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
angle : Specifies the angle of rotation, in degrees.
x, y, z : Specify the x, y, and z coordinates of a vector, respectively.
glScale()
Multiply the current matrix by a general scaling matrix
void glScaled(GLdouble x, GLdouble y, GLdouble z);
Syntax:
void glScalef(GLfloat x, GLfloat y, GLfloat z);
x, y, z : Specify scale factors along the x, y, and z axes, respectively.

CODING:

Ex. No. 14

IMPLEMENTATION OF 3D COMPOSITE TRANSFORMATION

USING OPENGL

Aim:
To write a c program for performing 3Dcomposite transformation using opengl.
ALGORITHM:
Step 1: Start the program
Step 2: Include the header files including GL/glut.h that are required for the execution of the
program.
Step 3: Define the required variables with the initialization values
Step 4: Define the mydisp function with clear, matrix mode and load identity function calling
Step 5: Define mykey function with the pr values for different 3D images including cube,
tetrahedron.
Step 6: Get the transformation option M for translation, scaling, Rotation.
Step 7: Get the translation, Scaling, Rotation Factors and define GLfloat for each values
Step 8: Define the main function with argc, argv parameters and call init and init display mode
function.
Step 9: Define window size, position with function.
Step 10: Stop the program.
CODING:
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<GL/glut.h> static GLfloat rot=0,a=1.0,b=1.0,c=1.0,as,tx,ty,tz,sx,sy,sz,rx,ry,rz,an,ang;
static GLintop,p,pr,pd,ch,key; void mydisp()
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(80.0,(GLdouble)4/(GLdouble)3,0.1,30.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0,0.0,20.0,0.0,0.0,0.0,0.0,1.0,1.0);
if(as==1)

glTranslatef(a,b,c);
if(as==2)
glScalef(a,b,c);
if(as==3)
glRotatef(an,a,b,c);
if(pr==1)
{
glColor3f(1.0,1.0,0.0);
glutWireTeapot(8);
}
if(pr==2)
{ glColor3f(0.0,1.0,1.0);
glutWireSphere(12,20,40);
}
if(pr==3)
{ glColor3f(1.0,0.0,1.0);
glutWireTorus(4,8,20,40);
}
if(pr==4)
{
glColor3f(1.0,1.0,0.0);
glutWireCube(8);
}
if(pr==5)
{ glColor3f(1.0,0.0,0.0);
glutWireCone(3.0,3.0,10,20);
}
if(pr==6)
{
glColor3f(1.0,0.0,1.0);
glutWireTetrahedron();
}
if(pr==7)
{
glColor3f(1.0,0.0,1.0);
glutWireOctahedron();
}

glutSwapBuffers();
}
void myidle()
{
rot=rot+1.0;
glutPostRedisplay();
}
void myKey(unsigned char pd,intx,int y)
{
switch(pd)
{
case 'p': case 'P':
printf("1.teapot\n2.sphere\n3.torus\n4.cube\n5.cone\n6.tetrahedron\n7.octahedron");
printf("\nEnter the option");
scanf("%d",&p);
switch(p)
{
case 1:
pr=1;
break;
case 2:
pr=2;
break;
case 3:
pr=3;
break;
case 4:
pr=4;
break;
case 5:
pr=5;
break;
case 6:
pr=6;
break;

case 7:
pr=7;
break;
}
break;
case 'm':
case'M':
glColor3f(1.0,1.0,0.0);
glutWireTeapot(8);
printf("1.translation \n 2.scaling \n3.rotation");
printf("\n Enter the option");
scanf("%d",&op);
switch(op)
{
case 1:
printf("Enter the tx,ty,tz values");
scanf("%f %f %f",&tx,&ty,&tz);
a=(GLfloat)tx;
b=(GLfloat)ty;
c=(GLfloat)tz;
as=1;
break;
case 2:
printf("Enter the sx,sy,sz values");
scanf("%f %f %f",&sx,&sy,&sz);
a=(GLfloat)sx;
b=(GLfloat)sy;
c=(GLfloat)sz;
as=2;
break;
case 3:
printf("Enter the rx,ry,rz values");
scanf("%f %f %f",&rx,&ry,&rz);
a=(GLfloat)rx;
b=(GLfloat)ry;
c=(GLfloat)rz;
as=3;
break;
default:
printf("choose the correct option");

break;
} }
}
void main(intargc,char** argv)
{ glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowSize(640,480); glutInitWindowPosition(0,0); glutCreateWindow("3D
PROGRAM"); glClearColor(0,0,0,0);
glutDisplayFunc(mydisp); glutKeyboardFunc(myKey);
glutIdleFunc(myidle);
glutMainLoop(); }
OUTPUT:
By pressing p

by pressing m: for translation

by pressing m: (for scaling)

by pressing m (for rotating)

RESULT:
Thus the program for 3D composite transformation is implemented using openGL and
executed successfully.

BLENDER

Blender is a free and open-source 3D computer graphics software product used for
creating animated films, visual effects, interactive 3D applications or video games. Blender's
features include 3D modeling, UV unwrapping, texturing, rigging and skinning, fluid and smoke
simulation, particle simulation, animating, rendering, video editing and compositing.
RENDERING:
A rendering is a pictorial output of a 3D scene or object. Features like materials, lighting,
oversampling and shadows control the effects and quality of the rendering.
There are three parts present in rendering they are
Materials and Textures
Lighting
Cameras

Materials and Textures:

You can control they way an object appears by applying color and textures. Materials
provide realism with added effects.

Lighting:
Lighting provides the realism to your scene through reflections and shadows. You can
control the type of light, intensity and color. Some lights can give a fog or dusty look with a
halo or volume lighting effect. Illumination distances can also be set.

Cameras:
Your camera is your point-of-view for the scene. Just like a real camera, you can control
lens length to achieve close-ups or wide angles. Clipping distance can also be set to control how
far and near the camera sees.

In every part it consists of three single arrow heads which points the direction (i.e.) is in x, y, z
direction.
Time factors:
In order to animate, you must first set the length of your animation in frames and your
frames per second (fps).

The given above figure tells the frame size and the green line is the starting point of the frame
and ending point will be set when a image is to be animated
BASIC BLENDER COMMANDS:
TAB key- Toggles between edit mode (vertex editing) and object select mode..
O key- The O key (not zero) will put you into proportional vertex editing while in edit
mode.
A key- While in edit mode its good for selecting all vertices for commands like remove
doubles and subdivide. A twice will clear selected and reselect.
B key- Gives you a box (window drag) to select multiple objects. In edit mode, works the
same to select multiple vertices, but hitting B twice gives you a circle select that can be sized
by scrolling the mouse wheel.
Space Bar- Brings up the tools menu where you can add meshes, cameras, lights, etc.
Number Pad- Controls your views. 7 top, 1 front, 3 side, 0 camera, 5 perspective, .
Zooms on selected object, + and zoom in and out. The +- buttons also control affected
vertices size in proportional vertex editing.
Mouse- Left to manipulate, right to select, center wheel to zoom and rotate view. If you hold
down shift and center wheel you can pan around on the screen.
Shift Key- Hold down the shift key to make multiple selections with the right mouse button.
Arrow Keys- Used to advance frames in animation. Left/right goes 1 frame at a time, up/down
goes 10 frames at a time.
R key- Rotates an object or selected vertices.

S key- Scales a selected object or vertices.

G key- Grabs or moves the object or selected vertices.
P key- While in edit mode, selected vertices can be separated into a single object by pressing
P.
Shift-D- Duplicates or copies selected objects or selected vertices.
E key- While in edit mode, selected vertices can be extruded by pressing E.
U key- In Object Mode brings up the Single-User menu to unlink materials, animations
(IPOs), etc. for linked or copied objects. Undo command. Only works in edit mode and can now
go back multiple steps. Sorry, no system-wide undo command.
M key- Moves selected objects to other layers. Mirror- while in edit mode, M will give
You a mirror command.
Z key- Toggles view from wireframe to solid.
Alt Z- Toggles a rough texture/shaded view.
N key- Brings up the numeric info. On a selected object (location, rotation and size). Info. can
then be changed in the window.
Ctrl J- Joins selected objects together.
F key- Makes a face in edit mode of the selected vertices. You can only select 3-4 vertices at
a time to make a face.
X or Delete- Delete selected objects, vertices or faces.
Function Keys- F1-Load File; F2-Save File; F3-Save Image; F4-Lamp Buttons; F5-Material
Buttons; F6-Texture Buttons; F7-Animation Buttons; F8-Real Time Buttons; F9- Edit Buttons;
F10-Display Buttons; F11-Last Render; F12-Render
TYPICAL VIEWS IN BLENDER:
The views that are present in blender are

Top view

Camera or perspective view

Front view

Right side view

CREATION OF OBJECTS:
There are many types of objects that can be created in blender. They may be
Plane- A simple two-dimensional shape ideal for grounds. Can be sub-divided and used with
proportional vertex editing to make nice hilly terrain.
Cube- Basic 3D shape. Nice object to start with to shape into rectangles and other shapes.
Circle- Wont display as a 3D object, but can be extruded and shaped.
UV Sphere- A sphere generated with rings and segments, like the latitude and longitude of the
earth.
Icosphere- A sphere generated with triangular shapes. Like Epcot Center.
Cylinder- Like a can, closed with a top and bottom.
The three main modifiers you can use to change an object (outside of edit mode) are moving it,
resizing (scaling) it or rotating it.
G key- move or grab
S key- sizing or scaling
R key- rotate

Ex.No.15

CREATING FRACTALS USING BLENDER

AIM:
To create a fractal image-DNA HELIX using Blender.
PROCEDURE:
1) Open blender from the location it is stored.

2) Switch to edit mode by choosing edit mode from the highlighted section on the image or press
TAB

3)Add a cylinder by choosing Add-> Mesh-> cylinder. The cylinder appears at the origin.

4) Scale it to the desired size by pressing the S key and press X and press SHIFT+Z to scale the
cylinder along x and z axis and drag the mouse until you obtain the desired size .

5) Now rotate the cylinder. Press the R button and press Y key to rotate along the Y axis and
type 90 and press ENTER.

6) Now translate the cylinder along the x axis by holding the mouse over the red line and
dragging it to a position as displayed below.

7) Now Right click on one of the vertices of the cube and press CTRL+L to select the entire
cube.

8) Press SHIFT+D to duplicate the cube and click on the screen. And translate the cube to the
position as in the below the image:

9) Now select the entire model by pressing the B key and the drag it to select model.

10) Now to position the cursor to the center press SHIFT+S and in the following pop up menu
select cursor to selected option:

This will move the cursor to the center of the model.

11)Switch back to OBJECT MODE by pressing the TAB key

12) To move the 3D cursor to the center press ALT+SHIFT+CRTL+C and choose Origin to 3D
cursor option:

13) To center the model to the center of the grid press Shift+S and choose cursor to center
option :

14) Now press ALT+S and choose selection to cursor option:

15) To provide a reference plane add an empty plane by choosing ADD-> EMPTY -> PLAIN
AXES:

16) Now select the entire model by right clicking it.

17) Here fractals are created using the ARRAY MODIFIER. To select the Array modifier click
on the WRENCH ICON as in the image below:

18) Select Add modifier and choose array.

19) Check off Relative offset and check Object offset and click on the empty space below and
from the pop up menu select Empty

20) Translate along the Y axis up by holding the blue line and dragging it up.

21) Rotate the top model by pressing Rand Z to rotate along z axis and rotate to a position as in
the image below:

22) Now Increasing the COUNT value in the array modifier panel will generate the helix.

23) FINAL IMAGE:

RESULT:
Thus the Fractal image-DNA HELIX was created and rendered successfully.