TRIBHUVAN UNIVERSITY

ASIAN SCHOOL OF MANAGEMENT AND TECHNOLOGY

Gongabu, Kathmandu

LAB REPORT ON COMPUTER GRAPHICS

SUBMITTED BY: SUBMITTED TO:

SANJAYA KHANAL Er. MANOJ GIRI
5TH SEMESTER
SYMBOL NO: 1121/20
 Contents
1. Draw a line using DDA……………………………………………………………………………………..1
2. Draw a line using BLA………………………………………………………………………………………4
3. General circle drawing algorithm…………………………………………………………………….7
4. Midpoint circle drawing algorithm………………………………………………………………….11
5. Translation………………………………………………………………………………………………………13
6. 2D Scaling……………………………………………………………………………………………………….16
7. 2D Rotation…………………………………………………………………………………………………….19
8. Reflection in x-axis………………………………………………………………………………………….23
9. Reflection in Y axis………………………………………………………………………………………….26
10. Reflection in origin……………………………………………………………………………………….29
11. Reflection in Reflection in Y=X………………………………………………………………………33
12. Reflection in y= mx+c……………………………………………………………………………………37
13. Shearing in X…………………………………………………………………………………………………43
14. Shearing in xy……………………………………………………………………………………………….46
15. Line clipping algorithm………………………………………………………………………………….49
16. Window to ViewPort Transformation……………………………………………………………55
17. Translation in 3 dimensional…………………………………………………………………………57
18. 3D scaling……………………………………………………………………………………………………..61
19. 3D Rotation…………………………………………………………………………………………………..67
20. Boundary Fill Algorithm………………………………………………………………………………..74
21. Flood fill algorithm……………………………………………………………………………………….76
22. Demonstrate 2D lines……………………………………………………………………………………78
23. Demonstrate text in java……………………………………………………………………………….80
[Link] Algorithm
import [Link].*;

import [Link].*;

import [Link];

import [Link];

