Tugas Rumah PBO-B: Membuat Gambar Pemandangan
Nama: Paramastri Ardiningrum
NRP: 05111740000019
Kelas: PBO-B
Tugas rumah kali ini adalah menggambar pemandangan menggunakan java dengan memanfaatkan bangun 2 dimensi seperti persegi, lingkaran, dan segitiga.
Di awal, saya membuat class-nya. Seperti di bawah ini.
Seperti yang terlihat, terdapat banyak class. Saya jabarkan dalam bentuk kodingan satu persatu.
Canvas
NRP: 05111740000019
Kelas: PBO-B
Tugas rumah kali ini adalah menggambar pemandangan menggunakan java dengan memanfaatkan bangun 2 dimensi seperti persegi, lingkaran, dan segitiga.
Di awal, saya membuat class-nya. Seperti di bawah ini.
Seperti yang terlihat, terdapat banyak class. Saya jabarkan dalam bentuk kodingan satu persatu.
Canvas
Class canvas memungkinkan kita untuk menggambar grafis sederhana menggunakan bentuk bangun 2 dimensi yang ada.
Square
Menghasilkan bentuk persegi yang bisa dimanipulasi pada kanvas
Triangle
Menghasilkan bentuk segitiga yang bisa dimanipulasi pada kanvas
Circle
Menghasilkan bentuk lingkaran yang bisa dimanipulasi pada kanvas
Setelah bentuk-bentuk tersebut selesai dikoding, saya meng-inspect satu persatu hingga tampak seperti di bawah ini:
Di situ sudah tertera elemen-elemen gambar pemandangan yang akan saya gambar supaya memudahkan.
Inspect ini memudahkan saya menata objek bangun supaya tepat pada koordinat yang saya inginkan dengan warna dan ukuran yang saya mau.
Data masing-masing bangun sudah saya dapatkan. Nah, saya lanjut dengan membuat kodingan class Picture dengan data-data yang sudah ada.
Picture
Saya menentukan koordinat masing-masing bentuk pada class ini supaya sesuai dengan gambar yang ingin saya hasilkan. Selain itu juga dilakukan manipulasi warna dan ukuran.
Setelah class picture selesai saya buat, saya compile hingga run dan hasilnya seperti ini!
import javax.swing.*;
import java.awt.*;
import java.util.List;
import java.util.*;
/**
* Canvas is a class to allow for simple graphical drawing on a canvas.
* This is a modification of the general purpose Canvas, specially made for
* the BlueJ "shapes" example.
*
* @author Paramastri A
* @version 16/9/2018
*/
public class Canvas
{
// Note: The implementation of this class (specifically the handling of
// shape identity and colors) is slightly more complex than necessary. This
// is done on purpose to keep the interface and instance fields of the
// shape objects in this project clean and simple for educational purposes.
private static Canvas canvasSingleton;
/**
* Factory method to get the canvas singleton object.
*/
public static Canvas getCanvas()
{
if(canvasSingleton == null) {
canvasSingleton = new Canvas("BlueJ Shapes Demo", 300, 300,
Color.white);
}
canvasSingleton.setVisible(true);
return canvasSingleton;
}
// ----- instance part -----
private JFrame frame;
private CanvasPane canvas;
private Graphics2D graphic;
private Color backgroundColor;
private Image canvasImage;
private List<Object> objects;
private HashMap<Object, ShapeDescription> shapes;
/**
* Create a Canvas.
* @param title title to appear in Canvas Frame
* @param width the desired width for the canvas
* @param height the desired height for the canvas
* @param bgColor the desired background color of the canvas
*/
private Canvas(String title, int width, int height, Color bgColor)
{
frame = new JFrame();
canvas = new CanvasPane();
frame.setContentPane(canvas);
frame.setTitle(title);
canvas.setPreferredSize(new Dimension(width, height));
backgroundColor = bgColor;
frame.pack();
objects = new ArrayList<Object>();
shapes = new HashMap<Object, ShapeDescription>();
}
/**
* Set the canvas visibility and brings canvas to the front of screen
* when made visible. This method can also be used to bring an already
* visible canvas to the front of other windows.
* @param visible boolean value representing the desired visibility of
* the canvas (true or false)
*/
public void setVisible(boolean visible)
{
if(graphic == null) {
// first time: instantiate the offscreen image and fill it with
// the background color
Dimension size = canvas.getSize();
canvasImage = canvas.createImage(size.width, size.height);
graphic = (Graphics2D)canvasImage.getGraphics();
graphic.setColor(backgroundColor);
graphic.fillRect(0, 0, size.width, size.height);
graphic.setColor(Color.black);
}
frame.setVisible(visible);
}
/**
* Draw a given shape onto the canvas.
* @param referenceObject an object to define identity for this shape
* @param color the color of the shape
* @param shape the shape object to be drawn on the canvas
*/
// Note: this is a slightly backwards way of maintaining the shape
// objects. It is carefully designed to keep the visible shape interfaces
// in this project clean and simple for educational purposes.
public void draw(Object referenceObject, String color, Shape shape)
{
objects.remove(referenceObject); // just in case it was already there
objects.add(referenceObject); // add at the end
shapes.put(referenceObject, new ShapeDescription(shape, color));
redraw();
}
/**
* Erase a given shape's from the screen.
* @param referenceObject the shape object to be erased
*/
public void erase(Object referenceObject)
{
objects.remove(referenceObject); // just in case it was already there
shapes.remove(referenceObject);
redraw();
}
/**
* Set the foreground color of the Canvas.
* @param newColor the new color for the foreground of the Canvas
*/
public void setForegroundColor(String colorString)
{
if(colorString.equals("red")) {
graphic.setColor(Color.red);
}
else if(colorString.equals("black")) {
graphic.setColor(Color.black);
}
else if(colorString.equals("blue")) {
graphic.setColor(Color.blue);
}
else if(colorString.equals("yellow")) {
graphic.setColor(Color.yellow);
}
else if(colorString.equals("green")) {
graphic.setColor(Color.green);
}
else if(colorString.equals("magenta")) {
graphic.setColor(Color.magenta);
}
else if(colorString.equals("white")) {
graphic.setColor(Color.white);
}
else {
graphic.setColor(Color.black);
}
}
/**
* Wait for a specified number of milliseconds before finishing.
* This provides an easy way to specify a small delay which can be
* used when producing animations.
* @param milliseconds the number
*/
public void wait(int milliseconds)
{
try
{
Thread.sleep(milliseconds);
}
catch (Exception e)
{
// ignoring exception at the moment
}
}
/**
* Redraw ell shapes currently on the Canvas.
*/
private void redraw()
{
erase();
for(Object shape : objects) {
shapes.get(shape).draw(graphic);
}
canvas.repaint();
}
/**
* Erase the whole canvas. (Does not repaint.)
*/
private void erase()
{
Color original = graphic.getColor();
graphic.setColor(backgroundColor);
Dimension size = canvas.getSize();
graphic.fill(new Rectangle(0, 0, size.width, size.height));
graphic.setColor(original);
}
/************************************************************************
* Inner class CanvasPane - the actual canvas component contained in the
* Canvas frame. This is essentially a JPanel with added capability to
* refresh the image drawn on it.
*/
private class CanvasPane extends JPanel
{
public void paint(Graphics g)
{
g.drawImage(canvasImage, 0, 0, null);
}
}
/************************************************************************
* Inner class CanvasPane - the actual canvas component contained in the
* Canvas frame. This is essentially a JPanel with added capability to
* refresh the image drawn on it.
*/
private class ShapeDescription
{
private Shape shape;
private String colorString;
public ShapeDescription(Shape shape, String color)
{
this.shape = shape;
colorString = color;
}
public void draw(Graphics2D graphic)
{
setForegroundColor(colorString);
graphic.fill(shape);
}
}
}
Square
Menghasilkan bentuk persegi yang bisa dimanipulasi pada kanvas
import java.awt.*;
/**
* A square that can be manipulated and that draws itself on a canvas.
*
* @author Paramastri A
* @version 16/9/2018
*/
public class Square
{
private int size;
private int xPosition;
private int yPosition;
private String color;
private boolean isVisible;
/**
* Create a new square at default position with default color.
*/
public Square()
{
size = 30;
xPosition = 0;
yPosition = 0;
color = "red";
isVisible = false;
}
/**
* Make this square visible. If it was already visible, do nothing.
*/
public void makeVisible()
{
isVisible = true;
draw();
}
/**
* Make this square invisible. If it was already invisible, do nothing.
*/
public void makeInvisible()
{
erase();
isVisible = false;
}
/**
* Move the square a few pixels to the right.
*/
public void moveRight()
{
moveHorizontal(20);
}
/**
* Move the square a few pixels to the left.
*/
public void moveLeft()
{
moveHorizontal(-20);
}
/**
* Move the square a few pixels up.
*/
public void moveUp()
{
moveVertical(-20);
}
/**
* Move the square a few pixels down.
*/
public void moveDown()
{
moveVertical(20);
}
/**
* Move the square horizontally by 'distance' pixels.
*/
public void moveHorizontal(int distance)
{
erase();
xPosition += distance;
draw();
}
/**
* Move the square vertically by 'distance' pixels.
*/
public void moveVertical(int distance)
{
erase();
yPosition += distance;
draw();
}
/**
* Slowly move the square horizontally by 'distance' pixels.
*/
public void slowMoveHorizontal(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
xPosition += delta;
draw();
}
}
/**
* Slowly move the square vertically by 'distance' pixels.
*/
public void slowMoveVertical(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
yPosition += delta;
draw();
}
}
/**
* Change the size to the new size (in pixels). Size must be >= 0.
*/
public void changeSize(int newSize)
{
erase();
size = newSize;
draw();
}
/**
* Change the color. Valid colors are "red", "yellow", "blue", "green",
* "magenta" and "black".
*/
public void changeColor(String newColor)
{
color = newColor;
draw();
}
/**
* Draw the square with current specifications on screen.
*/
private void draw()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.draw(this, color,
new Rectangle(xPosition, yPosition, size, size));
canvas.wait(10);
}
}
/**
* Erase the square on screen.
*/
private void erase()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.erase(this);
}
}
}
Triangle
Menghasilkan bentuk segitiga yang bisa dimanipulasi pada kanvas
import java.awt.*;
/**
* A triangle that can be manipulated and that draws itself on a canvas.
*
* @author Paramastri A
* @version 16/9/2018
*/
public class Triangle
{
private int height;
private int width;
private int xPosition;
private int yPosition;
private String color;
private boolean isVisible;
/**
* Create a new triangle at default position with default color.
*/
public Triangle()
{
height = 30;
width = 40;
xPosition = 0;
yPosition = 0;
color = "green";
isVisible = false;
}
/**
* Make this triangle visible. If it was already visible, do nothing.
*/
public void makeVisible()
{
isVisible = true;
draw();
}
/**
* Make this triangle invisible. If it was already invisible, do nothing.
*/
public void makeInvisible()
{
erase();
isVisible = false;
}
/**
* Move the triangle a few pixels to the right.
*/
public void moveRight()
{
moveHorizontal(20);
}
/**
* Move the triangle a few pixels to the left.
*/
public void moveLeft()
{
moveHorizontal(-20);
}
/**
* Move the triangle a few pixels up.
*/
public void moveUp()
{
moveVertical(-20);
}
/**
* Move the triangle a few pixels down.
*/
public void moveDown()
{
moveVertical(20);
}
/**
* Move the triangle horizontally by 'distance' pixels.
*/
public void moveHorizontal(int distance)
{
erase();
xPosition += distance;
draw();
}
/**
* Move the triangle vertically by 'distance' pixels.
*/
public void moveVertical(int distance)
{
erase();
yPosition += distance;
draw();
}
/**
* Slowly move the triangle horizontally by 'distance' pixels.
*/
public void slowMoveHorizontal(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
xPosition += delta;
draw();
}
}
/**
* Slowly move the triangle vertically by 'distance' pixels.
*/
public void slowMoveVertical(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
yPosition += delta;
draw();
}
}
/**
* Change the size to the new size (in pixels). Size must be >= 0.
*/
public void changeSize(int newHeight, int newWidth)
{
erase();
height = newHeight;
width = newWidth;
draw();
}
/**
* Change the color. Valid colors are "red", "yellow", "blue", "green",
* "magenta" and "black".
*/
public void changeColor(String newColor)
{
color = newColor;
draw();
}
/**
* Draw the triangle with current specifications on screen.
*/
private void draw()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
int[] xpoints = { xPosition, xPosition + (width/2), xPosition - (width/2) };
int[] ypoints = { yPosition, yPosition + height, yPosition + height };
canvas.draw(this, color, new Polygon(xpoints, ypoints, 3));
canvas.wait(10);
}
}
/**
* Erase the triangle on screen.
*/
private void erase()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.erase(this);
}
}
}
Circle
Menghasilkan bentuk lingkaran yang bisa dimanipulasi pada kanvas
import java.awt.*;
import java.awt.geom.*;
/**
* A circle that can be manipulated and that draws itself on a canvas.
*
* @author Paramastri A
* @version 16/9/2018
*/
public class Circle
{
private int diameter;
private int xPosition;
private int yPosition;
private String color;
private boolean isVisible;
/**
* Create a new circle at default position with default color.
*/
public Circle()
{
diameter = 30;
xPosition = 0;
yPosition = 0;
color = "blue";
isVisible = false;
}
/**
* Make this circle visible. If it was already visible, do nothing.
*/
public void makeVisible()
{
isVisible = true;
draw();
}
/**
* Make this circle invisible. If it was already invisible, do nothing.
*/
public void makeInvisible()
{
erase();
isVisible = false;
}
/**
* Move the circle a few pixels to the right.
*/
public void moveRight()
{
moveHorizontal(20);
}
/**
* Move the circle a few pixels to the left.
*/
public void moveLeft()
{
moveHorizontal(-20);
}
/**
* Move the circle a few pixels up.
*/
public void moveUp()
{
moveVertical(-20);
}
/**
* Move the circle a few pixels down.
*/
public void moveDown()
{
moveVertical(20);
}
/**
* Move the circle horizontally by 'distance' pixels.
*/
public void moveHorizontal(int distance)
{
erase();
xPosition += distance;
draw();
}
/**
* Move the circle vertically by 'distance' pixels.
*/
public void moveVertical(int distance)
{
erase();
yPosition += distance;
draw();
}
/**
* Slowly move the circle horizontally by 'distance' pixels.
*/
public void slowMoveHorizontal(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
xPosition += delta;
draw();
}
}
/**
* Slowly move the circle vertically by 'distance' pixels.
*/
public void slowMoveVertical(int distance)
{
int delta;
if(distance < 0)
{
delta = -1;
distance = -distance;
}
else
{
delta = 1;
}
for(int i = 0; i < distance; i++)
{
yPosition += delta;
draw();
}
}
/**
* Change the size to the new size (in pixels). Size must be >= 0.
*/
public void changeSize(int newDiameter)
{
erase();
diameter = newDiameter;
draw();
}
/**
* Change the color. Valid colors are "red", "yellow", "blue", "green",
* "magenta" and "black".
*/
public void changeColor(String newColor)
{
color = newColor;
draw();
}
/**
* Draw the circle with current specifications on screen.
*/
private void draw()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.draw(this, color, new Ellipse2D.Double(xPosition, yPosition,
diameter, diameter));
canvas.wait(10);
}
}
/**
* Erase the circle on screen.
*/
private void erase()
{
if(isVisible) {
Canvas canvas = Canvas.getCanvas();
canvas.erase(this);
}
}
}
Setelah bentuk-bentuk tersebut selesai dikoding, saya meng-inspect satu persatu hingga tampak seperti di bawah ini:
Di situ sudah tertera elemen-elemen gambar pemandangan yang akan saya gambar supaya memudahkan.
Inspect ini memudahkan saya menata objek bangun supaya tepat pada koordinat yang saya inginkan dengan warna dan ukuran yang saya mau.
Data masing-masing bangun sudah saya dapatkan. Nah, saya lanjut dengan membuat kodingan class Picture dengan data-data yang sudah ada.
Saya menentukan koordinat masing-masing bentuk pada class ini supaya sesuai dengan gambar yang ingin saya hasilkan. Selain itu juga dilakukan manipulasi warna dan ukuran.
/**
* I draw my picture here.
*
* @author Paramastri A
* @version 16/9/2018
*/
public class Picture
{
private Triangle gunung1, gunung2, jalan;
private Circle matahari, awan1, awan2, awan3, awan4, awan5, awan6;
private Square sawah, sawah2, garisjalan1, garisjalan2, garisjalan3, garisjalan4;
public Picture()
{
}
public void draw()
{
matahari = new Circle();
matahari.changeSize(80);
matahari.moveHorizontal(20);
matahari.moveVertical(20);
matahari.changeColor("yellow");
matahari.makeVisible();
gunung1 = new Triangle();
gunung1.changeSize(100, 150);
gunung1.moveHorizontal(75);
gunung1.moveVertical(65);
gunung1.changeColor("blue");
gunung1.makeVisible();
gunung2 = new Triangle();
gunung2.changeSize(100, 150);
gunung2.moveHorizontal(225);
gunung2.moveVertical(65);
gunung2.changeColor("blue");
gunung2.makeVisible();
sawah = new Square();
sawah.changeSize(500);
sawah.moveHorizontal(105);
sawah.moveVertical(165);
sawah.changeColor("green");
sawah.makeVisible();
sawah2 = new Square();
sawah2.changeSize(150);
sawah2.moveHorizontal(0);
sawah2.moveVertical(165);
sawah2.changeColor("green");
sawah2.makeVisible();
jalan = new Triangle();
jalan.changeSize(300, 200);
jalan.moveHorizontal(150);
jalan.moveVertical(165);
jalan.changeColor("black");
jalan.makeVisible();
awan1 = new Circle();
awan1.changeSize(30);
awan1.moveHorizontal(80);
awan1.moveVertical(0);
awan1.changeColor("blue");
awan1.makeVisible();
awan2 = new Circle();
awan2.changeSize(30);
awan2.moveHorizontal(60);
awan2.moveVertical(10);
awan2.changeColor("blue");
awan2.makeVisible();
awan3 = new Circle();
awan3.changeSize(30);
awan3.moveHorizontal(80);
awan3.moveVertical(20);
awan3.changeColor("blue");
awan3.makeVisible();
awan4 = new Circle();
awan4.changeSize(30);
awan4.moveHorizontal(100);
awan4.moveVertical(20);
awan4.changeColor("blue");
awan4.makeVisible();
awan5 = new Circle();
awan5.changeSize(30);
awan5.moveHorizontal(100);
awan5.moveVertical(0);
awan5.changeColor("blue");
awan5.makeVisible();
awan6 = new Circle();
awan6.changeSize(30);
awan6.moveHorizontal(120);
awan6.moveVertical(10);
awan6.changeColor("blue");
awan6.makeVisible();
garisjalan1 = new Square();
garisjalan1.changeSize(10);
garisjalan1.moveHorizontal(145);
garisjalan1.moveVertical(200);
garisjalan1.changeColor("red");
garisjalan1.makeVisible();
garisjalan2 = new Square();
garisjalan2.changeSize(10);
garisjalan2.moveHorizontal(145);
garisjalan2.moveVertical(210);
garisjalan2.changeColor("red");
garisjalan2.makeVisible();
garisjalan3 = new Square();
garisjalan3.changeSize(10);
garisjalan3.moveHorizontal(145);
garisjalan3.moveVertical(250);
garisjalan3.changeColor("red");
garisjalan3.makeVisible();
garisjalan4 = new Square();
garisjalan4.changeSize(10);
garisjalan4.moveHorizontal(145);
garisjalan4.moveVertical(259);
garisjalan4.changeColor("red");
garisjalan4.makeVisible();
}
}
Setelah class picture selesai saya buat, saya compile hingga run dan hasilnya seperti ini!
Komentar
Posting Komentar