Langsung ke konten utama

Implementasi Algoritma MidPoint di java Untuk Lingkaran

Selamat malam pemirsa, malam ini mumpung lagi agak males ngapa ngapain saya mau bersih bersih blog. Tulisan ini sebenarnya sudah saya tulis lama banget di blog saya yang lama dan kali ini saya pindah ke yang baru biar kumpul. Langsung aja ke TEKAPE...

lingkaran ini memang hanya lingkaran.tapi proses pembuatannya itu yang bikin kepala puyeng.Ini sebenarnya tugas di pemrograma grafik mungkin bisa di jadikan referensi buat teman teman yang sedang membutuhkan.
oke cekidot....

Algoritma mid Point adalah algoritma untuk membuat lingkaran.Jika masih belum begitu faham bisa di baca di Sini.
untuk implementasinya dengan java seperti di bawah ini.Koding berikut bukan full dari koding yang saya buat.Hanya saya masukkan intinya saja supaya anda bisa berkreasi sendiri dengan ide kreatif anda.



public void midpoint(GLAutoDrawable drawable,int radius,int xcenter,int ycenter){//method untuk algoritma midpoint
        Lingkaran c = new Lingkaran();
        GLCanvas canvas = new GLCanvas();
       GL gl = drawable.getGL();
        int x1 = 0;
        int y1 = radius;
        int p = 1 - radius;
        c.displ(drawable, x1, y1, xcenter, ycenter);

  for(int x=0;x<=y1;x++){
     x1+=1;
  if (p < 0) {
   p += 2 * x1 + 1;
  } else {
   y1 = y1 - 1;
   p += 2 * (x1 - y1) + 1;
  }

c.displ(drawable, x1, y1, xcenter, ycenter);
  }
    }

public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
 gl.glLoadIdentity();
 gl.glTranslatef(0.0f, 0.0f, -20.0f);
 gl.glPointSize(1.5f);
        Lingkaran s=new Lingkaran();       s.midpoint(drawable,jari_jari,xtengah,ytengah); b.putus_horisontal(drawable,40,40,40,45);
        gl.glEnd();
        gl.glFlush(); 
    }

    public void displ(GLAutoDrawable drawable,int x1,int y1,int xcenter,int ycenter) {
         GL gl = drawable.getGL();
 gl.glBegin(GL.GL_POINTS);
     gl.glColor3f(1.0f, 0.0f, 0.0f);
  gl.glVertex2i(xcenter + x1, ycenter + y1);
  gl.glVertex2i(xcenter - x1, ycenter + y1);
  gl.glVertex2i(xcenter + x1, ycenter - y1);
  gl.glVertex2i(xcenter - x1, ycenter - y1);
  gl.glVertex2i(xcenter + y1, ycenter + x1);
  gl.glVertex2i(xcenter - y1, ycenter + x1);
  gl.glVertex2i(xcenter + y1, ycenter - x1);
  gl.glVertex2i(xcenter - y1, ycenter - x1);
 gl.glEnd();
 gl.glFlush();
    }

koding di atas merupakan koding utama dari program membuat lingkaran.sebenarnya masih banyak method method lain yang merupakan method bawaan dari JOGL.Berikut ini program yang sudah saya build jadi file jar sehingga bisa langsung di jalankan.Bisa di download Di Sini.
jika di jalankan kurang lebih seperti ini




file tersebut merupakan gabungan dari 3 bangun geometri yaitu garis dengan algoritma bressenham,lingkaran dan elips dengan algoritma Mid Point.Untuk implementasi di Elips seperti kode di bawah ini


