Wednesday 12 September 2012
OOAD
Object-oriented analysis and design (OOAD)
Objects and inheritance
Introduction:
Welcome to the world of object-oriented programming. You are about to embark on learning a method which is fun, elegant, easy to understand, powerful and comprehensive.
The intention of this course is to emphasise the fun as much, if not more, than the other characteristics. After all, what is the point of learning something to make life duller.
So if we sometimes see examples which appear off the wall, do not worry. There is a serious side to object-oriented systems too.
Object modelling is useful for designing computer systems, whether those systems are to be implemented in object-oriented languages or not.
Most designs are likely to need more than an object-oriented language, such as a database. Therefore, do not think that this is a wasted exercise if you cannot convince your manager to let you use C++, Smalltalk or whatever flavour of the month language is out there.
Object modelling also has a use outside of the design of computer systems. It is an excellent analysis method, and it can be used in business process reengineering, in social science research, or any complex environment where it is important to capture the structure and functionality of some world.
Why Design?
Even the most professional programmers feel the temptation to sit down and produce code at the earliest possible moment. Therein lie many of the ills of the software engineering industry. Design is a process which involves
• communication
• creativity
• negotiation
• agreement
It is a human process, to produce products for human consumption. Too often the communication, negotiation and agreement aspects are left out.
Object modelling provides a notation which is clear, consistent, and which can be used to communicate within a software development team, and with the clients and other third-parties which the team need to deal with.
Design methods
Traditionally systems were constructed using the waterfall method. This was based on the idea that clients would formally agree a requirements document. A design would then be put together, which would be further agreed. Then the system would be implemented, and then there would be an endless process of maintenance.
Modern ideas move away from this. Iterative methods are considered more appropriate for many system development approaches. This still follows the notion of analysis, design and implementation, but on a cyclical basis, where subsequent cycles build on earlier cycles. There are variants on this, and we will discuss later how to drive and control this process.
Objects
We begin at the beginning. The world is made of objects. Just open your eyes and ears. They are out there. Bank customers, students, cats, elephants, cars, balls of string, atoms, molecules, tubs of ice cream, Madonna, stars, bureaucrats, Robin Hood.
The world is built of objects. Objects are built of smaller objects, and so ad infinitum. Objects combine to make bigger objects. We already live in an object-oriented world.
The first thing an object analyst must do is to remove the scales from his or her eyes. Object modelling consists of looking for objects. Of course, there has to be some boundary. Even sitting at my desk I can see more objects than I could reasonably list. But that is where the beauty of object modelling comes in. It uses observation.
Objects can be described by their attributes and operations. Attributes are the changeable characteristics of an object. Cats have colour, size, weight and a preference for either Kit-E-Kat or Whiskers.
Operations are the things an object does or can have done to it. Cats can catch mice, eat, miaow, worm up to owners, and be stroked. In our notation we draw an object such as a cat like this.
The name is shown at the top. The attributes are listed underneath. The operations are listed below that. Actually, strictly speaking, this is a class diagram. But we will explain that later.
In an object model, all data is stored as attributes of some object. The attributes of an object are manipulated by the operations. The only way of getting at the attributes is through an operation. Attributes may sometimes be objects in their own right (more of that later).
In an object model, all functionality is defined by operations. Objects may use each others operations, but the only legal way one object can manipulate another object is through an operation. An operation may inform, say "mass of ball", or change the state of an object, say "throw ball".
Object modelling is about finding objects, their attributes and their operations, and tying them together in an object model. Nothing more. Here are some more objects:
Some of these objects may seem jokey, but they could reasonably be part of a system, be it a computer game or a multimedia story. Do not be constrained to be those dull systems that most software engineers drag out. Object modelling can be used to design lots of things.
By now you should be getting the idea that object modelling is, at its simplest level, very straightforward. The trick comes in knowing what objects are appropriate, and what their appropriate attributes and operations are. It is a question of focus. We will consider some ways of controlling focus later in the course.
How do objects relate to other concepts in design methods?
Remember entity-relationship models? SSADM, JSD and so on have a notion of entity. These are really objects. All we are doing in object modelling is relabelling entity modelling. However, we put the emphasis on capturing and grouping together both functions and data (operations and attributes in our terminology). That is the elegant simplicity of object modelling. We will look at object models later which look remarkably like entity-relationship models (because they are).
We will now look one powerful way of arranging objects - inheritance hierarchies.
Inheritance
Often we will find that there are objects which have something in common. It is then useful to create an abstract object which groups together the common features, and to use inheritance to define the original objects. For example, consider our two fairy story creatures:
Now we can see that they both have the same operations "arrive" and "meet". We can therefore create an abstract creature:
which has the common operations. We can then draw the original objects grouped under the abstract object as follows
By this device Red Riding Hood has also appetite, nose and teeth as operations. The latter two may be of relevance when she goes to charm the woodcutter, provided they are petite and pearly bright respectively.
Okay, so let's have some more practical examples for those of you who have to do real work. Firstly, the frighteningly dull student-lecturer example. You can do the same with the equally dull employee-customer example.
Inheritance can pass down an arbitrarily deep hierarchy. A slightly more complicated hierarchy is given below to describe objects which can be juggled.
The big deal about inheritance
Inheritance is considered good for the software re-use and for clarity of description.
Re-use
When new objects are created which are similar to other objects, they can have many of their attributes and operations ready defined. Let us suppose we now introduce Grandma into our fairystory hierarchy.
Here we get a Grandma who already had an appetite, nose and teeth and who can arrive and meet. Actually these are not in the normal scope of the fairy story, but the principle should be clear.
We might be writing a simple geometry program:
Now to add circles we simply put in another object under 2D shape.
So the circle object need not define the area and position attributes or the get area operation.
It is now possible to buy or obtain ready-built class hierarchies written in object-oriented languages which can be extended in this way to produce a new application.
Designing complex class hierarchies takes time and good design requires experience. But the basic principles outlined above, with some intuitive guidelines, are the basis for the design of good, re-usable designs.
Re-use can be viewed from two directions. Components can be re-used, which is a sort of bottom-up approach to re-use. Or designs can be re-used. Both elements are important in the production of re-usable software.
Objects and inheritance
Introduction:
Welcome to the world of object-oriented programming. You are about to embark on learning a method which is fun, elegant, easy to understand, powerful and comprehensive.
The intention of this course is to emphasise the fun as much, if not more, than the other characteristics. After all, what is the point of learning something to make life duller.
So if we sometimes see examples which appear off the wall, do not worry. There is a serious side to object-oriented systems too.
Object modelling is useful for designing computer systems, whether those systems are to be implemented in object-oriented languages or not.
Most designs are likely to need more than an object-oriented language, such as a database. Therefore, do not think that this is a wasted exercise if you cannot convince your manager to let you use C++, Smalltalk or whatever flavour of the month language is out there.
Object modelling also has a use outside of the design of computer systems. It is an excellent analysis method, and it can be used in business process reengineering, in social science research, or any complex environment where it is important to capture the structure and functionality of some world.
Why Design?
Even the most professional programmers feel the temptation to sit down and produce code at the earliest possible moment. Therein lie many of the ills of the software engineering industry. Design is a process which involves
• communication
• creativity
• negotiation
• agreement
It is a human process, to produce products for human consumption. Too often the communication, negotiation and agreement aspects are left out.
Object modelling provides a notation which is clear, consistent, and which can be used to communicate within a software development team, and with the clients and other third-parties which the team need to deal with.
Design methods
Traditionally systems were constructed using the waterfall method. This was based on the idea that clients would formally agree a requirements document. A design would then be put together, which would be further agreed. Then the system would be implemented, and then there would be an endless process of maintenance.
Modern ideas move away from this. Iterative methods are considered more appropriate for many system development approaches. This still follows the notion of analysis, design and implementation, but on a cyclical basis, where subsequent cycles build on earlier cycles. There are variants on this, and we will discuss later how to drive and control this process.
Objects
We begin at the beginning. The world is made of objects. Just open your eyes and ears. They are out there. Bank customers, students, cats, elephants, cars, balls of string, atoms, molecules, tubs of ice cream, Madonna, stars, bureaucrats, Robin Hood.
The world is built of objects. Objects are built of smaller objects, and so ad infinitum. Objects combine to make bigger objects. We already live in an object-oriented world.
The first thing an object analyst must do is to remove the scales from his or her eyes. Object modelling consists of looking for objects. Of course, there has to be some boundary. Even sitting at my desk I can see more objects than I could reasonably list. But that is where the beauty of object modelling comes in. It uses observation.
Objects can be described by their attributes and operations. Attributes are the changeable characteristics of an object. Cats have colour, size, weight and a preference for either Kit-E-Kat or Whiskers.
Operations are the things an object does or can have done to it. Cats can catch mice, eat, miaow, worm up to owners, and be stroked. In our notation we draw an object such as a cat like this.
The name is shown at the top. The attributes are listed underneath. The operations are listed below that. Actually, strictly speaking, this is a class diagram. But we will explain that later.
In an object model, all data is stored as attributes of some object. The attributes of an object are manipulated by the operations. The only way of getting at the attributes is through an operation. Attributes may sometimes be objects in their own right (more of that later).
In an object model, all functionality is defined by operations. Objects may use each others operations, but the only legal way one object can manipulate another object is through an operation. An operation may inform, say "mass of ball", or change the state of an object, say "throw ball".
Object modelling is about finding objects, their attributes and their operations, and tying them together in an object model. Nothing more. Here are some more objects:
Some of these objects may seem jokey, but they could reasonably be part of a system, be it a computer game or a multimedia story. Do not be constrained to be those dull systems that most software engineers drag out. Object modelling can be used to design lots of things.
By now you should be getting the idea that object modelling is, at its simplest level, very straightforward. The trick comes in knowing what objects are appropriate, and what their appropriate attributes and operations are. It is a question of focus. We will consider some ways of controlling focus later in the course.
How do objects relate to other concepts in design methods?
Remember entity-relationship models? SSADM, JSD and so on have a notion of entity. These are really objects. All we are doing in object modelling is relabelling entity modelling. However, we put the emphasis on capturing and grouping together both functions and data (operations and attributes in our terminology). That is the elegant simplicity of object modelling. We will look at object models later which look remarkably like entity-relationship models (because they are).
We will now look one powerful way of arranging objects - inheritance hierarchies.
Inheritance
Often we will find that there are objects which have something in common. It is then useful to create an abstract object which groups together the common features, and to use inheritance to define the original objects. For example, consider our two fairy story creatures:
Now we can see that they both have the same operations "arrive" and "meet". We can therefore create an abstract creature:
which has the common operations. We can then draw the original objects grouped under the abstract object as follows
By this device Red Riding Hood has also appetite, nose and teeth as operations. The latter two may be of relevance when she goes to charm the woodcutter, provided they are petite and pearly bright respectively.
Okay, so let's have some more practical examples for those of you who have to do real work. Firstly, the frighteningly dull student-lecturer example. You can do the same with the equally dull employee-customer example.
Inheritance can pass down an arbitrarily deep hierarchy. A slightly more complicated hierarchy is given below to describe objects which can be juggled.
The big deal about inheritance
Inheritance is considered good for the software re-use and for clarity of description.
Re-use
When new objects are created which are similar to other objects, they can have many of their attributes and operations ready defined. Let us suppose we now introduce Grandma into our fairystory hierarchy.
Here we get a Grandma who already had an appetite, nose and teeth and who can arrive and meet. Actually these are not in the normal scope of the fairy story, but the principle should be clear.
We might be writing a simple geometry program:
Now to add circles we simply put in another object under 2D shape.
So the circle object need not define the area and position attributes or the get area operation.
It is now possible to buy or obtain ready-built class hierarchies written in object-oriented languages which can be extended in this way to produce a new application.
Designing complex class hierarchies takes time and good design requires experience. But the basic principles outlined above, with some intuitive guidelines, are the basis for the design of good, re-usable designs.
Re-use can be viewed from two directions. Components can be re-used, which is a sort of bottom-up approach to re-use. Or designs can be re-used. Both elements are important in the production of re-usable software.
Friday 31 August 2012
Computer Graphics Lab manuals
LIST OF PROGRAMS
Ex.No | Title | Page No |
| 1 | Basic Shapes and Colors | 1 |
| 2 | Pattern creation using setfillstyle | 3 |
| 3 | Random Pattern Generation | 5 |
| 4 | Line Pattern Generation | 7 |
| 5 | Human Face Generation | 9 |
| 6 | 2D Transformation - Rectangle | 11 |
| 7 | 2D Transformation - Triangle | 15 |
| 8 | 2D Transformation – Shearing & Reflection | 21 |
| 9 | 3D Transformation – Cuboid | 26 |
| 10 | 3D Transformation – Rotation about axis | 31 |
| 11 | 2D Composite Transformation | 36 |
| 12 | 3D Composite Transformation | 40 |
| 13 | Visible Surface Detection | 45 |
| 14 | Image Enhancement | 57 |
| 15 | Image Transformation | 59 |
| 16 | Image Optimization | 61 |
| 17 | Editing tools | 63 |
Ex. No. 1
Basic Shapes and Colors
Aim:
To implement shape and color functions in the graphics.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Draw different shapes using graphics inbuilt functions such as circle(),
Ellipse(), rectangle(),outtextxy (), line(),drawpoly().
Step 4: Stop the process.
Source Code:
#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");
#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();
}
outtextxy(340, 460, "Polygon");
getch();
closegraph();
}
Output:
Ex. No. 2
Pattern creation using setfillstyle
Aim:
To create patterns using setfillstyle() in the graphics.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Draw different patterns using the graphics inbuilt function setfillstyle().
Step 4: Stop the process.
Source Code:
#include <graphics.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
void main()
{
int gd=DETECT,gm;
int s;
char *fname[] = { "EMPTY FILL","SOLID FILL","LINE FILL",
"LTSLASH FILL","SLASH FILL","BKSLASH FILL",
"LTBKSLASH FILL","HATCH FILL",
"XHATCH FILL","INTERLEAVE FILL",
"WIDE DOT FILL","CLOSE DOT FILL","USER FILL"
};
initgraph(&gd,&gm," ");
clrscr();
cleardevice();
for (s=0;s<13;s++)
{
setfillstyle(s,2);
setcolor(14);
rectangle(149,9+s*30,251,31+s*30);
bar(150,10+s*30,250,30+s*30);
outtextxy(255,20+s*30,fname[s]);
}
getch();
closegraph();
}
Output:
Empty fill
Solid fill
Close dot fill |
Wide dot fill
 |
