Powered by Blogger.
» » Membuat Garis dan Lingkaran Dengan Algoritma DDA dan Bresenham

Membuat Garis dan Lingkaran Dengan Algoritma DDA dan Bresenham

Java
Monday 30 October 2017
Belum ada komentar

Pada project ini, kami menggunakan bahasa pemrograman Java dengan tools NetBeans IDE 8.2. Berisi 4 class yaitu class Main atau class utama, class AlgoDDA (class yang berisi implementasi algoritma membuat garis menggunakan algoritma DDA), class AlgoBresenham (class yang berisi implementasi algoritma membuat garis menggunakan algoritma Bresenham), class AlgoLingkaran (class yang berisi implementasi algoritma membuat Lingkaran menggunakan algoritma Bresenham dengan beberapa modifikasi).

Implementasi algoritma yang kami tulis mungkin berbeda dengan implementasi rumus yang sebenarnya, hal ini karena kami memperbaiki bug yang ada sehingga program dapat berjalan dengan baik.

Berikut beberapa kondisi apabila Anda ingin melakukan pengecekan garis/lingkaran yang ditmpilkan di layar apakah sudah sesuai dengan koordinat atau tidak :
      
Kondisi-kondisi x dan y
  •         x1 == x2 dan  y1 == y2  tidak akan menampilkan apa-apa
  •         x1 == x2  dan y1 >  y2  menampilkan garis lurus vertikal
  •         x1 == x2 dan y1 <  y2  menampilkan garis lurus vertikal
  •         x1 >  x2 dan y1 == y2  menampilkan garis lurus horisontal
  •         x1 <  x2  dan y1 == y2  menampilkan garis lurus horisontal
  •         x1 >  x2 dan y1 >  y2  titik sebelah kanan lebih turun
  •         x1 <  x2  dan y1 >  y2  titik sebelah kiri lbh turun
  •         x1 >  x2  dan y1 <  y2  titik sebelah kiri lbh turun
  •         x1 <  x2 dan y1 <  y2  titik sebelah kiri lebih turun
  •         dx == dy
  •         dx>dy
  •         dy>dx
NB : Perlu diingat bila sumbu koordinat pada layar PC atau komputer berbeda dengan koordinat di dunia nyata atau yang biasa digunakan pada sumbu koordinat biasa, koordinat X0 dan Y0 pada PC di mulai dari sebelah kiri atas.

Untuk menampilkan layar window berupa hasil implementasi algoritma, kami menggunakan JFrame yang bisa Anda baca tutorial penggunaan nya di website berikut : Tutorial  Java JFrame silakan kunjungi website tersebut bila Anda ingin mengedit, mengurangi, atau menambah code pada project ini.

Silakan download project ini di link : Membuat Garis dan Lingkaran Dengan Algoritma DDA dan Bresenham

Main Class

 public static void main(String[] args) {
        //membuat objek baru dengan judul "Algoritma Membuat Garis"
        JFrame frame = new JFrame("Algoritma Membuat Garis");
        //  Menghentikan program saat kita menekan tombol close
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
        //membuat objek
        AlgoDDA dda = new AlgoDDA();
        AlgoBresenham brs = new AlgoBresenham();
        AlgoLingkaran o = new AlgoLingkaran();
     
        //set x dan y DDA
        dda.setx1(10);
        dda.sety1(120);
        dda.setx2(200);
        dda.sety2(60);
     
        //set x dan y bresenham
        brs.setx1(40);
        brs.sety1(50);
        brs.setx2(70);
        brs.sety2(170);
     
        //set x dan y lingkaran
        o.setxo(120);
        o.setyo(120);
        o.setjari2(100);
     
        //membuat frame
        frame.add(dda);
        frame.add(brs);
        frame.add(o);
     
        //membagi tampilan menjadi 3
        frame.setLayout(new GridLayout(1, 3));
        //mengatur ukuran dan letak frame di layar
        frame.setBounds(450,100,700,400);
     
        //mengatur icon frame
        Image icon = Toolkit.getDefaultToolkit().getImage("icons.png");
        frame.setIconImage(icon);
        //  Aktifkan untuk membuat Frame terlihat atau visible
        frame.setVisible(true);
        //Untuk mengaktifkan button maximize pada Frame
        frame.setResizable(true);
    }

