Scribd
Upload
96 views

Aim: Write A Program To Move An Object Using The Concept of 2-D Translation Transformation

Program 4 demonstrates 2D shearing transformation by drawing three rectangles sheared vertically by 1 unit, in different positions and colors. Program 5 implements the Digital Differential Analyzer (DDA) line drawing algorithm to draw a line as a series of points. Program 6 implements Bresenham's line

Uploaded by

aman
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
96 views

Aim: Write A Program To Move An Object Using The Concept of 2-D Translation Transformation

Program 4 demonstrates 2D shearing transformation by drawing three rectangles sheared vertically by 1 unit, in different positions and colors. Program 5 implements the Digital Differential Analyzer (DDA) line drawing algorithm to draw a line as a series of points. Program 6 implements Bresenham's line

Uploaded by

aman
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 14

Program No.

1
Aim: Write a program to move an object using the concept of 2-D
translation transformation.
Input:

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;

class Surface extends JPanel {


private void doDrawing(final Graphics g) {
final Graphics2D g2d = (Graphics2D) g.create();
g2d.setPaint(new Color(150, 150, 150));
g2d.fillRect(20, 20, 80, 50);
g2d.translate(150, 50);
g2d.fillRect(20, 20, 80, 50);
g2d.dispose();
}

@Override
public void paintComponent(final Graphics g) {
super.paintComponent(g);
doDrawing(g);
}
}

public class TranslationEx extends JFrame {


public TranslationEx() {
initUI();
}

private void initUI() {


add(new Surface());
setTitle("Translation");
setSize(300, 200);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(final String[] args) {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
final TranslationEx ex = new TranslationEx();
ex.setVisible(true);
}
});
}
}

Output:
Program No. 2
Aim: Write a program to move an object using the concept of 2-D rotation
transformation.
Input:

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;

class Surface extends JPanel {


private void doDrawing(Graphics g) {
Graphics2D g2d = (Graphics2D) g.create();
g2d.setPaint(new Color(150, 150, 150));
g2d.fillRect(20, 20, 80, 50);
g2d.translate(180, -50);
g2d.rotate(Math.PI / 4);
g2d.fillRect(80, 80, 80, 50);
g2d.dispose();
}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
doDrawing(g);
}
}

public class RotationEx extends JFrame {


public RotationEx() {
initUI();
}

private void initUI() {


setTitle("Rotation");
add(new Surface());
setSize(300, 200);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
RotationEx ex = new RotationEx();
ex.setVisible(true);
}
});
}
}

Output:
Program No. 3
Aim: Write a program to move an object using the concept of 2-D scaling
transformation.
Input:

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import javax.swing.JFrame;
import javax.swing.JPanel;

class Surface extends JPanel {


private void doDrawing(Graphics g) {
Graphics2D g2d = (Graphics2D) g.create();
g2d.setColor(new Color(150, 150, 150));
g2d.fillRect(20, 20, 80, 50);
AffineTransform tx1 = new AffineTransform();
tx1.translate(110, 22);
tx1.scale(0.5, 0.5);
g2d.setTransform(tx1);
g2d.fillRect(0, 0, 80, 50);
AffineTransform tx2 = new AffineTransform();
tx2.translate(170, 20);
tx2.scale(1.5, 1.5);
g2d.setTransform(tx2);
g2d.fillRect(0, 0, 80, 50);
g2d.dispose();
}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
doDrawing(g);
}
}

public class ScalingEx extends JFrame {


public ScalingEx() {
initUI();
}
private void initUI() {
add(new Surface());
setTitle("Scaling");
setSize(330, 160);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

public static void main(String[] args) {


EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
ScalingEx ex = new ScalingEx();
ex.setVisible(true);
}
});
}
}

Output:
Program No. 4
Aim: Write a program to move an object using the concept of 2-D shearing
transformation.
Input:

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import javax.swing.JFrame;
import javax.swing.JPanel;