Line fill
Back Slash fill
User fillEx. No. 3
Random Pattern Generation
Aim:
To create random patterns in the graphics using random() function.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Draw random patterns using the graphics inbuilt functions such as circle(), bar() and setfillstyle().
Step 4: Stop the process.
Source Code:
#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();
}
#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();
}
Output:
Ex. No. 4
Line Pattern Generation
Aim:
To generate line patterns in the graphics.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Draw line patterns using the graphics inbuilt functions setlinestyle ().
Step 4: Stop the process.
Source Code:
#include <graphics.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
void main()
{
int gd=DETECT,gm;
int s;
char *lname[]={"SOLID LINE","DOTTED LINE","CENTER LINE",
"DASHED LINE","USERBIT LINE"};
initgraph(&gd,&gm," ");
clrscr();
cleardevice();
printf("Line styles:");
for (s=0;s<5;s++)
{
setlinestyle(s,1,3);
line(100,30+s*50,250,250+s*50);
outtextxy(255,250+s*50,lname[s]);
}
getch();
closegraph();
}
Output:
Solid Line Dotted Line
Dashed Line
Userbit Line
Ex. No. 5
Human Face Generation
Aim:
To generate a human face in the graphics.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Draw human face using the graphics inbuilt functions.
Step 4: Stop the process.
Source Code:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\tc\bgi");
setcolor(GREEN);
setbkcolor(0);
/*-------------------CHIN------------------------*/
ellipse(298,244,160,380,60,80);
/*----------------- HAIR ------------------------*/
arc(300,219,400,140,80);
ellipse(355,190,270,438,10,28);
arc(359,188,169,265,30);
ellipse(288,190,180,360,40,20);
ellipse(239,193,96,370,8,25);
/*---------------Eye Brows-------------------------*/
arc(282,255,89,130,40);
arc(278,259,80,120,40);
arc(314,255,405,92,40);
arc(319,259,420,100,40);
line(310,215,310,220);
line(284,215,284,219);
/*-------------------Eyes--------------------------*/
setfillstyle(SOLID_FILL,WHITE);
ellipse(320,230,0,360,10,5);
ellipse(275,230,0,360,10,5);
fillellipse(320,230,10,5);
fillellipse(275,230,10,5);
setfillstyle(SOLID_FILL,BLACK);
ellipse(320,230,0,360,4,4);
ellipse(275,230,0,360,4,4);
fillellipse(320,230,5,5);
fillellipse(275,230,5,5);
/*------------------Nose----------------------*/
ellipse(280,220,270,0,10,40);
ellipse(315,220,180,270,10,40);
ellipse(285,260,100,285,8,7);
ellipse(310,260,255,70,8,7);
circle(320,230,2);
circle(275,230,2);
arc(297,257,228,689,15);
/*---------------------MOUTH--------------------*/
ellipse(298,290,0,360,30,7);
line(270,290,326,290);
/*----------------------Ears--------------------*/
ellipse(234,240,0,330,4,20);
ellipse(362,240,220,170,4,20);
getch();
closegraph();
restorecrtmode();
}
Output:
Ex. No. 6
2D Transformation - Rectangle
Aim:
To create a rectangle and apply 2D transformations like Scaling, Rotation and Translation.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Initialize the variables
Step 4: Enter the choice for transformation
Step 5: If choice = 2 translation (i.e.) changing the coordinates of the object is performed
x’ = x + tx
y’ = y + ty
Step 6 : If choice = 3 rotation (i.e.) rotating the angle of the object is performed
x’ = x*cosθ - y*sinθ
y’ = x*sinθ + y*cosθ
Step 7: If choice = 4 scaling (i.e.) resizing the object is performed
x’ = x * sx
y’ = y * sy
Step 8: Stop the process.
Source Code:
#include<process.h>
#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
int tx,ty,a;
float sx,sy,x1,y1,x2,y2,x3,y3,x,r,x4,y4;
void org()
{
line(150,200,300,200);
line(150,200,150,50);
line(150,50,300,50);
line(300,50,300,200);
}
void trans()
{
printf("Enter the position to be translated");
scanf("%d %d",&tx,&ty);
line(150+tx,200+ty,300+tx,200+ty);
line(150+tx,200+ty,150+tx,50+ty);
line(150+tx,50+ty,300+tx,50+ty);
line(300+tx,50+ty,300+tx,200+ty);
}
void scal()
{
printf("Enter the scaling factors");
scanf("%f %f",&sx,&sy);
line(150*sx,200*sy,300*sx,200*sy);
line(150*sx,200*sy,150*sx,50*sy);
line(150*sx,50*sy,300*sx,50*sy);
line(300*sx,50*sy,300*sx,200*sy);
}
void rot()
{
printf("Enter the angle");
scanf("%d",&a);
r=(a*3.14159/180.0);
x1=(150.0*cos(r))-(200.0*sin(r));
y1=(150.0*sin(r))+(200.0*cos(r));
x2=(300.0*cos(r))-(50.0*sin(r));
y2=(300.0*sin(r))+(50.0*cos(r));
x3=(150.0*cos(r))-(50.0*sin(r));
y3=(150.0*sin(r))+(50.0*cos(r));
x4=(300.0*cos(r))-(200.0*sin(r));
y4=(300.0*sin(r))+(200.0*cos(r));
line(x4,y4,x1,y1);
line(x3,y3,x1,y1);
line(x3,y3,x2,y2);
line(x4,y4,x2,y2);
}
void main()
{
int gd=DETECT,gm,c;
initgraph(&gd,&gm,"C:\turboc3\\bgi");
clrscr();
while(1)
{
clrscr();
cleardevice();
printf("\n 1.Original\n\n2.Translation\n\n3.Rotation\n\n4.Scaling\n\n5.Exit\n\n");
printf("Enter ur choice");
scanf("%d",&c);
switch(c)
{
case 1:
printf("Original\n");
org();
break;
case 2:
printf("Translation\n");
trans();
break;
case 3:
printf("Rotation\n");
rot();
break;
case 4:
printf("Scaling\n");
scal();
break;
case 5:
exit(1);
break;
default:
printf("Enter correct entries\n");
}
getch();
}}
Output:
1. Original
2. Translation
3. Rotation
4. Scaling
5. Exit
Enter your choice: 1
Original
 |