class D1 extends JFrame implements ActionListener { JLabel l1, l2, l3, l4;

JTextField t1, t2, t3, t4;

Graphics g;

D1() {

[Link]("11211/20- DDA Line Algorithm");

[Link](800, 700);

[Link]([Link]);

[Link](null);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

JButton btn = new JButton("Draw");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

1
[Link](100, 130, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](btn);

[Link](true);

g = [Link]();

@Override

public void actionPerformed(ActionEvent e) {

int x0 = [Link]([Link]());

int y0 = [Link]([Link]());

int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int dx = x1 - x0;

int dy = y1 - y0;

int steps = [Link]([Link](dx), [Link](dy));

float xincrement = (float) dx / steps;

float yincrement = (float) dy / steps;

float x = x0;

float y = y0;

for (int i = 0; i <= steps; i++) {

[Link]([Link](x), [Link](y), 2, 2);

2
x += xincrement;

y += yincrement;

public static void main(String[] args) {

new D1();

Output:

3
2. BLA Algorithm
import [Link].*;

import [Link].*;

import [Link];

import [Link];

class BLALineAlgorithm extends JFrame implements ActionListener { JLabel l1, l2, l3, l4;

JTextField t1, t2, t3, t4;

Graphics g;

BLALineAlgorithm() {

[Link]("11211/20 - BLA Line Algorithm");

[Link](800, 700);

[Link](null);

[Link]([Link]);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

JButton btn = new JButton("Draw");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

4
[Link](100, 130, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](btn);

[Link](true);

g = [Link]();

@Override

public void actionPerformed(ActionEvent e) {

int x0 = [Link]([Link]());

int y0 = [Link]([Link]());

int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int dx = [Link](x1 - x0);

int dy = [Link](y1 - y0);

int sx = (x1 - x0) > 0 ? 1 : -1;

int sy = (y1 - y0) > 0 ? 1 : -1;

int xn = x0, yn = y0, p0;

if (dx > dy) {

p0 = 2 * dy - dx;

for (int i = 0; i <= dx; i++) {

[Link](xn, yn, 2, 2);

5
xn = xn + sx;

if (p0 >= 0) {

yn = yn + sy;

p0 = p0 + 2 * (dy - dx);

} else {

p0 = p0 + 2 * dy;

}}}

else {

p0 = 2 * dx - dy;

for (int i = 0; i <= dy; i++) {

[Link](xn, yn, 2, 2);

if (p0 >=0) {

xn = xn + sx;

yn = yn + sy;

p0 = p0 + 2 * (dx - dy); } else {

yn = yn + sy;

p0 = p0 + 2 * dx;

}}}}

public static void main(String[] args) {

new BLALineAlgorithm();

Output:

6
3. General Circle Drawing Algorithm
import [Link].*;

import [Link].*;

import [Link].*;

class GCD extends JFrame implements ActionListener {

JLabel l1, l2, l3;

JTextField t1, t2, t3;

Graphics g;

GCD() {

l1 = new JLabel("h:");

[Link](10, 10, 40, 25);

[Link](l1);

t1 = new JTextField();

[Link](20, 10, 40, 25);

[Link](t1);

l2 = new JLabel("k:");

[Link](100, 10, 40, 25);

[Link](l2);

t2 = new JTextField();

[Link](120, 10, 40, 25);

[Link](t2);

l3 = new JLabel("r:");

[Link](200, 10, 40, 25);

[Link](l3);

t3 = new JTextField();

[Link](220, 10, 40, 25);

[Link](t3);

JButton btn = new JButton("Draw");

[Link](300, 10, 100, 25);

7
 [Link](this);

[Link](btn);

[Link](" General Circle Algorithm ");

[Link](800, 700);

[Link](null);

[Link](true);

g = [Link]();

@Override

public void actionPerformed(ActionEvent e) {

int h = [Link]([Link]());

int k = [Link]([Link]());

int r = [Link]([Link]());

int xk = r;

int yk = 0;

while (xk > yk) {

[Link](xk + h, yk + k, 2, 2);

[Link](yk + h, xk + k, 2, 2);

[Link](-xk + h, yk + k, 2, 2);

[Link](-yk + h, xk + k, 2, 2);

[Link](-xk + h, -yk + k, 2, 2);

[Link](-yk + h, -xk + k, 2, 2);

[Link](xk + h, -yk + k, 2, 2);

[Link](yk + h, -xk + k, 2, 2);

xk = xk - 1;

yk = (int) [Link]([Link](r * r - xk * xk));

public static void main(String[] args) {

new GCD();
8
 }

Output:

9
[Link] Circle Algorithm Program
import [Link].*;

import [Link];

import [Link].*;

class MidpointCircle extends JFrame implements ActionListener {

JLabel l1, l2, l3;

JTextField t1, t2, t3;

Graphics g;

MidpointCircle() {

l1 = new JLabel("h:");

[Link](10, 10, 40, 25);

add(l1);

t1 = new JTextField();

[Link](20, 10, 40, 25);

add(t1);

l2 = new JLabel("k:");

[Link](70, 10, 40, 25);

add(l2);

t2 = new JTextField();

[Link](90, 10, 40, 25);

add(t2);

l3 = new JLabel("r:");

[Link](130, 10, 40, 25);

[Link](l3);

t3 = new JTextField();

[Link](150, 10, 40, 25);

[Link](t3);

JButton btn = new JButton("Draw");

[Link](200, 10, 100, 25);

10
 [Link](this);

[Link](btn);

[Link](" Mid-Point Circle Algorithm ");

[Link](600, 700);

[Link](null);

[Link](true);

g = [Link]();

@Override

public void actionPerformed(ActionEvent e) {

int h = [Link]([Link]());

int k = [Link]([Link]());

int r = [Link]([Link]());

int xk = 0;

int yk = r;

int pk = 1 - r;

for (int i = 0; i <= r; i++) {

[Link](xk + h, yk + k, 2, 2);

[Link](yk + h, xk + k, 2, 2);

[Link](-xk + h, yk + k, 2, 2);

[Link](-yk + h, xk + k, 2, 2);

[Link](-xk + h, -yk + k, 2, 2);

[Link](-yk + h, -xk + k, 2, 2);

[Link](xk + h, -yk + k, 2, 2);

[Link](yk + h, -xk + k, 2, 2);

if ([Link](xk) >= [Link](yk)) {

break;

xk = xk + 1;

if (pk >= 0) {
11
 yk = yk - 1;

pk = pk + 2 * (xk - yk) + 1;

else {

pk = pk + 2 * xk + 1;

public static void main(String[] args) {

new MidpointCircle();

Output:

12
[Link]
import [Link].*;

import [Link].*;

import [Link];

import [Link];

class Translation extends JFrame implements ActionListener {

JLabel l1, l2, l3, l4, l5, l6;

JTextField t1, t2, t3, t4, t5, t6;

Graphics g;

Translation() {

[Link]("11211/20 - 2D Translation");

[Link](800, 700);

[Link](null);

[Link]([Link]);

l1= new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

l5 = new JLabel("tx:");

t5 = new JTextField();

l6 = new JLabel("ty:");

t6 = new JTextField();

JButton btn = new JButton("Translate");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

13
[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](250, 10, 50, 25);

[Link](320, 10, 100, 25);

[Link](250, 50, 50, 25);

[Link](320, 50, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](l5);

[Link](t5);

[Link](l6);

[Link](t6);

[Link](btn);

[Link](true);

g = [Link]();

@Override

public void actionPerformed(ActionEvent e) {

14
int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int x2 = [Link]([Link]());

int y2 = [Link]([Link]());

int tx = [Link]([Link]());

int ty = [Link]([Link]());

int[][] orgMatrix = {{x1, x2}, {y1, y2}, {1, 1}};

int[][] translationVector = {{1, 0, tx}, {0, 1, ty}, {0, 0, 1}};

int[][] finalMatrix = new int[3][2];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

finalMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

finalMatrix[i][j] += translationVector[i][k] * orgMatrix[k][j]; }

public static void main(String[] args) {

new Translation();

Output:

15
[Link] a Java Program to demonstrate 2D scaling
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Scaling extends JFrame implements ActionListener {

JLabel l1, l2, l3, l4, l5, l6;

JTextField t1, t2, t3, t4, t5, t6;

Graphics g;

Scaling() {

[Link]("11211/20 -- Scaling");

[Link](800, 700);

[Link](null);

[Link]([Link]);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

l5 = new JLabel("sx:");

t5 = new JTextField();

l6 = new JLabel("sy:");

t6 = new JTextField();

JButton btn = new JButton("Scale");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

16
[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](250, 10, 50, 25);

[Link](320, 10, 100, 25);

[Link](250, 50, 50, 25);

[Link](320, 50, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](l5);

[Link](t5);

[Link](l6);

[Link](t6);

[Link](btn);

[Link](true);

@Override

public void actionPerformed(ActionEvent e) {

int x1 = [Link]([Link]());
17
int y1 = [Link]([Link]());

int x2 = [Link]([Link]());

int y2 = [Link]([Link]());

int sx = [Link]([Link]());

int sy = [Link]([Link]());

int[][] orgMatrix = {{x1, x2}, {y1, y2}, {1, 1}};

int[][] scalingVector = {{sx, 0, 0}, {0, sy, 0}, {0, 0, 1}};

int[][] finalMatrix = new int[3][2];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

finalMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

finalMatrix[i][j] += scalingVector[i][k] * orgMatrix[k][j];

}}}

g = [Link]();

[Link](orgMatrix[0][0], orgMatrix[1][0], orgMatrix[0][1], orgMatrix[1][1]);

[Link]("Before Scaling", 100, 350);

[Link](finalMatrix[0][0], finalMatrix[1][0], finalMatrix[0][1], finalMatrix[1][1]);

[Link]("After Scaling", 380, 660);}

public static void main(String[] args) {

new Scaling();

}}

Output:

18
[Link] to demonstrate 2D Rotation
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Rotation extends JFrame implements ActionListener {

JLabel l1, l2, l3, l4, l5;

JTextField t1, t2, t3, t4, t5;

Graphics g;

Rotation() {

[Link]("2D Rotation");

[Link](800, 700);

[Link](null);

[Link](JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

l5 = new JLabel("Angle:");

t5 = new JTextField();

JButton btn = new JButton("Rotate");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

19
[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](250, 10, 50, 25);

[Link](320, 10, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](l5);

[Link](t5);

[Link](btn);

[Link](true);

g = [Link]();

void counterClockWise(int[][] orgMatrix, double rad) {

double[][] rotationVector = {{[Link](rad), -[Link](rad), 0}, {[Link](rad), [Link](rad), 0}, {0, 0, 1}};

int[][] finalMatrix = new int[3][2];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

finalMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

finalMatrix[i][j] += rotationVector[i][k] * orgMatrix[k][j];

20
}

[Link](finalMatrix[0][0], finalMatrix[1][0], finalMatrix[0][1], finalMatrix[1][1]);

[Link]("Rotation in Counter Clockwise", 80, 560);

void clockWise(int[][] orgMatrix, double rad) {

double[][] rotationVector = {{[Link](rad), -[Link](rad), 0}, {[Link](rad), [Link](rad), 0}, {0, 0, 1}};

int[][] finalMatrix = new int[3][2];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

finalMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

finalMatrix[i][j] += rotationVector[i][k] * orgMatrix[k][j];

[Link](finalMatrix[0][0], finalMatrix[1][0], finalMatrix[0][1], finalMatrix[1][1]);

[Link]("Rotation in Clockwise", 320, 410);

@Override

public void actionPerformed(ActionEvent e) {

int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int x2 = [Link]([Link]());

int y2 = [Link]([Link]());

int angle = [Link]([Link]());

double rad = [Link](angle);

int[][] orgMatrix = {{x1, x2}, {y1, y2}, {1, 1}};

[Link](orgMatrix[0][0], orgMatrix[1][0], orgMatrix[0][1], orgMatrix[1][1]);

21
[Link]("Before Rotation", 200, 480);

counterClockWise(orgMatrix, rad);

clockWise(orgMatrix, -rad);

public static void main(String[] args) {

new Rotation();

Output:

22
[Link] to demonstrate 2D Reflection in X axis
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Refx extends JFrame implements ActionListener { JLabel l1, l2, l3, l4;

JTextField t1, t2, t3, t4;

Graphics g;

Refx() {

[Link]("11211/20 - Reflection Through X-Axis");

[Link](800, 700);

[Link](null);

[Link](JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

JButton btn = new JButton("Reflect");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

23
[Link](100, 130, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](btn);

[Link](true); // Added this line to make the JFrame visible g = [Link]();

int[][] translate(int[][] orgMatrix, int tx, int ty) {

int[][] translationVector = {{1, 0, tx}, {0, 1, ty}, {0, 0, 1}};

int[][] tempMatrix = new int[3][2];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

tempMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

tempMatrix[i][j] += translationVector[i][k] * orgMatrix[k][j];

}}}

return tempMatrix;

@Override

public void actionPerformed(ActionEvent e) {

int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int x2 = [Link]([Link]());
24
int y2 = [Link]([Link]());

[Link](400, 0, 400, 700);

[Link](0, 350, 800, 350);

[Link]("(400,350)", 340, 370);

int[][] orgMatrix = {{x1, x2}, {y1, y2}, {1, 1}};

int[][] translatedMatrix = translate(orgMatrix, 400, 350);

int[][] reflectionVector = {{1, 0, 0}, {0, -1, 0}, {0, 0, 1}};

int[][] reflectedMatrix = new int[3][2];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

reflectedMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

reflectedMatrix[i][j] += reflectionVector[i][k] * translatedMatrix[k][j];

}}}

int[][] finalMatrix = translate(reflectedMatrix, 0, 750);

[Link](translatedMatrix[0][0], translatedMatrix[1][0], translatedMatrix[0][1], translatedMatrix[1][1]);

[Link]("Before Reflection", 580, 650);

[Link](finalMatrix[0][0], finalMatrix[1][0], finalMatrix[0][1], finalMatrix[1][1]);

[Link]("After Reflection", 550, 250);

public static void main(String[] args) {

new Refx();

}}

Output:

25
[Link] to demonstrate 2D Reflection in Y axis.
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Refy extends JFrame implements ActionListener { JLabel l1, l2, l3, l4;

JTextField t1, t2, t3, t4;

Graphics g;

public Refy() {

[Link]("11211/20 - Reflection Through Y-Axis");

[Link](800, 700);

[Link](null);

[Link](JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

JButton btn = new JButton("Reflect");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

26
[Link](100, 130, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](btn);

[Link](true);

g = [Link]();

int[][] translate(int[][] orgMatrix, int tx, int ty) {

int[][] translationVector = {{1, 0, tx}, {0, 1, ty}, {0, 0, 1}};

int[][] tempMatrix = new int[3][2];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

tempMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

tempMatrix[i][j] += translationVector[i][k] * orgMatrix[k][j]; }

}}

return tempMatrix;}

@Override

public void actionPerformed(ActionEvent e) {

int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int x2 = [Link]([Link]());
27
int y2 = [Link]([Link]());

[Link](400, 0, 400, 700);

[Link](0, 350, 800, 350);

[Link]("(400,350)", 340, 370);

int[][] orgMatrix = {{x1, x2}, {y1, y2}, {1, 1}};

int[][] translatedMatrix = translate(orgMatrix, 400, 350);

int[][] reflectionVector = {{-1, 0, 0}, {0, 1, 0}, {0, 0, 1}};

int[][] reflectedMatrix = new int[3][2];

for (int i = 0; i < 3; i++) { for (int j = 0; j < 2; j++) {

reflectedMatrix[i][j] = 0; for (int k = 0; k < 3; k++) {

reflectedMatrix[i][j] += reflectionVector[i][k] * translatedMatrix[k][j];

}}}

int[][] finalMatrix = translate(reflectedMatrix, 750, 0);

[Link](translatedMatrix[0][0], translatedMatrix[1][0], translatedMatrix[0][1], translatedMatrix[1][1]);

[Link]("Before Reflection", 580, 650);

[Link](finalMatrix[0][0], finalMatrix[1][0], finalMatrix[0][1], finalMatrix[1][1]);

[Link]("After Reflection", 80, 650);

public static void main(String[] args) {

new Refy();

}}

Output:

28
10. WAP to demonstrate 2D Reflection in Reflection in origin.
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class RefO extends JFrame implements ActionListener { JLabel l1, l2, l3, l4, l5, l6;

JTextField t1, t2, t3, t4, t5, t6;

Graphics g;

RefO() {

[Link]("11211/20 - Reflection Through Origin");

[Link](800, 700);

[Link](null);

[Link](JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

l5 = new JLabel("X3:");

t5 = new JTextField();

l6 = new JLabel("Y3:");

t6 = new JTextField();

JButton btn = new JButton("Reflect");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

29
[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](10, 170, 50, 25);

[Link](100, 170, 100, 25);

[Link](10, 210, 50, 25);

[Link](100, 210, 100, 25);

[Link](10, 250, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](l5);

[Link](t5);

[Link](l6);

[Link](t6);

[Link](btn);

[Link](true);

g = [Link]();}

int[][] translate(int[][] orgMatrix, int tx, int ty) {

int[][] translationVector = {{1, 0, tx}, {0, 1, ty}, {0, 0, 1}};

int[][] tempMatrix = new int[3][3];

for (int i = 0; i < 3; i++) {

30
for (int j = 0; j < 3; j++) {

tempMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

tempMatrix[i][j] += translationVector[i][k] * orgMatrix[k][j]; }

}}

return tempMatrix;}

@Override

public void actionPerformed(ActionEvent e) {

int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int x2 = [Link]([Link]());

int y2 = [Link]([Link]());

int x3 = [Link]([Link]());

int y3 = [Link]([Link]());

[Link](400, 0, 400, 700);

[Link](0, 350, 800, 350);

[Link]("(400,350)", 340, 370);

int[][] orgMatrix = {{x1, x2, x3}, {y1, y2, y3}, {1, 1, 1}};

int[][] translatedMatrix = translate(orgMatrix, 400, 350);

int[][] reflectionVector = {{-1, 0, 0}, {0, -1, 0}, {0, 0, 1}};

int[][] reflectedMatrix = new int[3][3];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

reflectedMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

reflectedMatrix[i][j] += reflectionVector[i][k] * translatedMatrix[k][j]; }

}}

int[][] finalMatrix = translate(reflectedMatrix, 800, 750);

int x1Translated = translatedMatrix[0][0];

int y1Translated = translatedMatrix[1][0];

31
int x2Translated = translatedMatrix[0][1];

int y2Translated = translatedMatrix[1][1];

int x3Translated = translatedMatrix[0][2];

int y3Translated = translatedMatrix[1][2];

[Link](x1Translated, y1Translated, x2Translated, y2Translated);

[Link](x2Translated, y2Translated, x3Translated, y3Translated);

[Link](x3Translated, y3Translated, x1Translated, y1Translated);

int x1Final = finalMatrix[0][0];

int y1Final = finalMatrix[1][0];

int x2Final = finalMatrix[0][1];

int y2Final = finalMatrix[1][1];

int x3Final = finalMatrix[0][2];

int y3Final = finalMatrix[1][2];

[Link](x1Final, y1Final, x2Final, y2Final);

[Link](x2Final, y2Final, x3Final, y3Final);

[Link](x3Final, y3Final, x1Final, y1Final);

[Link]("Before Reflection", 580, 550);

[Link]("After Reflection", 280, 310);

public static void main(String[] args) {

new RefO();

Output:

32
11. WAP to demonstrate 2D Reflection in Reflection in Y=X
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Refyequalsx extends JFrame implements ActionListener { JLabel l1, l2, l3, l4, l5, l6;

JTextField t1, t2, t3, t4, t5, t6;

Graphics g;

Refyequalsx() {

[Link]("11211/20- Reflection Through Line Y=X");

[Link](700, 700);

[Link](null);

[Link](JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X1:");

t1 = new JTextField();

l2 = new JLabel("Y1:");

t2 = new JTextField();

l3 = new JLabel("X2:");

t3 = new JTextField();

l4 = new JLabel("Y2:");

t4 = new JTextField();

l5 = new JLabel("X3:");

t5 = new JTextField();

l6 = new JLabel("Y3:");

t6 = new JTextField();

JButton btn = new JButton("Reflect");

[Link](this);

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

33
[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](10, 170, 50, 25);

[Link](100, 170, 100, 25);

[Link](10, 210, 50, 25);

[Link](100, 210, 100, 25);

[Link](10, 250, 100, 25);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](l5);

[Link](t5);

[Link](l6);

[Link](t6);

[Link](btn);

[Link](true);

g = [Link]();

int[][] translate(int[][] orgMatrix) {

int[][] translationVector = {{1, 0, 350}, {0, 1, 350}, {0, 0, 1}};

int[][] temp = new int[3][3];

34
for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

temp[i][j] = 0;

for (int k = 0; k < 3; k++) {

temp[i][j] += translationVector[i][k] * orgMatrix[k][j];

}}}

return temp;

@Override

public void actionPerformed(ActionEvent e) {

int x1 = [Link]([Link]());

int y1 = [Link]([Link]());

int x2 = [Link]([Link]());

int y2 = [Link]([Link]());

int x3 = [Link]([Link]());

int y3 = [Link]([Link]());

[Link](350, 0, 350, 700);

[Link](0, 350, 700, 350);

[Link](350, 350, 700, 700);

[Link]("(350,350)", 290, 370);

int[][] orgMatrix = {{x1, x2, x3}, {y1, y2, y3}, {1, 1, 1}};

int[][] translatedMatrix = translate(orgMatrix);

int[][] reflectionVector = {{0, 1, 0}, {1, 0, 0}, {0, 0, 1}};

int[][] finalMatrix = new int[3][3];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

finalMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

finalMatrix[i][j] += reflectionVector[i][k] * translatedMatrix[k][j]; }

}}
35
x1 = finalMatrix[0][0];

y1 = finalMatrix[1][0];

x2 = finalMatrix[0][1];

y2 = finalMatrix[1][1];

x3 = finalMatrix[0][2];

y3 = finalMatrix[1][2];

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x1, y1);

[Link]("Before Reflection", 550, 530);

x1 = translatedMatrix[0][0];

y1 = translatedMatrix[1][0];

x2 = translatedMatrix[0][1];

y2 = translatedMatrix[1][1];

x3 = translatedMatrix[0][2];

y3 = translatedMatrix[1][2];

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x1, y1);

[Link]("After Reflection", 400, 620); }

public static void main(String[] args) {

new Refyequalsx();

}}

Output:

36
[Link] to demonstrate 2D reflection in y=mx+c
import [Link].*;

import [Link].*;

import [Link].*;

public class reflection_Y_mx extends JFrame implements ActionListener {

JLabel l1_, l2_, l3_, l4_, l5_, l6_, l7, l8_;

JTextField t1, t2_, t3_, t4_, t5, t6_, t7_, t8_;

Graphics g;

reflection_Y_mx() {

[Link](" Reflection Through Line Y = mx + c");

[Link](800, 700);

[Link](null);

l1_ = new JLabel("X1:");

t1 = new JTextField();

l2_ = new JLabel("Y1:");

t2_ = new JTextField();

l3_ = new JLabel("X2:");

t3_ = new JTextField();

l4_ = new JLabel("Y2:");

t4_ = new JTextField();

l5_ = new JLabel("X3:");

t5 = new JTextField();

l6_ = new JLabel("Y3:");

t6_ = new JTextField();

l7 = new JLabel("m:");

t7_ = new JTextField();

37
 l8_ = new JLabel("c:");

t8_ = new JTextField();

JButton btn = new JButton("Reflect");

l1_.setBounds(10, 10, 80, 25);

[Link](100, 10, 100, 25);

l2_.setBounds(10, 50, 80, 25);

t2_.setBounds(100, 50, 100, 25);

l3_.setBounds(10, 90, 80, 25);

t3_.setBounds(100, 90, 100, 25);

l4_.setBounds(10, 130, 80, 25);

t4_.setBounds(100, 130, 100, 25);

l5_.setBounds(10, 170, 50, 25);

[Link](100, 170, 100, 25);

l6_.setBounds(10, 210, 50, 25);

t6_.setBounds(100, 210, 100, 25);

[Link](250, 10, 50, 25);

t7_.setBounds(320, 10, 100, 25);

l8_.setBounds(250, 50, 50, 25);

t8_.setBounds(320, 50, 100, 25);

[Link](10, 250, 100, 25);

[Link](this);

[Link](l1_);

[Link](t1);

[Link](l2_);

[Link](t2_);

[Link](l3_);

38
 [Link](t3_);

[Link](l4_);

[Link](t4_);

[Link](l5_);

[Link](t5);

[Link](l6_);

[Link](t6_);

[Link](l7);

[Link](t7_);

[Link](l8_);

[Link](t8_);

[Link](btn);

[Link](true);

g = [Link]();

double[][] translate(double[][] orgMatrix, int tx, int ty) {

double[][] translationVector = {{1, 0, tx}, {0, 1, ty}, {0, 0, 1}};

double[][] tempMatrix = new double[3][3];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

tempMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

tempMatrix[i][j] += translationVector[i][k] * orgMatrix[k][j];

} }}

return tempMatrix;

39
 @Override

public void actionPerformed(ActionEvent e) {

int x1 = [Link]([Link]());

int y1 = [Link](t2_.getText());

int x2 = [Link](t3_.getText());

int y2 = [Link](t4_.getText());

int x3 = [Link]([Link]());

int y3 = [Link](t6_.getText());

int m = [Link](t7_.getText());

int c = [Link](t8_.getText());

[Link](400, 0, 400, 700);

[Link](0, 350, 800, 350);

[Link]("(400,350)", 340, 370);

double[][] orgMatrix = {{x1, x2, x3}, {y1, y2, y3}, {1, 1, 1}};

double[][] translatedMatrix = translate(orgMatrix, 400, 350);

x1 = (int) translatedMatrix[0][0];

y1 = (int) translatedMatrix[1][0];

x2 = (int) translatedMatrix[0][1];

y2 = (int) translatedMatrix[1][1];

x3 = (int) translatedMatrix[0][2];

y3 = (int) translatedMatrix[1][2];

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x1, y1);

[Link]("Before Reflection", 550, 570);

x1 = -(c / m);

40
 y2 = c;

[Link](x1 + 400, 350, 400, y2 + 350);

[Link]("y = " + m + "x" + " + " + c, 420, 580);

double a = m * m - 1;

double b = m * m + 1;

double[][] reflectionVector = {

{-a / b, (2 * m) / b, (-2 * m * c) / b},{(2 * m) / b, a / b, (2 * c) / b},{0, 0, 1}};

double[][] reflectedMatrix = new double[3][3];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

reflectedMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

reflectedMatrix[i][j] += reflectionVector[i][k] * translatedMatrix[k][j];

double[][] finalMatrix = translate(reflectedMatrix, 800, 500);

x1 = (int) finalMatrix[0][0];

y1 = (int) finalMatrix[1][0];

x2 = (int) finalMatrix[0][1];

y2 = (int) finalMatrix[1][1];

x3 = (int) finalMatrix[0][2];

y3 = (int) finalMatrix[1][2];

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x1, y1);

41
 [Link]("After Reflection", 160, 650);

public static void main(String[] args) {

new reflection_Y_mx();

Output:

42
13. WAP to demonstrate Shearing in X.
import [Link].*;

import [Link].*;

import [Link];

public class Shearing extends JPanel {

static int x1, y1, x2, y2, x3, y3, x4, y4;

static int px1, px2, px3, px4;

int shx = 2;

public Shearing(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) { this.x1 = x1;

this.y1 = y1;

this.x2 = x2;

this.y2 = y2;

this.x3 = x3;

this.y3 = y3;

this.x4 = x4;

this.y4 = y4;

px1 = y1 * shx + x1;

px2 = y2 * shx + x2;

px3 = y3 * shx + x3;

px4 = y4 * shx + x4;

@Override

public void paintComponent(Graphics g) {

[Link](g);

[Link]("Before Shearing", x1 - 20, y1 - 20);

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x4, y4);

[Link](x4, y4, x1, y1);

43
[Link]("After Shearing", px1 - 20, y1 - 20);

[Link](px1, y1, px2, y2);

[Link](px2, y2, px3, y3);

[Link](px3, y3, px4, y4);

[Link](px4, y4, px1, y1);

public static void main(String args[]) {

JFrame f = new JFrame();

Scanner sc = new Scanner([Link]);

[Link]("Enter x1:");

int x1 = [Link]();

[Link]("Enter y1:");

int y1 = [Link]();

[Link]("Enter x2:");

int x2 = [Link]();

[Link]("Enter y2:");

int y2 = [Link]();

[Link]("Enter x3:");

int x3 = [Link]();

[Link]("Enter y3:");

int y3 = [Link]();

[Link]("Enter x4:");

int x4 = [Link]();

[Link]("Enter y4:");

int y4 = [Link]();

Shearing shearing = new Shearing(x1, y1, x2, y2, x3, y3, x4, y4);

[Link](shearing);

[Link]("Shearing in X-axis");

[Link](JFrame.EXIT_ON_CLOSE);

[Link](500, 500);
44
[Link](true);

Input:

Output:

45
14. WAP to demonstrate shearing in xy
import [Link].*;

import [Link].*;

import [Link];

public class Shearingxy extends JPanel {

static int x1, y1, x2, y2, x3, y3, x4, y4;

static int px1, px2, px3, px4;

int shx = 2;

public Shearingxy(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)

{ this.x1 = x1;

this.y1 = y1;

this.x2 = x2;

this.y2 = y2;

this.x3 = x3;

this.y3 = y3;

this.x4 = x4;

this.y4 = y4;

px1 = x1 + y1 * shx;

px2 = x2 + y2 * shx;

px3 = x3 + y3 * shx;

px4 = x4 + y4 * shx;

@Override

public void paintComponent(Graphics g) {

[Link](g);

[Link]("Before Shearing", x1 - 20, y1 - 20);

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x4, y4);

46
[Link](x4, y4, x1, y1);

[Link]("After Shearing (XY-axis)", px1 - 20, y1 - 20);

[Link](px1, y1, px2, y2);

[Link](px2, y2, px3, y3);

[Link](px3, y3, px4, y4);

[Link](px4, y4, px1, y1);

public static void main(String args[]) {

JFrame f = new JFrame();

Scanner sc = new Scanner([Link]);

[Link]("Enter x1:");

int x1 = [Link]();

[Link]("Enter y1:");

int y1 = [Link]();

[Link]("Enter x2:");

int x2 = [Link]();

[Link]("Enter y2:");

int y2 = [Link]();

[Link]("Enter x3:");

int x3 = [Link]();

[Link]("Enter y3:");

int y3 = [Link]();

[Link]("Enter x4:");

int x4 = [Link]();

[Link]("Enter y4:");

int y4 = [Link]();

Shearingxy = new Shearingxy(x1, y1, x2, y2, x3, y3, x4, y4);

[Link](Shearingxy);

[Link]("Shearing in X-axis");

[Link](JFrame.EXIT_ON_CLOSE);
47
[Link](600, 500);

[Link](true);

Input:

Output:

48
15. Line Clipping (Cohen–Sutherland Algorithm)
import [Link].*;

import [Link].*;

import [Link].*;

class Cohen_Sutherland extends JFrame implements ActionListener {

final int INSIDE = 0; // 0000

final int LEFT = 1; // 0001

final int RIGHT = 2; // 0010

final int BOTTOM = 4; // 0100

final int TOP = 8; // 1000

int x_min, y_min, x_max, y_max;

JLabel l1, l2, l3, l4, l5, l6, l7, l8;

JTextField t1, t2, t3, t4, t5, t6, t7, t8;

Graphics g;

Cohen_Sutherland() {

[Link]("Cohen-Sutherland Line Clipping Algorithm");

[Link](800, 700);

[Link](null);

l1 = new JLabel("Xmin:");

t1 = new JTextField();

l2 = new JLabel("Ymin:");

t2 = new JTextField();

l3 = new JLabel("Xmax:");

t3 = new JTextField();

l4 = new JLabel("Ymax:");

t4 = new JTextField();

l5 = new JLabel("X1:");

t5 = new JTextField();

l6 = new JLabel("Y1:");

49
t6 = new JTextField();

l7 = new JLabel("X2:");

t7 = new JTextField();

l8 = new JLabel("Y2:");

t8 = new JTextField();

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](250, 10, 50, 25);

[Link](320, 10, 100, 25);

[Link](250, 50, 50, 25);

[Link](320, 50, 100, 25);

[Link](250, 90, 50, 25);

[Link](320, 90, 100, 25);

[Link](250, 130, 50, 25);

[Link](320, 130, 100, 25);

JButton btn = new JButton("Clip Line");

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);
50
 [Link](l4);

add(t4);

[Link](l5);

[Link](t5);

[Link](l6);

[Link](t6);

[Link](l7);

[Link](t7);

[Link](l8);

[Link](t8);

[Link](btn);

[Link](true);

g = [Link]();

int computeCode(double x, double y) {

int code = INSIDE;

if (x < x_min) // to the left of rectangle

code |= LEFT;

else if (x > x_max) // to the right of rectangle

code |= RIGHT;

if (y < y_min) // below the rectangle

code |= BOTTOM;

else if (y > y_max) // above the rectangle

code |= TOP;

return code;

@Override

public void actionPerformed(ActionEvent e) {

x_min = [Link]([Link]());

y_min = [Link]([Link]());
51
x_max = [Link]([Link]());

y_max = [Link]([Link]());

double x1 = [Link]([Link]());

double y1 = [Link]([Link]());

double x2 = [Link]([Link]());

double y2 = [Link]([Link]());

[Link](x_min, y_min, x_min, y_max);

[Link](x_min, y_max, x_max, y_max);

[Link](x_max, y_max, x_max, y_min);

[Link](x_max, y_min, x_min, y_min);

[Link]((int) x1, (int) y1, (int) x2, (int) y2);

[Link]("Before Clipping", 150, 600);

int code1 = computeCode(x1, y1);

int code2 = computeCode(x2, y2);

boolean accept = false;

while (true) {

if ((code1 == 0) && (code2 == 0)) {

accept = true;

break;

else if ((code1 & code2) != 0) {

break;

else {

int code_out;

double x = 0, y = 0;

if (code1 != 0) {

code_out = code1;

else {
52
 code_out = code2;

if ((code_out & TOP) != 0) {

x = x1 + (x2 - x1) * (y_max - y1) / (y2 - y1);

y = y_max;

else if ((code_out & BOTTOM) != 0) {

x = x1 + (x2 - x1) * (y_min - y1) / (y2 - y1);

y = y_min;

else if ((code_out & RIGHT) != 0) {

y = y1 + (y2 - y1) * (x_max - x1) / (x2 - x1);

x = x_max;

else if ((code_out & LEFT) != 0) {

y = y1 + (y2 - y1) * (x_min - x1) / (x2 - x1);

x = x_min;

if (code_out == code1) {

x1 = x;

y1 = y;

code1 = computeCode(x1, y1);

else {

x2 = x;

y2 = y;

code2 = computeCode(x2, y2);

}
53
 int tx = 300;

if (accept) {

[Link](x_min + tx, y_min, x_min + tx, y_max);

[Link](x_min + tx, y_max, x_max + tx, y_max);

[Link](x_max + tx, y_max, x_max + tx, y_min);

[Link](x_max + tx, y_min, x_min + tx, y_min);

[Link]((int) x1 + tx, (int) y1, (int) x2 + tx, (int) y2);

[Link]("After Clipping", 460, 600);

else {

[Link]("Line is rejected.");

public static void main(String[] args) {

new Cohen_Sutherland();

Output:

54
16. WAP in JAVA program to demonstrate Window to ViewPort Transformation.
import [Link].*;

import [Link];

import [Link];

public class WindowViewPort extends JPanel {

@Override

protected void paintComponent(Graphics g) {

[Link](g);

int windowWidth = 200;

int windowHeight = 200;

int viewportWidth = 400;

int viewportHeight = 400;

float sx = (float) viewportWidth / windowWidth;

float sy = (float) viewportHeight / windowHeight;

[Link]("Window space", 100, 100);

[Link](100, 100, windowWidth, windowHeight);

[Link]("Viewport space", 400, 400);

[Link](100, 100, viewportWidth, viewportHeight);

int x1 = 50;

int y1 = 50;

int xt1 = (int) (x1 * sx);

int yt1 = (int) (y1 * sy);

[Link]([Link]); // Set color for the transformed point

[Link](xt1 + 100, yt1 + 100, 5, 5); // Draw transformed point

public static void main(String[] args) {

JFrame mango = new JFrame("Window to Viewport Transformation Example");

[Link](600, 600); // Increased size to show the transformations clearly

[Link](new WindowViewPort());

55
[Link](true);

Output:

56
17. WAP to demonstrate Translation in 3 dimensional.
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Translation3D extends JFrame implements ActionListener {

JLabel l1, l2, l3, l4, l5, l6;

JTextField t1, t2, t3, t4, t5, t6;

Graphics g;

Translation3D() {

setTitle("3D Translation");

setSize(800, 700);

setLayout(null);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X");

t1 = new JTextField();

l2 = new JLabel("Y");

t2 = new JTextField();

l3 = new JLabel("Length");

t3 = new JTextField();

l4 = new JLabel("Shift");

t4 = new JTextField();

l5 = new JLabel("tx");

t5 = new JTextField();

l6 = new JLabel("ty");

t6 = new JTextField();

JButton btn = new JButton("Draw");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

57
[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](250, 10, 50, 25);

[Link](320, 10, 100, 25);

[Link](250, 50, 50, 25);

[Link](320, 50, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

add(l1);

add(t1);

add(l2);

add(t2);

add(l3);

add(t3);

add(l4);

add(t4);

add(l5);

add(t5);

add(l6);

add(t6);

add(btn);

setVisible(true);

g = [Link]();

Point[] getCubeOnePoints(int x, int y, int length) { Point[] points = new Point[4];

points[0] = new Point(x, y);

58
points[1] = new Point(x + length, y);

points[2] = new Point(x + length, y + length);

points[3] = new Point(x, y + length);

return points;

Point[] getCubeTwoPoints(int x, int y, int length, int shift) {

int newX = x + shift;

int newY = y + shift;

Point[] points = new Point[4];

points[0] = new Point(newX, newY);

points[1] = new Point(newX + length, newY);

points[2] = new Point(newX + length, newY + length);

points[3] = new Point(newX, newY + length);

return points;

@Override

public void actionPerformed(ActionEvent e) {

int x = [Link]([Link]());

int y = [Link]([Link]());

int length = [Link]([Link]());

int shift = [Link]([Link]());

int tx = [Link]([Link]());

int ty = [Link]([Link]());

Point[] cubeOnePoints = getCubeOnePoints(x, y, length);

Point[] cubeTwoPoints = getCubeTwoPoints(x, y, length, shift);

[Link]([Link]);

[Link](x, y, length, length);

[Link](x + shift, y + shift, length, length);

for (int i = 0; i < 4; i++) {

[Link](cubeOnePoints[i].x, cubeOnePoints[i].y, cubeTwoPoints[i].x, cubeTwoPoints[i].y);

59
}

[Link]("Before Translation", x - 20, y - 20);

[Link]([Link]);

[Link](x + tx, y + ty, length, length);

[Link](x + shift + tx, y + shift + ty, length, length);

for (int i = 0; i < 4; i++) {

[Link](cubeOnePoints[i].x + tx, cubeOnePoints[i].y + ty, cubeTwoPoints[i].x + tx, cubeTwoPoints[i].y + ty);

[Link]("After Translation", x + tx - 20, y + ty - 20);

public static void main(String[] args) {

[Link](() -> new Translation3D());

Output:

60
18. Write a Java program to demonstrate 3D scaling.
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Scaling3D extends JFrame implements ActionListener {

JLabel l1, l2, l3, l4, l5, l6;

JTextField t1, t2, t3, t4, t5, t6;

Graphics g;

Scaling3D() {

[Link](" 3D Scaling");

[Link](800, 700);

[Link](null);

[Link](JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X:");

t1 = new JTextField();

l2 = new JLabel("Y:");

t2 = new JTextField();

l3 = new JLabel("Length:");

t3 = new JTextField();

l4 = new JLabel("Shift:");

t4 = new JTextField();

l5 = new JLabel("sx:");

t5 = new JTextField();

l6 = new JLabel("sy:");

t6 = new JTextField();

JButton btn = new JButton("Draw");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

61
[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](250, 10, 50, 25);

[Link](320, 10, 100, 25);

[Link](250, 50, 50, 25);

[Link](320, 50, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](l5);

[Link](t5);

[Link](l6);

[Link](t6);

[Link](btn);

[Link](true);

g = [Link]();

Point[] getCubeOnePoints(int x, int y, int length) {

62
Point[] points = new Point[4];

points[0] = new Point(x, y);

points[1] = new Point(x + length, y);

points[2] = new Point(x + length, y + length);

points[3] = new Point(x, y + length);

return points;

Point[] getCubeTwoPoints(int x, int y, int length, int shift) {

int newX = x + shift;

int newY = y + shift;

Point[] points = new Point[4];

points[0] = new Point(newX, newY);

points[1] = new Point(newX + length, newY);

points[2] = new Point(newX + length, newY + length);

points[3] = new Point(newX, newY + length);

return points;

Point[] drawCubeOnePointsAfterScaling(int x, int y, int length, int sx, int sy) {

Point[] points = new Point[4];

points[0] = new Point(x * sx, y * sy);

points[1] = new Point((x + length) * sx, y * sy);

points[2] = new Point((x + length) * sx, (y + length) * sy);

points[3] = new Point(x * sx, (y + length) * sy);

int x1 = points[0].x;

int y1 = points[0].y;

int x2 = points[1].x;

int y2 = points[1].y;

int x3 = points[2].x;

int y3 = points[2].y;
63
int x4 = points[3].x;

int y4 = points[3].y;

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x4, y4);

[Link](x4, y4, x1, y1);

return points;

Point[] drawCubeTwoPointsAfterScaling(int x, int y, int length, int shift, int sx, int sy) {

int newX = x + shift;

int newY = y + shift;

Point[] points = new Point[4];

points[0] = new Point(newX * sx, newY * sy);

points[1] = new Point((newX + length) * sx, newY * sy);

points[2] = new Point((newX + length) * sx, (newY + length) * sy);

points[3] = new Point(newX * sx, (newY + length) * sy);

int x1 = points[0].x;

int y1 = points[0].y;

int x2 = points[1].x;

int y2 = points[1].y;

int x3 = points[2].x;

int y3 = points[2].y;

int x4 = points[3].x;

int y4 = points[3].y;

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x4, y4);

[Link](x4, y4, x1, y1);

return points;
64
}

@Override

public void actionPerformed(ActionEvent e) {

int x = [Link]([Link]());

int y = [Link]([Link]());

int length = [Link]([Link]());

int shift = [Link]([Link]());

int sx = [Link]([Link]());

int sy = [Link]([Link]());

Point[] cubeOnePoints = getCubeOnePoints(x, y, length);

Point[] cubeTwoPoints = getCubeTwoPoints(x, y, length, shift);

[Link](x, y, length, length);

[Link](x + shift, y + shift, length, length);

[Link]("Before Scaling", 100, 360);

for (int i = 0; i < 4; i++) {

[Link](cubeOnePoints[i].x, cubeOnePoints[i].y, cubeTwoPoints[i].x,

cubeTwoPoints[i].y);

Point[] finalCubeOnePoints = drawCubeOnePointsAfterScaling(x, y, length, sx, sy);

Point[] finalCubeTwoPoints = drawCubeTwoPointsAfterScaling(x, y, length, shift, sx,

sy);

for (int i = 0; i < 4; i++) {

[Link](finalCubeOnePoints[i].x, finalCubeOnePoints[i].y,

finalCubeTwoPoints[i].x, finalCubeTwoPoints[i].y);

[Link]("After Scaling", 560, 620);

public static void main(String[] args) {

new Scaling3D();
65
}

Output:

66
19. WAP to demonstrate 3D Rotation.
import [Link].*;

import [Link].*;

import [Link];

import [Link];

public class Rotation3D extends JFrame implements ActionListener {

JLabel l1, l2, l3, l4, l5;

JTextField t1, t2, t3, t4, t5;

Graphics g;

Rotation3D() {

[Link]("3D Rotation");

[Link](800, 700);

[Link](null);

[Link](JFrame.EXIT_ON_CLOSE);

l1 = new JLabel("X:");

t1 = new JTextField();

l2 = new JLabel("Y:");

t2 = new JTextField();

l3 = new JLabel("Length:");

t3 = new JTextField();

l4 = new JLabel("Shift:");

t4 = new JTextField();

l5 = new JLabel("Angle:");

t5 = new JTextField();

JButton btn = new JButton("Draw");

[Link](10, 10, 80, 25);

[Link](100, 10, 100, 25);

[Link](10, 50, 80, 25);

[Link](100, 50, 100, 25);

67
[Link](10, 90, 80, 25);

[Link](100, 90, 100, 25);

[Link](10, 130, 80, 25);

[Link](100, 130, 100, 25);

[Link](250, 10, 50, 25);

[Link](320, 10, 100, 25);

[Link](10, 170, 100, 25);

[Link](this);

[Link](l1);

[Link](t1);

[Link](l2);

[Link](t2);

[Link](l3);

[Link](t3);

[Link](l4);

[Link](t4);

[Link](l5);

[Link](t5);

[Link](btn);

[Link](true);

g = [Link]();

Point[] getCubeOnePoints(int x, int y, int length) {

Point[] points = new Point[4];

points[0] = new Point(x, y);

points[1] = new Point(x + length, y);

points[2] = new Point(x + length, y + length);

points[3] = new Point(x, y + length);

return points;

}
68
Point[] getCubeTwoPoints(int x, int y, int length, int shift) {

int newX = x + shift;

int newY = y + shift;

Point[] points = new Point[4];

points[0] = new Point(newX, newY);

points[1] = new Point(newX + length, newY);

points[2] = new Point(newX + length, newY + length);

points[3] = new Point(newX, newY + length);

return points;

Point[] drawCubeOnePointsAfterRotation(int x, int y, int length, double rad) {

int[][] orgMatrix = {

{x, x + length, x + length, x},

{y, y, y + length, y + length},

{1, 1, 1, 1}

};

double[][] rotationVector = {

{[Link](rad), -[Link](rad), 0},

{[Link](rad), [Link](rad), 0},

{0, 0, 1}

};

int[][] finalMatrix = new int[3][4];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 4; j++) {

finalMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

finalMatrix[i][j] += rotationVector[i][k] * orgMatrix[k][j];

}
69
int x1 = finalMatrix[0][0];

int y1 = finalMatrix[1][0];

int x2 = finalMatrix[0][1];

int y2 = finalMatrix[1][1];

int x3 = finalMatrix[0][2];

int y3 = finalMatrix[1][2];

int x4 = finalMatrix[0][3];

int y4 = finalMatrix[1][3];

Point[] points = new Point[4];

points[0] = new Point(x1, y1);

points[1] = new Point(x2, y2);

points[2] = new Point(x3, y3);

points[3] = new Point(x4, y4);

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x4, y4);

[Link](x4, y4, x1, y1);

return points;

Point[] drawCubeTwoPointsAfterRotation(int x, int y, int length, int shift, double rad) {

int newX = x + shift;

int newY = y + shift;

int[][] orgMatrix = {{newX, newX + length, newX + length, newX},{newY, newY, newY + length, newY +
length},{1, 1, 1, 1}};

double[][] rotationVector = {{[Link](rad), -[Link](rad), 0},{[Link](rad), [Link](rad), 0},{0, 0, 1}};

int[][] finalMatrix = new int[3][4];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 4; j++) {

finalMatrix[i][j] = 0;

for (int k = 0; k < 3; k++) {

70
finalMatrix[i][j] += rotationVector[i][k] * orgMatrix[k][j];

int x1 = finalMatrix[0][0];

int y1 = finalMatrix[1][0];

int x2 = finalMatrix[0][1];

int y2 = finalMatrix[1][1];

int x3 = finalMatrix[0][2];

int y3 = finalMatrix[1][2];

int x4 = finalMatrix[0][3];

int y4 = finalMatrix[1][3];

Point[] points = new Point[4];

points[0] = new Point(x1, y1);

points[1] = new Point(x2, y2);

points[2] = new Point(x3, y3);

points[3] = new Point(x4, y4);

[Link](x1, y1, x2, y2);

[Link](x2, y2, x3, y3);

[Link](x3, y3, x4, y4);

[Link](x4, y4, x1, y1);

return points;

@Override

public void actionPerformed(ActionEvent e) {

int x = [Link]([Link]());

int y = [Link]([Link]());

int length = [Link]([Link]());

int shift = [Link]([Link]());

int angle = [Link]([Link]());

71
double rad = [Link](angle);

Point[] cubeOnePoints = getCubeOnePoints(x, y, length);

Point[] cubeTwoPoints = getCubeTwoPoints(x, y, length, shift);

[Link](x, y, length, length);

[Link](x + shift, y + shift, length, length);

[Link]("Before Rotation", 370, 530);

for (int i = 0; i < 4; i++) {

[Link](cubeOnePoints[i].x, cubeOnePoints[i].y, cubeTwoPoints[i].x,

cubeTwoPoints[i].y);

[Link]("Rotation in Counter-Clockwise", 200, 650);

Point[] finalCubeOnePoints = drawCubeOnePointsAfterRotation(x, y, length, rad);

Point[] finalCubeTwoPoints = drawCubeTwoPointsAfterRotation(x, y, length, shift, rad);

for (int i = 0; i < 4; i++) {

[Link](finalCubeOnePoints[i].x,

finalCubeOnePoints[i].y,

finalCubeTwoPoints[i].x,

finalCubeTwoPoints[i].y

);

Point[] finalCubeOnePointsClockwise = drawCubeOnePointsAfterRotation(x, y, length,

-rad);

Point[] finalCubeTwoPointsClockwise = drawCubeTwoPointsAfterRotation(x, y,

length, shift, -rad);

for (int i = 0; i < 4; i++) {

[Link](

finalCubeOnePointsClockwise[i].x,

finalCubeOnePointsClockwise[i].y,

finalCubeTwoPointsClockwise[i].x,

finalCubeTwoPointsClockwise[i].y
72
);

[Link]("Rotation in Clockwise", 560, 280);

public static void main(String[] args) {

new Rotation3D();

Output:

73
20. WAP in Java to demonstrate boundary fill algorithm.
import [Link];

import [Link];

import [Link];

import [Link].Graphics2D;

import [Link];

import [Link];

public class BoundaryFill extends JFrame {

public static int width = 500;

public static int height = 500;

public BoundaryFill() {

setTitle("BoundaryFill");

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setSize(800, 600);

setVisible(true);

public void boundaryFill(int x, int y, Color fill, Color boundary, WritableRaster raster) {

int[] fillColor = { [Link](), [Link](), [Link](), [Link]() };

int[] boundaryColor = { [Link](), [Link](), [Link]() };

int[] curColor = [Link](x, y, new int[] { 255, 255, 255, 255 });

if ((!isEqualRgba(curColor, boundaryColor)) && (!isEqualRgba(curColor, fillColor))) {

[Link](x, y, fillColor);

boundaryFill(x + 1, y, fill, boundary, raster);

boundaryFill(x - 1, y, fill, boundary, raster);

boundaryFill(x, y + 1, fill, boundary, raster);

boundaryFill(x, y - 1, fill, boundary, raster);

private boolean isEqualRgba(int[] pix1, int[] pix2) {

74
return pix1[0] == pix2[0] && pix1[1] == pix2[1] && pix1[2] == pix2[2] && pix1[3] == pix2[3]; }

@Override

public void paint(Graphics g) {

[Link](g);

Graphics2D g2d = (Graphics2D) g;

BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

Graphics2D big2d = [Link]();

[Link]([Link]);

[Link](250, 250, 100, 100);

WritableRaster raster = [Link]();

boundaryFill(251, 251, [Link], [Link], raster);

[Link](bi, 0, 0, null);

public static void main(String[] args) {

[Link](() -> new BoundaryFill()); }

Output:

75
21. WAP to demonstrate Flood fill algorithm.
import [Link].*;

import [Link].*;

import [Link];

import [Link];

import [Link];

public class FloodFill extends JPanel {

private BufferedImage image;

private Graphics2D g2;

public static void main(String[] args) { [Link](() -> {

JFrame frame = new JFrame("FloodFill algorithm"); [Link](JFrame.EXIT_ON_CLOSE);

FloodFill fill = new FloodFill();

[Link](fill);

[Link]();

[Link](true);

});

public FloodFill() {

image = new BufferedImage(500, 500, BufferedImage.TYPE_INT_RGB);

setPreferredSize(new Dimension([Link](), [Link]()));

setMinimumSize(getPreferredSize());

g2 = [Link]();

[Link]([Link]);

[Link]([Link]);

[Link](100, 100, 100, 100);

addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

floodFill([Link](), [Link](), [Link]([Link](), [Link]()));

repaint();

76
}

});

@Override

protected void paintComponent(Graphics g) {

[Link](g);

[Link](image, 0, 0, this);

public void floodFill(int seedX, int seedY, int rgb) {

if ([Link](seedX, seedY) == rgb) {

[Link](seedX, seedY, [Link]());

if (seedX > 0 && seedX < [Link]() - 1 && seedY > 0 && seedY < [Link]() - 1) {
floodFill(seedX - 1, seedY - 1, rgb);

floodFill(seedX - 1, seedY + 1, rgb);

floodFill(seedX + 1, seedY - 1, rgb);

floodFill(seedX + 1, seedY + 1, rgb);

floodFill(seedX, seedY - 1, rgb);

floodFill(seedX, seedY + 1, rgb);

floodFill(seedX - 1, seedY, rgb);

floodFill(seedX + 1, seedY, rgb);

}}}}

Output:

77
22. WAP in JAVA program to demonstrate 2D lines
import [Link].*;

import [Link].*;

public class Lines extends JFrame {

Lines() {

[Link](" Line Types");

[Link](600, 800);

[Link](true);

@Override

public void paint(Graphics g) {

[Link](g);

Graphics2D g2D = (Graphics2D) g;

[Link](new BasicStroke(4f));

[Link](40, 100, 40, 300);

[Link]("Normal Line", 20, 100);

[Link](new BasicStroke(10f));

[Link](120, 100, 120, 300);

[Link]("Thick Line", 110, 90);

[Link](new BasicStroke(1f));

[Link](190, 100, 190, 300);

[Link]("Thin Line", 190, 90);

float[] dash = {2f, 0f, 2f};

BasicStroke bs1 = new BasicStroke(4f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 1.0f, dash, 2f);

[Link](bs1);

[Link](280, 100, 280, 300);

[Link]("Dotted Line", 280, 90);

BasicStroke bs2 = new BasicStroke(10f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 1.0f, dash, 2f);

[Link](bs2);

78
 [Link](40, 350, 400, 350);

[Link]("Thick Dotted Line", 200, 380);

BasicStroke bs3 = new BasicStroke(1f, BasicStroke.CAP_BUTT,BasicStroke.JOIN_ROUND, 1.0f, dash, 2f);

[Link](bs3);

[Link](40, 420, 400, 420);

[Link]("Dashed Line", 220, 440);

public static void main(String[] args) {

new Lines();

Output:

79
23. WAP in JAVA program to demonstrate text in java.
import [Link].*;

import [Link].*;

public class Texts extends JPanel {

@Override

protected void paintComponent(Graphics g) {

[Link](g);

Graphics2D g2d = (Graphics2D) g;

Font font = new Font("Times New Roman", [Link], 32); [Link](font);

[Link]([Link]);

String text = " This is CG assignment" ;

int x = 50;

int y = 50;

[Link](text, x, y);

public static void main(String[] args) {

[Link](() -> {

JFrame frame = new JFrame("Text Display"); [Link](JFrame.EXIT_ON_CLOSE);

Texts textsPanel = new Texts();

[Link](new Dimension(400, 300)); [Link]().add(textsPanel);

[Link]();

[Link](true);

});

}}

Output:

80