class Surface extends JPanel {


private void doDrawing(Graphics g) {
Graphics2D g2d = (Graphics2D) g.create();
AffineTransform tx1 = new AffineTransform();
tx1.translate(50, 90);
g2d.setTransform(tx1);
g2d.setPaint(Color.green);
g2d.drawRect(0, 0, 160, 50);
AffineTransform tx2 = new AffineTransform();
tx2.translate(50, 90);
tx2.shear(0, 1);
g2d.setTransform(tx2);
g2d.setPaint(Color.blue);
g2d.draw(new Rectangle(0, 0, 80, 50));
AffineTransform tx3 = new AffineTransform();
tx3.translate(130, 10);
tx3.shear(0, 1);
g2d.setTransform(tx3);
g2d.setPaint(Color.red);
g2d.drawRect(0, 0, 80, 50);
g2d.dispose();
}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
doDrawing(g);
}
}

public class ShearingEx extends JFrame {


public ShearingEx() {
initUI();
}

private void initUI() {


add(new Surface());
setTitle("Shearing");
setSize(330, 270);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

public static void main(String[] args) {


EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
ShearingEx ex = new ShearingEx();
ex.setVisible(true);
}
});
}
}

Output:
Program No. 5
Aim: Write a program to implement DDA line drawing algorithm.
Input:

import java.awt.*;
import java.applet.*;
public class DDA extends Applet {
@Override
public void paint(Graphics g) {
double dx, dy, steps, x, y, k;
double xc, yc;
double x1 = 50, y1 = 200, x2 = 250, y2 = 10;
dx = x2 - x1;
dy = y2 - y1;
if (Math.abs(dx) > Math.abs(dy))
steps = Math.abs(dx);
else
steps = Math.abs(dy);
xc = (dx / steps);
yc = (dy / steps);
x = x1;
y = y1;
g.fillOval(200, 500, 5, 5);
for (k = 1; k <= steps; k++) {
x = x + xc;
y = y + yc;
g.fillOval((int) x, (int) y, 5, 5);
}
}
}
Output:
Program No. 6
Aim: Write a program to implement Bresenhams line drawing algorithm.
Input:

import java.applet.*;
import java.awt.*;
public class Bresenham extends Applet {
@Override
public void paint(Graphics g) {
int x, y, k;
double dx, dy, p;
int x1 = 50, y1 = 50, x2 = 250, y2 = 250;
dx = Math.abs(x2 - x1);
dy = Math.abs(y2 - y1);
x = x1;
y = y1;
p = 2 * dy - dx;
g.fillOval(200, 300, 5, 5);
for (k = 0; k < dx; k++) {
if (p < 0) {
g.fillOval(x++, y, 5, 5);
p = p + (2 * dy);
} else {
g.fillOval(x++, y++, 5, 5);
p = p + (2 * (dy - dx));
}
}
}
}
Output:
Program No. 7
Aim: Write a program to implement Bresenhams circle drawing
algorithm.
Input:

import java.awt.*;
import java.applet.*;
public class Brescir1 extends Applet
{
@Override
public void paint(Graphics g)
{
int xc,yc,r;
xc=125;
yc=125;
r=60;
int x=0;
int y=r;
int p=3-2*r;
do
{
if(p<0)
p=p+4*x+6;
else
{
p=p+4*(x-y)+10;
y=y-1;
}
x=x+1;
g.drawLine(xc+x,yc+y,xc+x,yc+y);
g.drawLine(x+xc,yc-y,xc+x,yc-y);
g.drawLine(xc-x,yc+y,xc-x,yc+y);
g.drawLine(xc-x,yc-y,xc-x,yc-y);
g.drawLine(xc+y,yc+x,xc+y,yc+x);
g.drawLine(xc+y,yc-x,xc+y,yc-x);
g.drawLine(xc-y,yc+x,xc-y,yc+x);
g.drawLine(xc-y,yc-x,xc-y,yc-x);
}
while(x<y);
}
}

Output:

You might also like