Enter your choice: 2
Before Translation After Translation
| |||
| |||
Enter your choice: 3
Before Rotation After Rotation
 | |||
| |||
Enter your choice: 4
Before Scaling After Scaling
 | |||
 | |||
Ex. No. 7
2D Transformation - Triangle
Aim:
To create a simple triangle and apply 2D transformations like Scaling, Rotation and Translation.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Declare a structure with necessary variables and functions
Step 4: Initialize the variables
Step 5: Enter the choice for transformation
Step 6: If choice = 1 scaling (i.e.) resizing the object is performed
x’ = x * sx
y’ = y * sy
Step 7 : If choice = 2 rotation (i.e.) rotating the angle of the object is performed
x’ = x*cosθ - y*sinθ
y’ = x*sinθ + y*cosθ
Step 8: If choice = 3 translation (i.e.) changing the coordinates of the object is performed
x’ = x + tx
y’ = y + ty
Step 9: Stop the process.
Source Code:
#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<graphics.h>
typedef float matrix[3][3];
matrix thematrix;
static struct wept
{
int x;
int y;
};
int k;
typedef struct wept wept2;
void main()
{
int s;
int gdriver=DETECT,gmode,ch,g;
int pts1[10],pts2[10],c;
void matrixsetidentity(matrix m);
void rotate(float a,wept2 refpt);
void matirxpremultiply(matrix a,matrix b);
void translate(int tx,int ty);
void scale(float sx,float sy,wept2 refpt);
void transformpoint(int npts,wept2 pts[]);
wept2 pts[6]={50.0,50.0,100.0,50.0,100.0,100.0};
wept2 refpt={100.0,100.0};
initgraph(&gdriver,&gmode,"c:\\tc\\bgi");
do
{
printf("1.Scale\n2.Rotate\n3.Translate");
printf("\nEnter the choice:");
scanf("%d",&ch);
cleardevice();
for(k=0,c=0;k<3;k++)
{
pts2[c]=pts[k].x;
c++;
pts2[c]=pts[k].y;
c++;
}
switch(ch)
{
case 1:
cleardevice();
outtextxy(100,15," Before scaling ");
fillpoly(3,pts2);
matrixsetidentity(thematrix);
getch();
cleardevice();
outtextxy(100,15,"After scaling ");
scale(2,1,refpt);
transformpoint(3,pts2);
fillpoly(3,pts2);
break;
case 2:
cleardevice();
outtextxy(100,15," Before Rotation ");
fillpoly(3,pts2);
matrixsetidentity(thematrix);
getch();
cleardevice();
outtextxy(100,15,"After Rotation ");
rotate(90.0,refpt);
transformpoint(3,pts2);
fillpoly(3,pts2);
break;
case 3:
cleardevice();
outtextxy(100,15," \nBefore translation ");
fillpoly(3,pts2);
outtextxy(75,50,"RE");
matrixsetidentity(thematrix);
getch();
cleardevice();
outtextxy(100,15,"\nAfter translation ");
translate(100,0);
transformpoint(3,pts2);
fillpoly(3,pts2);
break;
}
getch();
clrscr();
printf("\n To continue press 1 \n To exit press 0 ");
scanf("%d",&s);
}while(s);
}
void matrixsetidentity(matrix m)
{
int i,j;
matrix temp;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
m[i][j]=(i==j);
}
void matrixpremultiply(matrix a,matrix b)
{
int r,c;
matrix tmp;
for(r=0;r<3;r++)
for(c=0;c<3;c++)
tmp[r][c]=a[r][0]*b[0][c]+a[r][1]*b[1][c]+a[r][2]*b[2][c];
for(r=0;r<3;r++)
for(c=0;c<3;c++)
b[r][c]=tmp[r][c];
}
void translate(int tx,int ty)
{
matrix m;
matrixsetidentity(m);
m[0][2]=tx;
m[1][2]=ty;
matrixpremultiply(m,thematrix);
}
void scale(float sx,float sy,wept2 refpt)
{
matrix m;
matrixsetidentity(m);
m[0][0]=sx;
m[0][2]=(1-sx)*refpt.x;
m[1][1]=sy;
m[1][2]=(1-sy)*refpt.y;
matrixpremultiply(m,thematrix);
}
void rotate(float b,wept2 refpt)
{
matrix m;
float a;
matrixsetidentity(m);
a=3.1617/180*b;
m[0][0]=cos(a);
m[0][1]=-sin(a);
m[0][2]=refpt.x*(1-cos(a))+refpt.y*sin(a);
m[1][0]=sin(a);
m[1][1]=cos(a);
m[1][2]=refpt.x*(1-cos(a))-refpt.y*sin(a);
matrixpremultiply(m,thematrix);
}
void transformpoint(int npts,wept2 pts[])
{
int k;
float tmp;
for(k=0;k<npts;k++)
{
tmp=thematrix[0][0]*pts[k].x+thematrix[0][1]*pts[k].y+thematrix[0][2];
pts[k].y=thematrix[1][0]*pts[k].x+thematrix[1][1]*pts[k].y+thematrix[1][2];
pts[k].x=tmp;
}
}
Output:
1. Scale
2. Rotate
3. Translate
Enter your choice: 1
Before scaling After scaling  |
To continue press 1
Enter your choice:2
Before Rotation After Rotation
To continue press 1
Enter your choice:3
Before Translation After Translation
 |  | ||