public void init(GLAutoDrawable drawable) {//method untuk mengisi nilai

       try{// Use debug pipeline

        // drawable.setGL(new DebugGL(drawable.getGL()));

        String str = JOptionPane.showInputDialog ("Masukkan Lebar Horisontal");

        int x=Integer.parseInt(str);

        String str1 = JOptionPane.showInputDialog ("Masukkan Lebar Vertikal");

        int x1=Integer.parseInt(str1);

        String str2 = JOptionPane.showInputDialog ("Masukkan x titik tengah");

        int y=Integer.parseInt(str2);

        String str3 = JOptionPane.showInputDialog ("Masukkan y titik tengah");

        int z=Integer.parseInt(str3);

        this.jari_hor=x;

        this.jari_ver=x1;

        this.xtengah=y;

        this.ytengah=z;

        GL gl = drawable.getGL();

        System.err.println("INIT GL IS: " + gl.getClass().getName());


        // Enable VSync

        gl.setSwapInterval(1);


        // Setup the drawing area and shading mode

        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

        gl.glShadeModel(GL.GL_SMOOTH); // try setting this to GL_FLAT and see what happens.

    }catch(Exception e){

        JOptionPane.showMessageDialog(null, e);

        Elips l=new Elips();

        l.init(drawable);

    }

    }


public void elips(GLAutoDrawable drawable,int Rx,int Ry,int xCentre,int yCentre){//mid point untuk elips

        Elips e= new Elips();

        GL gl = drawable.getGL();

        int p, px, py, x = 0, y = 0, Ry2, Rx2, twoRx2, twoRy2;

       

       

        Ry2 = Ry * Ry;

    Rx2 = Rx * Rx;

    twoRy2 = 2 * Ry2;

    twoRx2 = 2 * Rx2;


        x = 0;

    y = Ry;

    px = 0;

    py = twoRx2 * y;


       if ((2*Ry*Ry*x) < (2*Rx*Rx*y)) {

        p = (int) Math.round(Ry2 - Rx2 * Ry + (0.25 * Rx2));

       

      e.piksel(drawable, x, y, xCentre, yCentre);

       

        while (px < py){

            x++;

            px += twoRy2;

            if (p<0){

             p +=Ry2 + px;  

            }else{

                y --;

   py -= twoRx2;

   p += Ry2 + px - py;

            }

           e.piksel(drawable, x, y, xCentre, yCentre);

        }

    }

p = (int)Math.round(Ry2*(x+0.5)*(x+0.5)+Rx2*(y-1)*(y-1)- Rx2*Ry2);

        while (y>0){

            y--;

            py -=twoRx2;

            if ( p > 0){

  p += Rx2 - py;

        } else {

  x++;

  px += twoRy2;

  p += Ry2 + px - py;

  }

            e.piksel(drawable, x, y, xCentre, yCentre);

        }

            }

    public void piksel(GLAutoDrawable drawable,int x,int y,int xCentre,int yCentre){//method untuk membangkitkan piksel

        GL gl= drawable.getGL();

       

        gl.glBegin(GL.GL_POINTS);

        gl.glVertex2i(xCentre+x, yCentre+y);

        gl.glVertex2i(xCentre-x, yCentre+y);

        gl.glVertex2i(xCentre+x, yCentre-y);

        gl.glVertex2i(xCentre-x, yCentre-y);

        gl.glEnd();

        gl.glFlush();

       

    }

    public void display(GLAutoDrawable drawable) {//method yang pertama di jalankan

        GL gl = drawable.getGL();


        // Clear the drawing area

        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

        // Reset the current matrix to the "identity"

        gl.glLoadIdentity();

        gl.glPointSize(2);


        // Move the "drawing cursor" around

        gl.glTranslatef(-1.5f, 0.0f, -6.0f);


        Elips e=new Elips();

        e.elips(drawable,jari_hor,jari_ver,xtengah,ytengah );

    }

koding di atas memang bukan keseluruhan dari koding yang saya buat.Silahkan berexsperimen dengan ide kreatif anda.saya yakin kita bisa......

Kalau dosen aja bisa...kenapa kita tidak...???
Maju terus programer Indonesia

Jika ada Uneg Uneg bisa disampaikan di kolom komentar terima kasih
Label:

Komentar

  1. Unknown16 Mei 2016 pukul 14.22

    pas di download pkgnya kok ga ada file yg existensinya java?

    BalasHapus
  2. Nur Hidayatullah16 Mei 2016 pukul 16.20

    kalo gak salah itu file yang sudah jadi .jar aja, kalau untuk source code lengkap bisa saya kirim via email

    BalasHapus
  3. Unknown1 November 2017 pukul 18.33

    mas ada skrip codenya yang lengkap ngak ? kalo ada plese kasih tau kirim email. ficky596@gmail.com

    BalasHapus
    Balasan
    1. Nur Hidayatullah2 November 2017 pukul 09.16

      sudah kehapus gan, itu yang saya tulis sudah lengkap kok, tinggal di praktekin aja pasti jalan, jangan lupa baca tulisan saya yang lain tentang setting OPEL GL di Netbeans

      Hapus
  4. Shiltz29 Maret 2018 pukul 11.41

    Link download nya sudah tdak berlaku.

    BalasHapus

