Implementasi Algoritma MidPoint di java Untuk Lingkaran - Hallo sahabat Dev-Create, Pada Artikel yang anda baca kali ini dengan judul Implementasi Algoritma MidPoint di java Untuk Lingkaran, kami telah mempersiapkan artikel ini dengan baik untuk anda baca dan ambil informasi didalamnya. mudah-mudahan isi postingan Artikel Java, Artikel Pemograman Komputer Grafis, yang kami tulis ini dapat anda pahami. baiklah, selamat membaca.

Judul : Implementasi Algoritma MidPoint di java Untuk Lingkaran
link : Implementasi Algoritma MidPoint di java Untuk Lingkaran

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

Demikianlah Artikel Implementasi Algoritma MidPoint di java Untuk Lingkaran

Sekianlah artikel Implementasi Algoritma MidPoint di java Untuk Lingkaran kali ini, mudah-mudahan bisa memberi manfaat untuk anda semua. baiklah, sampai jumpa di postingan artikel lainnya.

Anda sekarang membaca artikel Implementasi Algoritma MidPoint di java Untuk Lingkaran dengan alamat link https://dev-create.blogspot.com/2015/05/implementasi-algoritma-midpoint-di-java.html