Ex. No. 8
2D Transformation – Shearing & Reflection
Aim:
To create a simple object and apply 2D transformations like Scaling, Rotation, Translation,
Shearing and Reflection.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Initialize the variables
Step 4: Enter the choice for transformation
Step 5: If choice = 1 translation (i.e.) changing the coordinates of the object is performed
x’ = x + tx
y’ = y + ty
Step 6 : If choice = 2 scaling (i.e.) resizing the object is performed
x’ = x * sx
y’ = y * sy
Step 7: If choice = 3 rotation (i.e.) rotating the angle of the object is performed
x’ = x*cosθ - y*sinθ
y’ = x*sinθ + y*cosθ
Step 8: If choice = 4 shearing (i.e.) distortion of the object is performed
x’ = x + sh*y1;
y’ = y;
Step 9: If choice = 5 reflection (i.e.) mirror image of the object is generated
Step 10: Stop the process.
Source Code:
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<graphics.h>
int x1,y1,x2,y2;
void translation()
{
int tx,ty,xn1,xn2,yn1,yn2;
printf("Enter the Translation Vector:");
scanf("%d\n%d",&tx,&ty);
cleardevice();
outtextxy(400,100,"TRANSLATION");
xn1=x1+tx;
yn1=y1+ty;
xn2=x2+tx;
yn2=y2+ty;
line(x1,y1,x2,y2);
line(xn1,yn1,xn2,yn2);
getch();
}
void scaling()
{
int xn1,yn1,xn2,yn2;
float sx,sy;
printf("Enter the Sacling Factor:");
scanf("%f\n%f",&sx,&sy);
cleardevice();
outtextxy(300,200,"SCALING");
xn1=x1*sx;
yn1=y1*sy;
xn2=x2*sx;
yn2=y2*sy;
line(x1,y1,x2,y2);
line(xn1,yn1,xn2,yn2);
getch();
}
void rotation()
{
int r;
float rx,xn1,yn1,xn2,yn2;
printf("Enter the Angle for Rotation:");
scanf("%d",&r);
cleardevice();
outtextxy(500,200,"ROTATION");
rx=(r*3.14)/180;
xn1=x1*cos(rx)-y1*sin(rx);
yn1=y1*cos(rx)+x1*sin(rx);
xn2=x2*cos(rx)-y2*sin(rx);
yn2=y2*cos(rx)+x2*sin(rx);
line(x1,y1,x2,y2);
line(xn1,yn1,xn2,yn2);
getch();
}
void shearing()
{
int sh;
float xn1,yn1,xn2,yn2;
printf("Enter the value of Shearing");
scanf("%d",&sh);
cleardevice();
outtextxy(500,100,"SHEARING");
xn1=x1+sh*y1;
yn1=y1;
xn2=x2+sh*y2;
yn2=y2;
line(x1,y1,x2,y2);
line(xn1,yn1,xn2,yn2);
getch();
}
void reflection()
{
int xn1,yn1,xn2,yn2;
cleardevice();
outtextxy(300,100,"REFLECTION");
if((x1<y1)^(x2<y2))
{
xn1=x1+50;
xn2=x2+50;
yn1=y1;
yn2=y2;
}
else
{
xn1=x1;
xn2=x2;
yn1=y1+50;
yn2=y2+50;
}
line(x1,y1,x2,y2);
line(xn1,yn1,xn2,yn2);
getch();
}
void get()
{
int xn1,yn1,xn2,yn2;
printf("Enter the Co-ordinates x1,y1,x2,y2:");
scanf("%d\n%d\n%d\n%d\n",&x1,&y1,&x2,&y2);
cleardevice();
outtextxy(200,100,"ORIGINAL OBJECT");
line(x1,y1,x2,y2);
line(xn1,yn1,xn2,yn2);
getch();
}
void main()
{
int ch,gd=DETECT,gm;
initgraph(&gd,&gm,"C:/tc/bgi");
get();
do
{
cleardevice();
outtextxy(10,10,"1.Translation");
outtextxy(10,20,"2.Scaling");
outtextxy(10,30,"3.Rotation");
outtextxy(10,40,"4.Shearing");
outtextxy(10,50,"5.Reflection");
outtextxy(10,60,"6.Exit");
outtextxy(10,70,"Enter Your Choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
{
translation();
break;
}
case 2:
{
scaling();
break;
}
case 3:
{
rotation();
break;
}
case 4:
{
shearing();
break;
}
case 5:
{
reflection();
break;
}
case 6:
{
exit(0);
break;
}
}
}
while(ch<6);
}
Output:
1. Translation
2. Scaling
3. Rotate
4. Shearing
5. Reflection
6. Exit
Enter your choice: 4
SHEARING
 |