Posting Komentar

Postingan populer dari blog ini

Contoh Perhitungan Algoritma Perceptron

      Melanjutkan tulisan saya sebelumnya tentang algoritma perceptron,kali ini saya akan menulis tentang conto perhitungan manual algoritma perceptron. Untuk contoh kasusnya saya menggunakan data logika AND. Cekidot.... Algoritma      Data yang kita gunakan sebagai contoh adalah data logika AND sebagai berikut: x1 x2 target 0 0 0 0 1 0 1 0 0 1 1 1       tentukan bobot awal secara acak, saya pakai contoh w1 = 0,w2 =0, learning rate = 1, bias = 0,maksimal epoh = 10. Disini saya memakai fungsi aktivasi undak biner. Epoh ke 1 Data ke satu x = {0,0}, bobot w = {0,0},b=0,target = 0 y_in = (x1*w1)+(x2*w2)+b = (0*0)+(0*0)+0 = 0 y = sign(0) = 1 karena y != target maka hitung error dan update bobot  error = target - y = 0 - 1 = -1 w1_baru = w1_lama +(learning_rate*error*x1)                = 0 + (1*(-1)*0) = 0 w2_baru = w2_lama +(learning_rate*error*x2)                = 0+(1*(-1)*0) = 0
12 komentar
Baca selengkapnya

Pemrograman Berorientasi Object - Overloading dan Overriding

       Function atau method overloading dan override adalah fitur yang sangat mendasar dan berguna dari bahasa OOP manapun. Dalam tutorial ini kita akan membahas implementasi metode overloading dan override di php. Di sini pertama kita akan membahas dasar-dasar overloading dan override. Setelah eksplorasi dasar kita akan menerapkan overloading dan override di php. Sebelum melangkah lebih jauh, saya mengasumsikan bahwa Anda memiliki pengetahuan dasar tentang class dan pewarisan di php. Anda juga memiliki pemahaman tentang magic method di php. Magic method karena overloading di php bisa di implmentasikan dengan menggunakan magic method. Overriding        Arti dasar dari overriding di OOP sama dengan arti kata sebenarnya. Dalam arti kata sebenarnya dari overriding adalah menggantikan perilaku orang tua yang sama pada anak. Ini sama dengan override method di OOP. Dalam arti OOP, override adalah mengganti method class induk di class anak. Atau dengan method kata kunci sederhana yang me
1 komentar
Baca selengkapnya

Contoh Perhitungan Algoritma Learning Vector Quantization

Melanjutkan tulisan saya tentang algoritma Learning Vector Quantization yang lalu, kali ini saya akan melanjutkan dengan contoh perhitungan manual. Berikut ini contoh data yang akan kita hitung. No X1 X2 X3 X4 target 1 0 1 1 0 0 2 0 0 1 1 1 3 1 1 1 1 0 4 1 0 0 1 1 pada contoh di atas, saya menggunakan 4 data sebagai data training beserta target yang bertujuan untuk mendapatkan bobot yang akan digunakan pada proses klasifikasi. Bobot awal adalah { 1, 1, 1, 0} dan { 1, 0, 1, 1} dengan learning rate 0,05 dengan fungsi pembelajaran = 0,1. Pelatihan Iterasi ke 1 1. Data ke 1 { 0, 1, 1, 0} dengan target 0, bobot = {{ 1, 1, 1, 0},{ 1, 0, 1, 1}}      - menghitung bobot untuk masing masing output :          kelas 0 = sqrt(((0-1)^2)+((1-1)^2)+((1-1)^2)+((0-0)^2)) = 1         kelas 1 = sqrt(((0-1)^2)+((1-0)^2)+((1-
38 komentar
Baca selengkapnya