Membuat garis dengan Algoritma DDA, class AlgoDDA

//import library yg dibutuhkan
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class AlgoDDA extends JPanel{
    //variable untuk menentukan x dan y
    private int x1,y1,x2,y2;
 
    //constructor DDA
    public AlgoDDA() {
    }
 
    public void setx1(int x1) {
        this.x1 = x1;
    }
    public void setx2(int x2) {
        this.x2 = x2;
    }
    public void sety1(int y1) {
        this.y1 = y1;
    }
    public void sety2(int y2) {
        this.y2 = y2;
    }
 
    @Override
    public void paint(Graphics grs) {
        int jmlLangkah,i;
        float x_inc,y_inc;
     
        int dx = x2-x1;  //mencari jarak x2 dengan x1
     
        int dy = y2-y1; //mencari jarak y2 dengan y1
     
        //dibuat atau di casting menjadi float karena variabel akan menampung nilai desimal
        float x=x1;
        float y=y1;
     
        super.paint(grs);  //menurunkan fungsi parent
        this.setBackground(Color.MAGENTA);  //warna background
        grs.setColor(Color.RED);  //warna garis
     
        //menentukan jumlah langkah untuk perulangan
        //apabila variabel adalah bilangan negatif maka diubah menjadi bilangan positif
        if(Math.abs(dx)>Math.abs(dy)){
            jmlLangkah = Math.abs(dx);
        }
        else{
            jmlLangkah = Math.abs(dy);
        }
     
        //menentukan pertambahan nilai tiap langkah
        x_inc = dx/(float)jmlLangkah;
     
        y_inc = dy/(float)jmlLangkah;
     
        //perulangan utk menggambar titik
        for(i=1;i<=jmlLangkah;i++) {
            //setiap langkah, x dan y akan mengalami pertambahan sesuai increment
            x += x_inc;
            y += y_inc;
         
            //menggambar atau mewarnai titik sesuai x dan y
            grs.drawRect(Math.round(x), Math.round(y), 1, 1);
        }
    }

Membuat garis dengan Algoritma Brasenham, class AlgoBresenham

//import library yg dibutuhkan
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class AlgoBresenham extends JPanel{
    //variable untuk menentukan x dan y
    private int x1,y1,x2,y2,p,pkd0,pld0;
    
    //constructor bresenham
    public AlgoBresenham() {
        
    }
    
    public void setx1(int x1) {
        this.x1 = x1;
    }
    public void setx2(int x2) {
        this.x2 = x2;
    }
    public void sety1(int y1) {
        this.y1 = y1;
    }
    public void sety2(int y2) {
        this.y2 = y2;
    }
    
    @Override
    public void paint(Graphics grs) {
        int x,y,endx,endy;
        
        //mencari jarak x2 dengan x1
        int dx = Math.abs(x2-x1);
        int dy = Math.abs(y2-y1);
        
        super.paint(grs); //menurunkan fungsi parent
        this.setBackground(Color.black); //warna bachround
        grs.setColor(Color.YELLOW);// warna garis
        
        //apabila jarak dx lbh besar dari dy, maka perulangan berpatokan titik x
        if(dx>=dy){
            p = 2*dy-dx;   //P awal  
            pkd0 = 2*dy;   //P selanjutnya jika P<0
            pld0 = 2*(dy-dx);  //P selanjutnya jika P>0
                
            //menentukan x, y
            //endx untuk menandai batas x dan untuk akhir perulangan
            //bila x1 lbh besar dari x2 maka awal pembuatan garis dimulai dari x2 (titik paling kiri                          menuju ke kanan)
            if (x1>x2){
                x = x2;
                y = y2;
                endx = x1;
            }else{
                x = x1;
                y = y1;
                endx = x2;
            }
            
            //perulangan membuat titik berpatokan x karena dx lbh besar dari dy
            while(x<endx){
                x++;
                
                //bila p<0 maka hanya x yg bertambah
                if(p<0) {
                    p += pkd0;
                }else{
                    //jika y lbh besar dari endy maka gambar akan semakin keatas
                    //jika endy lbh besar maka gambar akan menurun kebawah
                    if(y1>y2){
                        y--;
                    } 
                    else{ 
                        y++;
                    }    
                    
                    p+=pld0;   
                }    
            
                //menggambar titik sesuai x dan y
                grs.drawRect(x, y, 1, 1);
            }
        }
        //perulangan berpatokan sumbu y karena dy lebih besar
        else{
            p = 2*dx-dy;  //P awal 
            pkd0 = 2*dx; //P selanjutnya, jika P<0
            pld0 = 2*(dx-dy); //P selanjutnya, jika P>0
            
            //menentukan x, y
            //endy untuk menandai batas y                
            //bila x1 lbh besar dari x2 maka awal pembuatan garis dimulai dari x2 (titik paling kiri                           menuju ke kanan)
            if(y1>y2){
                x = x2;
                y = y2;
                endy = y1;
            }
            //karena y2 lebih besar dari y1
            else{
                x = x1;
                // x = 80
                // y = 30
                y = y1;
                endy = y2;
                //endy = 180
            }
            
            //perulangan membuat titik berpatokan y karena dy lbh besar dari dx
            while(y<endy){
                y++;
                
                if(p<0) {
                    p+=pkd0;
                }else{
                    //jika x lbh besar dari endx maka gambar akan semakin keatas
                    //jika endx lbh besar maka gambar akan menurun kebawah
                    if(x1>x2){
                        x--;
                    }else{
                        x++;
                    }
                    
                    p+=pld0;
                }
                
                //menggambar titik sesuai x dan y
                grs.drawRect(x, y, 1, 1);
            }
        }
    }
}

Membuat Lingkaran dengan modifikasi dari Algoritma Bresenham, class AlgoLingkaran

// library yang di butuhkan
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class AlgoLingkaran extends JPanel{    
    int xo,yo,jari2;

    public AlgoLingkaran(){
        
    }
    
    public void setxo(int x) {
        xo = x;
    }
    public void setyo(int y) {
        yo = y;
    }
    public void setjari2(int jari2) {
        this.jari2 = jari2;
    }

    @Override
    public void paint(Graphics grs) {     
        int p =  1-jari2;
        int x; 
        int y = jari2;
        
        super.paint(grs);
        this.setBackground(Color.GREEN);
        grs.setColor(Color.blue);
        
        //perulangan dr x sampai y maka
        for(x=0;x<=y;x++) {
            
            if(p<0){
               p+=2*x+1;
            }else{
                y--;
                p+=2*(x-y)+1;
            }
            
            //langkah pencerminan
            //langkah menggambar atau mewarnai pixel sesuai x dan y
            grs.drawRect(xo+x, yo+y, 1, 1);
            grs.drawRect(xo-x, yo+y, 1, 1);
            grs.drawRect(xo+x, yo-y, 1, 1);
            grs.drawRect(xo-x, yo-y, 1, 1);
            grs.drawRect(xo+y, yo+x, 1, 1);
            grs.drawRect(xo-y, yo+x, 1, 1);
            grs.drawRect(xo+y, yo-x, 1, 1);
            grs.drawRect(xo-y, yo-x, 1, 1);
        }
    }
}

Kami akan sangat berterima kasih bila Anda mau mempelajari, memahami, serta mengembangkan program yang kami buat atau menemukan Bug kemudian membagikan pengalaman Anda di kolom komentar.

Sekian dari postingan Membuat Garis dan Lingkaran Dengan Algoritma DDA dan Bresenham kami ini, semoga bermanfaat bagi para pembaca sekian dan sampai jumpa di postingan selanjutnya.
Apabila kalian ingin menyebarluaskan atikel ini mohon untuk mencantumkan link blog Project Kami. Jika postingan ini bermanfaat langsung saja bookmark halaman ini di web browser kalian, dengan cara menekan Ctrl + D pada keyboard.

Postingan Terbaru:

Tulislah Komentar atau pertanyaan disini !
Gunakan pilihan Anonymous jika kamu tidak punya akun apapun :)