Enter your choice: 5
REFLECTION
Ex. No. 9
3D Transformation - Cuboid
Aim:
To create a cuboid and apply 3D transformations like Scaling, Rotation and Translation.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Initialize the variables
Step 4: Enter the choice for transformation
Step 5: If choice = 2 translation (i.e.) changing the coordinates of the object is performed
x’ = x + tx
y’ = y + ty
z’ = z + tz
Step 6 : If choice = 3 rotation (i.e.) rotating the angle of the object is performed
y’ = y*cosθ - z*sinθ
z’ = y*sinθ + z*cosθ
x’ = x
Step 7: If choice = 4 scaling (i.e.) resizing the object is performed
x’ = x * sx
y’ = y * sy
z’ = z * sz
Step 8: Stop the process.
Source Code:
#include<process.h>
#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
int tx,ty,a;
float sx,sy,x1,y1,x2,y2,x3,y3,x,r,x4,y4,x5,y5,x6,y6,x7,y7,x8,y8;
void org()
{
line(150,200,230,200);
line(150,200,150,120);
line(150,120,230,120);
line(230,120,230,200);
line(210,150,290,150);
line(210,150,210,70);
line(210,70,290,70);
line(290,70,290,150);
line(150,120,210,70);
line(230,200,290,150);
line(150,200,210,150);
line(230,120,290,70);
}
void trans()
{
printf("Enter the position to be translated");
scanf("%d %d" ,&tx,&ty);
line(150+tx,200+ty,230+tx,200+ty);
line(150+tx,200+ty,150+tx,120+ty);
line(150+tx,120+ty,230+tx,120+ty);
line(230+tx,120+ty,230+tx,200+ty);
line(210+tx,150+ty,290+tx,150+ty);
line(210+tx,150+ty,210+tx,70+ty);
line(210+tx,70+ty,290+tx,70+ty);
line(290+tx,70+ty,290+tx,150+ty);
line(150+tx,120+ty,210+tx,70+ty);
line(230+tx,200+ty,290+tx,150+ty);
line(150+tx,200+ty,210+tx,150+ty);
line(230+tx,120+ty,290+tx,70+ty);
}
void scal()
{
printf("Enter the scaling factors");
scanf("%f %f",&sx,&sy);
line(150*sx,200*sy,230*sx,200*sy);
line(150*sx,200*sy,150*sx,120*sy);
line(150*sx,120*sy,230*sx,120*sy);
line(230*sx,120*sy,230*sx,200*sy);
line(210*sx,150*sy,290*sx,150*sy);
line(210*sx,150*sy,210*sx,70*sy);
line(210*sx,70*sy,290*sx,70*sy);
line(290*sx,70*sy,290*sx,150*sy);
line(150*sx,120*sy,210*sx,70*sy);
line(230*sx,200*sy,290*sx,150*sy);
line(150*sx,200*sy,210*sx,150*sy);
line(230*sx,120*sy,290*sx,70*sy);
}
void rot()
{
printf("Enter the angle");
scanf("%d",&a);
r=(a*3.14159/180.0);
x1=(150.0*cos(r))-(200.0*sin(r));
y1=(150.0*sin(r))+(200.0*cos(r));
x2=(230.0*cos(r))-(200.0*sin(r));
y2=(230.0*sin(r))+(200.0*cos(r));
x3=(150.0*cos(r))-(120.0*sin(r));
y3=(150.0*sin(r))+(120.0*cos(r));
x4=(230.0*cos(r))-(120.0*sin(r));
y4=(230.0*sin(r))+(120.0*cos(r));
x5=(210.0*cos(r))-(150.0*sin(r));
y5=(210.0*sin(r))+(150.0*cos(r));
x6=(210.0*cos(r))-(70.0*sin(r));
y6=(210.0*sin(r))+(70.0*cos(r));
x7=(290.0*cos(r))-(70.0*sin(r));
y7=(290.0*sin(r))+(70.0*cos(r));
x8=(290.0*cos(r))-(150.0*sin(r));
y8=(290.0*sin(r))+(150.0*cos(r));
line(x1,y1,x2,y2);
line(x1,y1,x3,y3);
line(x3,y3,x4,y4);
line(x4,y4,x2,y2);
line(x5,y5,x8,y8);
line(x5,y5,x6,y6);
line(x6,y6,x7,y7);
line(x7,y7,x8,y8);
line(x3,y3,x6,y6);
line(x2,y2,x8,y8);
line(x1,y1,x5,y5);
line(x4,y4,x7,y7);
}
void main()
{
int gd=DETECT,gm,c;
initgraph(&gd,&gm,"C:\turboc3\\bgi");
clrscr();
while(1)
{
clrscr();
cleardevice();
printf("\n 1.Original\n\n2.Translation\n\n3.Rotation\n\n4.Scaling\n\n
5.Exit\n\n");
printf("Enter ur choice");
scanf("%d",&c);
switch(c)
{
case 1:
printf("Original\n");
org();
break;
case 2:
printf("Translation\n");
trans();
break;
case 3:
printf("Rotation\n");
rot();
break;
case 4:
printf("Scaling\n");
scal();
break;
case 5:
exit(1);
break;
default:
printf("Enter correct entries\n");
}
getch();
}
}
Output:
1. Original
2. Translation
3. Rotation
4. Scaling
5. Exit
Enter your choice: 1
Original
 |
Enter your choice: 2
Before Translation After Translation
 | |||
| |||
Enter your choice: 3
Before Rotation After Rotation
|
Enter your choice: 4
Before Scaling After Scaling
 |  | ||
Ex. No. 10
Aim:
To create a cube and apply 3D transformations like Scaling, Rotation about axis
and Translation.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Initialize the variables
Step 4: Enter the choice for transformation
Step 5: If choice = 2 translation (i.e.) changing the coordinates of the object is performed
x’ = x + tx
y’ = y + ty
z’ = z + tz
Step 6 : If choice = 3 rotation (i.e.) rotating the angle of the object is performed
About X-axis y’ = y*cosθ - z*sinθ
z’ = y*sinθ + z*cosθ
x’ = x
About Y-axis z’ = z*cosθ - x*sinθ
x’ = z*sinθ + x*cosθ
y’ = y
About Z-axis x’ = x*cosθ - y*sinθ
y’ = x*sinθ + y*cosθ
z’ = z
Step 7: If choice = 4 scaling (i.e.) resizing the object is performed
x’ = x * sx
y’ = y * sy
z’ = z * sz
Step 8: Stop the process.
Source Code:
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
int maxx,maxy,midx,midy;
void axis()
{
getch();
cleardevice();
line(midx,0,midx,maxy);
line(0,midy,maxx,midy);
}
void main()
{
int gd,gm,x,y,z,o,x1,x2,y1,y2;
detectgraph(&gd,&gm);
initgraph(&gd,&gm,"..//bgi");
setfillstyle(0,getmaxcolor());
maxx=getmaxx();
maxy=getmaxy();
midx=maxx/2;
midy=maxy/2;
axis();
bar3d(midx+50,midy-100,midx+60,midy-90,5,1);
printf("Enter translation factor ");
scanf("%d%d",&x,&y);
axis();
printf("After translation:");
bar3d(midx+x+50,midy-(y+100),midx+x+60,midy-(y+90),5,1);
axis();
bar3d(midx+50,midy-100,midx+60,midy-90,5,1);
printf("Enter scaling factors");
scanf("%d%d%d", &x,&y,&z);
axis();
printf("After scaling ");
bar3d(midx+(x*50),midy-(y*100),midx+(x*60),midy-(y*90),5*z,1);
axis();
bar3d(midx+50,midy-100,midx+60,midy-90,5,1);
printf("Enter rotating angle" );
scanf("%d",&o);
x1=50*cos(o*3.14/180)-100*sin(o*3.14/180);
y1=50*sin(o*3.14/180)+100*cos(o*3.14/180);
x2=60*cos(o*3.14/180)-90*sin(o*3.14/180);
y2=60*sin(o*3.14/180)+90*cos(o*3.14/180);
axis();
printf("After rotation about z axis" );
bar3d(midx+x1,midy-y1,midx+x2,midy-y2,5,1);
axis();
printf("After rotation about x axis ");
bar3d(midx+50,midy-x1,midx+60,midy-x2,5,1);
axis();
printf("After rotation about yaxis");
bar3d(midx+x1,midy-100,midx+x2,midy-90,5,1);
getch();
closegraph();
}
Output:
Enter Translation Factor: 50 70 After Translation:
 | |  | |||
Enter Scaling Factor: 2 2 2 After Scaling:
|
Enter Rotating Angle: 45 After Rotation about Z axis  |
After Rotation about X axis After Rotation about Y axis
 | |
Ex. No. 11
2D Composite Transformation
Aim:
To create a triangle and apply 2D composite transformations like Scaling, Rotation and Translation.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Initialize the variables
Step 4: Enter the choice for transformation
Step 5: If choice = 1 two successive translation & rotation are performed
Step 6 : If choice = 2 two successive translation & scaling are performed
Step 7: If choice = 3 two successive scaling and rotation are performed
Step 8: Stop the process.
Source Code:
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h>
#include<graphics.h>
float tx,ty,sx,sy,r;
float x[15][15],y[15][15];
int i,j=2,choice;
void transform();
void rotate();
void scale();
void transform()
{
x[i][j-1]=x[i][j-1]+tx;
x[i][j]=x[i][j]+tx;
y[i][j-1]=y[i][j-1]+ty;
y[i][j]=y[i][j]+ty;
}
void rotate()
{
x[i][j-1]=(x[i][j-1]*cos(r))-(y[i][j-1]*sin(r));
y[i][j-1]=(x[i][j-1]*sin(r))+(y[i][j-1]*cos(r));
x[i][j]=(x[i][j]*cos(r))-(y[i][j]*sin(r));
y[i][j]=(x[i][j]*sin(r))+(y[i][j]*cos(r));
}
void scale()
{
x[i][j-1]=x[i][j-1]*sx;
x[i][j]=x[i][j]*sx;
y[i][j-1]=y[i][j-1]*sy;
y[i][j]=y[i][j]*sy;
}
int main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc\\bgi");
x[1][1]=100,x[1][2]=200,y[1][1]=200,y[1][2]=300;
x[2][1]=200,x[2][2]=200,y[2][1]=300,y[2][2]=200;
x[3][1]=100,x[3][2]=200,y[3][1]=200,y[3][2]=200;
textattr(0);
for(i=1;i<=3;i++)
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
while(choice!=4)
{
printf("2D COMPOSITE");
printf("\n1.Translation & Rotation");
printf("\n2. Translation & Scaling");
printf("\n3.Scaling & Rotation");
printf("\n4.exit");
printf("\nEnter your choice:");
scanf("%d",&choice);
switch(choice)
{
case 1:
printf("\nEnter X & Y vector:");
scanf("%f%f",&tx,&ty);
printf("\nEnter Rotation Angle:");
scanf("%f",&r);
clrscr();
r=(r*3.14/180);
for(i=1;i<=3;i++)
{
transform();
rotate();
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
delay(500);
}
break;
case 2:
printf("\nEnter X & Y vector:");
scanf("%f%f",&tx,&ty);
printf("\nEnter X & Y vector:");
scanf("%f%f",&sx,&sy);
clrscr();
for(i=1;i<=3;i++)
{
transform();
scale();
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
delay(500);
}
break;
case 3:
printf("\nEnter X & Y vector:");
scanf("%f%f",&sx,&sy);
printf("\nEnter Rotation Angle:");
scanf("%f",&r);
clrscr();
r=(r*3.14/180);
for(i=1;i<=3;i++)
{
scale();
rotate();
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
delay(500);
}
break;
case 4:
exit(0);
}
}
getch();
return 0;
}
Output:
2D Composite Transformation
1.Translation & Rotation
2.Translation & Scaling
3.Scaling & Rotation
4.Exit
 |
Original
 |
Enter your choice: 1
Enter the X & Y vector: 100 100
Enter the rotation angle: 45
Enter your choice: 2Enter the X & Y vector: 100 100
Enter the X & Y vector: 2 2
Enter your choice: 3Enter the X & Y vector: 2 2
Enter the rotation angle: 45 Ex. No. 12
3D Composite Transformation
Aim:
To create a cube and apply 3D composite transformations like Scaling, Rotation and Translation.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Initialize the variables
Step 4: Enter the choice for transformation
Step 5: If choice = 1 two successive translation & rotation are performed
Step 6 : If choice = 2 two successive translation & scaling are performed
Step 7: If choice = 3 two successive scaling and rotation are performed
Step 8: Stop the process.
Source Code:
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h>
#include<graphics.h>
float tx,ty,tz,sx,sy,sz,r;
float x[15][15],y[15][15],z[15][15];
int i,j=2,choice;
void transform();
void rotate();
void scale();
void transform()
{
x[i][j-1]=x[i][j-1]+tx;
x[i][j]=x[i][j]+tx;
y[i][j-1]=y[i][j-1]+ty;
y[i][j]=y[i][j]+ty;
z[i][j-1]=z[i][j-1]+tz;
z[i][j]=z[i][j]+tz;
}
void rotate()
{
if(i<=8)
{
x[i][j-1]=(x[i][j-1]*cos(r))-(y[i][j-1]*sin(r));
y[i][j-1]=(x[i][j-1]*sin(r))+(y[i][j-1]*cos(r));
x[i][j]=(x[i][j]*cos(r))-(y[i][j]*sin(r));
y[i][j]=(x[i][j]*sin(r))+(y[i][j]*cos(r));
}
else
{
z[i][j-1]=(z[i][j-1]*cos(r))-(y[i][j-1]*sin(r));
y[i][j-1]=(z[i][j-1]*sin(r))+(y[i][j-1]*cos(r));
z[i][j]=(z[i][j]*cos(r))-(y[i][j]*sin(r));
y[i][j]=(z[i][j]*sin(r))+(y[i][j]*cos(r));
}
}
void scale()
{
x[i][j-1]=x[i][j-1]*sx;
x[i][j]=x[i][j]*sx;
y[i][j-1]=y[i][j-1]*sy;
y[i][j]=y[i][j]*sy;
z[i][j-1]=z[i][j-1]*sz;
z[i][j]=z[i][j]*sz;
}
int main(void)
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc\\bgi");
x[1][1]=200,x[1][2]=250,y[1][1]=200,y[1][2]=200;
x[2][1]=200,x[2][2]=200,y[2][1]=200,y[2][2]=150;
x[3][1]=200,x[3][2]=250,y[3][1]=150,y[3][2]=150;
x[4][1]=250,x[4][2]=250,y[4][1]=150,y[4][2]=200;
x[5][1]=220,x[5][2]=270,y[5][1]=140,y[5][2]=140;
x[6][1]=270,x[6][2]=270,y[6][1]=140,y[6][2]=190;
x[7][1]=220,x[7][2]=220,y[7][1]=140,y[7][2]=190;
x[8][1]=220,x[8][2]=270,y[8][1]=190,y[8][2]=190;
z[9][1]=200,z[9][2]=220,y[9][1]=150,y[9][2]=140;
z[10][1]=250,z[10][2]=270,y[10][1]=150,y[10][2]=140;
z[11][1]=250,z[11][2]=270,y[11][1]=200,y[11][2]=190;
z[12][1]=220,z[12][2]=200,y[12][1]=190,y[12][2]=200;
textattr(0);
for(i=1;i<=12;i++)
{
if(i<=8)
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
else
line(z[i][j-1],y[i][j-1],z[i][j],y[i][j]);
}
while(choice!=4)
{
printf("3D COMPOSITE");
printf("\n1.Translation & Rotation");
printf("\n2. Translation & Scaling");
printf("\n3.Scaling & Rotation");
printf("\n4.Exit");
printf("\nEnter your choice:");
scanf("%d",&choice);
switch(choice)
{
case 1:
printf("\nEnter X,Y & Z vector:");
scanf("%f%f%f",&tx,&ty,&tz);
printf("\nEnter Rotation Angle:");
scanf("%f",&r);
clrscr();
r=(r*3.14/180);
for(i=1;i<=12;i++)
{
transform();
rotate();
if(i<=8)
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
else
line(z[i][j-1],y[i][j-1],z[i][j],y[i][j]);
delay(200);
}
break;
case 2:
printf("\nEnter X,Y & Z vector:");
scanf("%f%f%f",&tx,&ty,&tz);
printf("\nEnter X,Y & Z vector:");
scanf("%f%f%f",&sx,&sy,&sz);
clrscr();
for(i=1;i<=12;i++)
{
transform();
scale();
if(i<=8)
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
else
line(z[i][j-1],y[i][j-1],z[i][j],y[i][j]);
delay(200);
}
break;
case 3:
printf("\nEnter X,Y & Z vector:");
scanf("%f%f%f",&sx,&sy,&sz);
printf("\nEnter Rotation Angle:");
scanf("%f",&r);
clrscr();
r=(r*3.14/180);
for(i=1;i<=12;i++)
{
scale();
rotate();
if(i<=8)
line(x[i][j-1],y[i][j-1],x[i][j],y[i][j]);
else
line(z[i][j-1],y[i][j-1],z[i][j],y[i][j]);
delay(200);
}
break;
case 4:
exit(0);
}
}
getch();
return 0;
}
Output:
3D Composite Transformation
1. Translation & Rotation:
2. Translation & Scaling :3. Scaling & Rotation:
4. Exit
Enter Your Choice: 1
Enter X,Y & Z vector: 80 80 80
Enter Rotation Angle: 120 |
Enter Your Choice: 2
Enter X,Y & Z vector: 100 100 100 |
Enter X,Y & Z vector: 2 2 2
 |
Enter Your Choice: 3
Enter X,Y & Z vector: 2 2 2
 |
Enter Rotation Angle: 60
Ex. No. 13
Visible Surface Detection
Aim:
To create a pyramid structure as wire frame display and detect visible surfaces.
Algorithm:
Step 1: Include the graphics header file
Step 2: Initialize graphics using initgraph()
Step 3: Initialize the variables
Step 4: Enter the choice for detection.
Step 5: Draw a wire frame pyramid structure using line() function.
Step 6 : Use scan line method to detect points to be removed.
Step 7: calculate end points x1,y1,x2,y2,x3,y3 to detect all points visible from wire frame pyramid
Step 8: Display visible surface using line() function.
Step 9: Stop the process.
Source Code:
#include<stdio.h>
#include<iostream.h>
#include<dos.h>
#include<process.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
void render(float,float,float, float,float,float,float,float,float,float,float,float);
void initialize(void);
void firstpage(void);
void call_first(void);
float intensity,alpha,thita,tempy,tempz,tempx;
char ch='4';
char ch1='1';
char ch2='1';
int pts1[5][3];
float tx,ty,tz,d=.5;
void assign(float,float,float,float,float,float,float,float,float);
void scan_line(float,float,float,float,float,float,float,float,float);
void drawpyramid(float,float,float,float,float,float);
void call_assign(void);
void display(void);
void tranform(void);
void draw(void);
void drawscale(void);
float pts[5][3]={-100,0,0, 0,0,45, 100,0,0, 0,0,-45, 0,130,0};
float pts2[5][3]={228,273,0, 305,295,0, 428,273,0, 350,250,0
,328,143,0};
float pt[5][3]={-100,0,0, 0,0,45,100,0,0,0,0-45,0,130,0};
void main()
{
int i;
float sx,sy,sz=1;
struct palettetype pal;
int gd,gm;
detectgraph(&gd,&gm);
initgraph(&gd,&gm,"c:\\tc\\bgi");
getpalette(&pal);
firstpage();
for(i=16;i>0;i--)
setrgbpalette(pal.colors[i],0,4*i,0);
L1: display();
while(ch1!='4')
{
ch='2';
L2: call_assign();
clearviewport();
gotoxy(1,2);
cout<<"1. Translation";
cout<<"2. Rotation";
cout<<"3. Scaling ";
cout<<"4. Back ";
ch1=getch();
if(ch1=='4')
{
clearviewport();
goto L1;
}
if(ch1=='1')
{
clearviewport();
while(ch1!='4')
{
gotoxy(2,2);
cout<<"a. X+"; cout<<" b. X-";
cout<<" c. Y+"; cout<<" d. Y- ";
cout<<" e. Z+"; cout<<" f. Z-";
cout<<" g. Back";
call_assign();
ch1=getch();
clearviewport();
if(ch1=='g')
goto L2;
if(ch1=='a')
tx=5;
if(ch1=='b')
tx=-5;
if(ch1=='c')
ty=5;
if(ch1=='d')
ty=-5;
if(ch1=='e')
tz=10;
if(ch1=='f')
tz=-10;
for(i=0;i<5;i++)
{
pts[i][0]+=tx;
pts[i][1]+=ty;
pts[i][1]+=tz;
}
}
}
if(ch1=='3')
{
clearviewport();
cout<<"Enter sx:";
cin>>sx;
cout<<"Enter sy:";
cin>>sy;
for(i=0;i<5;i++)
{
pts2[i][0]=abs(pts2[i][0]*sx+200*(1-sx));
pts2[i][1]=abs(pts2[i][1]*sy+200*(1-sy)); }
drawscale();
getch();
}
if(ch1=='2')
{
while(ch2!='4')
{
clearviewport();
gotoxy(1,2);
cout<<"1.X-axis rotation";
gotoxy(1,3);
cout<<"2.Y-axis rotation";
gotoxy(1,4);
cout<<"3.Z-axis rotation";
gotoxy(1,5);
cout<<"4.Back";
ch2=getch();
if(ch2=='4')
break;
if(ch2=='1')
{
alpha=0;
while(alpha<360)
{
alpha=alpha+10;
thita=(alpha*3.142)/180;
initialize();
for(i=0;i<5;i++)
{
tempy=(pts1[i][1]*cos(thita)+pts1[i][2]*sin(thita));
pts1[i][2]=(pts1[i][1]*sin(thita)-pts1[i][2]*cos(thita));
pts1[i][1]=tempy;
}
clearviewport();
draw();
delay(100);
}
}
if(ch2=='2')
{
alpha=0;
while(alpha<360)
{
alpha=alpha+10;
thita=(alpha*3.142)/180;
initialize();
for(i=0;i<5;i++)
{
tempz=(pts1[i][2]*cos(thita)+pts1[i][0]*sin(thita));
pts1[i][0]=(pts1[i][2]*sin(thita)-pts1[i][0]*cos(thita));
pts1[i][2]=tempz;
}
clearviewport();
draw();
delay(100);
}
}
if(ch2=='3')
{
alpha=0;
while(alpha<360)
{
alpha=alpha+10;
thita=(alpha*3.142)/180;
initialize();
for(i=0;i<5;i++)
{
tempx=(pts1[i][0]*cos(thita)-pts1[i][1]*sin(thita));
pts1[i][1]=(pts1[i][0]*sin(thita)+pts1[i][1]*cos(thita));
pts1[i][0]=tempx;
}
clearviewport();
draw();
delay(100);
clearviewport();
draw();
}
}
}
}
}
closegraph();
restorecrtmode();
}
void initialize()
{
pts1[0][0]=-100;
pts1[0][1]=-65;
pts1[0][2]=0;
pts1[1][0]=0;
pts1[1][1]=-65;
pts1[1][2]=-45;
pts1[2][0]=100;
pts1[2][1]=-65;
pts1[2][2]=0;
pts1[3][0]=0;
pts1[3][1]=-65;
pts1[3][2]=45;
pts1[4][0]=0;
pts1[4][1]=65;
pts1[4][2]=0;
}
void firstpage()
{
clearviewport();
setcolor(WHITE);
rectangle(300,120,580,320);
rectangle(295,115,585,325);
setcolor(6);
settextstyle(4,HORIZ_DIR,3);
outtextxy(50,100, "OPTIONS");
settextstyle(3,HORIZ_DIR,1);
setcolor(11);
outtextxy(20,150,"1. VISIBLE SURFACE DETECTION");
outtextxy(20,190,"2. SURFACE RENDERING");
outtextxy(20,230,"3. TRANSFORMATIONS");
outtextxy(20,270,"4. WIREFRAME DISPLAY");
outtextxy(20,310,"5. EXIT");
settextstyle(2,HORIZ_DIR,4);
outtextxy(400,370,"welcome to");
setcolor(YELLOW);
outtextxy(410,385,"VSD MAGIC");
call_first();
//display();
setcolor(WHITE);
getch();
cleardevice();
clearviewport();
}
void display(void)
{ while(ch!='3')
{ clearviewport();
gotoxy(2,2);
cout<<"1. Visible Surface Detection ";
gotoxy(2,3);
cout<<"2. Surface Rendering";
gotoxy(2,4);
cout<<"3. Transformations";
gotoxy(2,5);
cout<<"4. Wireframe Display";
gotoxy(2,6);
cout<<"5. Exit ";
call_assign();
ch=getch();
if(ch=='5')
exit(0);
clearviewport();
if(ch=='3')
break;
}
}
void call_assign(void)
{
assign(pts[0][0],pts[0][1],pts[0][2],pts[1][0],pts[1][1],pts[1][2],pts[4][0],pts[4][1],pts[4][2]);
assign(pts[1][0],pts[1][1],pts[1][2],pts[2][0],pts[2][1],pts[2][2],pts[4][0],pts[4][1],pts[4][2]);
assign(pts[2][0],pts[2][1],pts[2][2],pts[3][0],pts[3][1],pts[3][2],pts[4][0],pts[4][1],pts[4][2]);
assign(pts[0][0],pts[0][1],pts[0][2],pts[4][0],pts[4][1],pts[4][2],pts[3][0],pts[3][1],pts[3][2]);
}
void call_first(void)
{
assign(pt[0][0],pt[0][1],pt[0][2],pt[1][0],pt[1][1],pt[1][2],pt[4][0],pt[4][1],pt[4][2]);
assign(pt[1][0],pt[1][1],pt[1][2],pt[2][0],pt[2][1],pt[2][2],pt[4][0],pt[4
][1],pt[4][2]);
assign(pt[2][0],pt[2][1],pt[2][2],pt[3][0],pt[3][1],pt[3][2],pt[4][0],pt[4][1],pt[4][2]);
assign(pt[0][0],pt[0][1],pt[0][2],pt[4][0],pt[4][1],pt[4][2],pt[3][0],pt[3][1],pt[3][2]);
}
void drawpyramid(float x1,float y1,float x2,float y2,float x3,float y3)
{
line(x1,y1,x2,y2);
line(x2,y2,x3,y3);
line(x3,y3,x1,y1);
}
void assign(float x1,float y1,float z1,float x2,float y2,float z2,float
x3,float y3,float z3)
{
float A,B,C;
float temp,An,Bn,Cn,X,Y,Z;
float Xl=-6,Yl=10,Zl=50;
float templ;
A=y1*(z2-z3)+y2*(z3-z1)+y3*(z1-z2);
B=z1*(x2-x3)+z2*(x3-x1)+z3*(x1-x2);
C=x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2);
temp=sqrt(A*A+B*B+C*C);
templ=sqrt(Xl*Xl+Yl*Yl+Zl*Zl);
X=(float)Xl/templ; Y=(float)Yl/templ; Z=(float)Zl/templ;
An=(A/temp); Bn=(float)B/temp; Cn=(float)C/temp;
intensity=15*(An*X+Bn*Y+Cn*Z);
if (intensity<0)
intensity=0;
if (intensity>15)
intensity=15;
z1=55-z1;
x1=x1+300+(d*z1); y1=300-y1-(d*z1);
z2=55-z2;
x2=x2+300+(d*z2); y2=300-y2-(d*z2);
z3=55-z3;
x3=x3+300+(d*z3); y3=300-y3-(d*z3);
if(ch=='1')
{ if(intensity==0) return;
drawpyramid(x1,y1,x2,y2,x3,y3);
return;
}
if(ch=='3')
exit(0);
if(ch=='4')
drawpyramid(x1,y1,x2,y2,x3,y3);
if(ch=='2')
{
if(intensity==0) return;
if ((y1>y2) && (y1>y3) && (y2>y3))
scan_line(x1,y1,z1,x2,y2,z2,x3,y3,z3);
if ((y1>y2) && (y1>y3) && (y3>y2))
scan_line(x1,y1,z1,x3,y3,z3,x2,y2,z2);
if ((y2>y1) && (y2>y3) && (y1>y3))
scan_line(x2,y2,z2,x1,y1,z1,x3,y3,z3);
if ((y2>y1) && (y2>y3) && (y3>y1))
scan_line(x2,y2,z2,x3,y3,z3,x1,y1,z1);
if ((y3>y1) && (y3>y2) && (y1>y2))
scan_line(x3,y3,z3,x1,y1,z1,x2,y2,z2);
if ((y3>y1) && (y3>y2) && (y2>y1))
scan_line(x3,y3,z3,x2,y2,z2,x1,y1,z1);
}
}
void scan_line(float x1,float y1,float z1,float x2,float y2,float
z2,float
x3,float y3,float z3)
{
int i;
float tempx,tempx1,tempy;
float m1,m2,thita,alpha;
alpha=0;
tempx=x1; tempx1=x1; tempy=y1;
m1=(y2-y1)/(x2-x1);
m2=(y3-y1)/(x3-x1);
while((int)tempy!=(int)y2)
{ alpha=alpha+5;
thita=(alpha*3.14/180);
tempx=tempx-1/m1;
tempx1=tempx1-1/m2;
if(tempx<tempx1)
{
for(i=0;i+tempx<=tempx1;i++)
{
putpixel(tempx+i,tempy,intensity);
}
}
else
if (tempx1<tempx)
{ for(i=0;i+tempx1<=tempx;i++)
{
putpixel(tempx1+i,tempy,intensity);
}
}
tempy--;
}
m1=(float)(y3-y2)/(x3-x2);
while((int)tempy!=(int)y3)
{
tempx=tempx-1/m1;
tempx1=tempx1-1/m2;
if(tempx<tempx1)
{
for(i=0;i+tempx<=tempx1;i++)
putpixel(tempx+i,tempy,intensity);
}
else
{
for(i=0;i+tempx1<=tempx;i++)
putpixel(tempx1+i,tempy,intensity);
}
tempy--;
}
}
void draw()
{ int i;
for(i=0;i<5;i++)
{
pts1[i][2]=50+pts1[i][2]+50;
pts1[i][0]=pts1[i][0]+300+.5*pts1[i][2];
pts1[i][1]=200+65-pts1[i][1]-.5*pts1[i][2];
}
line(pts1[0][0],pts1[0][1],pts1[1][0],pts1[1][1]);
line(pts1[1][0],pts1[1][1],pts1[2][0],pts1[2][1]);
line(pts1[2][0],pts1[2][1],pts1[3][0],pts1[3][1]);
line(pts1[3][0],pts1[3][1],pts1[0][0],pts1[0][1]);
line(pts1[0][0],pts1[0][1],pts1[4][0],pts1[4][1]);
line(pts1[1][0],pts1[1][1],pts1[4][0],pts1[4][1]);
line(pts1[2][0],pts1[2][1],pts1[4][0],pts1[4][1]);
line(pts1[3][0],pts1[3][1],pts1[4][0],pts1[4][1]);
}
void drawscale()
{
line(pts2[0][0],pts2[0][1],pts2[1][0],pts2[1][1]);
line(pts2[1][0],pts2[1][1],pts2[2][0],pts2[2][1]);
line(pts2[2][0],pts2[2][1],pts2[3][0],pts2[3][1]);
line(pts2[3][0],pts2[3][1],pts2[0][0],pts2[0][1]);
line(pts2[0][0],pts2[0][1],pts2[4][0],pts2[4][1]);
line(pts2[1][0],pts2[1][1],pts2[4][0],pts2[4][1]);
line(pts2[2][0],pts2[2][1],pts2[4][0],pts2[4][1]);
line(pts2[3][0],pts2[3][1],pts2[4][0],pts2[4][1]);
}
Output:
Wire frame display :
Visible surface after detection :
Ex. No. 14
Image Enhancement
Aim:
To enhance an image by changing its color balance.
Procedure :Step 1: Open an image file in Photoshop.
Step 2: Create a duplicate layer of that image by pressing Ctrl+J
Step 3: Change the image Blend mode as Screen, by selecting
Layer -> Layer Style -> Blending Options
Then change its blend mode as Screen. Then click OK
Step 4: Change the Fill Value as 66%
Step 5: Open Color balance dialog box, by selecting
Image -> Adjustments -> Color balance
And change the parameter value of yellow color as +17
Step 6: Change the image Blend mode as Color Dodge, by selectingLayer -> Layer Style -> Blending Options
Then change its blend mode as Color Dodge. Then click OK
Step 7: Change the Fill Value as 70%
Step 8: Finally Combine all the layer by pressing Ctrl+E.
Step 9: Save the modified file.
Output :
Original Image:
Enhanced Image:
Ex. No. 15
Image Transformation
Aim:
To transform an image from color mode to gray scale mode and vice versa.
Procedure :Step 1: Open an image file.
Step 2: To change the RGB color mode to gray scale, Select
Image-> Mode-> Gray scale
Step 3: To change the gray scale mode to RGB color mode, Select Image -> Mode -> RGB mode
Step 4: To get the color information of the image, Select
File -> Revert.
Image in RGB Color Mode
Image in Gray Scale mode:
Ex. No. 16
Image Optimization
Aim:
To create attractive images with the smallest file size suitable to be embedded
in the web page.Procedure :
Step 1 : Open a file in Adobe Photoshop. Call the command File => Save for Web to view
a dialog box with the logo in it.
Step 2: In the upper part of the window there are tabs: Original, Optimized, 2-Up, 4-Up.
Choose the 4-Up tab. It will show the original picture and 3 optimized versions with different
settings.
Step 3: If file format is in the GIF format, choose another format from the drop-out menu.
Step 4: Reduce the number of colors.
Step 5: Save the optimized picture by pressing the button Save. In the next dialog box enter the file name and select the target folder.
Original Image:
Modified Image:
Ex. No. 17
Editing Tools
Aim:
To change eye ball color to demonstrate usage of editing tools with Hue/Saturation
adjustment layerProcedure :
Step 1: Zoom in on the eyes
Step 2: Select the lasso tool
Step 3: Draw selections around the eyes
Step 4: Add a Hue/Saturation adjustment layer
Step 5: Select the "Colorize" option
Step 6: Adjust the Hue, Saturation and Lightness
Output :
The original image
Modified Image:
Subscribe to:
Posts (Atom)