Tampilkan postingan dengan label Pemograman Komputer Grafis. Tampilkan semua postingan
Tampilkan postingan dengan label Pemograman Komputer Grafis. Tampilkan semua postingan

Selasa, 26 Mei 2015

Umumnya persamaan garis lurus pada koordinat kartesius diwujudkan dalam
persamaan garis : y=m.x+b. Jika dimisalkan pada dua titik(x0,y0 dan x1,y1) akan
dibuat sebuah garis lurus, kita dapat menentukan nilai �m� dan �b� dengan
persamaan berikut:
m= y1-y0 / x1-x0
b=y1 � m.x1
Algoritma untuk menggambar garis pada komputer didasarkan pada dua
persamaan di atas. dimana m adalah gradien atau kemiringan garis tersebut.

1.Algoritma DDA
             Algoritma digital differential analyzer(DDA), Prinsip algoritma ini adalah mengambil
nilai integer terdekat dengan jalur garis berdasarkan atas sebuah titik yang telah
ditentukan sebelumnya(titik awal garis).
Algoritma pembentukan garis DDA:
1. Tentukan dua titik yang akan dihubungkan dalam pembentukan garis.
2. Tentukan salah satu titik sebagai awal(x_awal,y_awal) dan titik
     akhir(x_akhir,y_akhir).
3. Hitung Dx=x_akhir � x_awal, dan Dy= y_akhir � y_awal.
4. Tentukan langkah, yaitu dengan cara jarak maksimum jumlah penambahan
     nilai x maupun nilai y, dengan cara:
5. Bila nilai absolut dari Dx lebih besar dari absolut Dy, maka langkah= absolut
     dari Dx.
6. Bila tidak maka langkah= absolut dari Dy
7. Hitung penambahan koordinat pixel yaitu x_increment=Dx/langkah,dan y_increment=Dy/langkah
8. Koordinat selanjutnya (x_awal+x_increment, y_awal+y_increment)
9. Gambar pixel di (x_awal, y_awal)
10. Ulangi nomor 8 dan 9 sampai x=x_akhir dan y=y_akhir.



Untuk lebih jelasnya bisa dilihat pada contoh program disini


2.Algoritma Bressenham

       Tidak seperti Algoritma DDA, Algoritma Bressenham tidak membulatkan nilai posisi
pixel setiap waktu. Algoritma Bressenham hanya menggunakan penambahan nilai
integer yang juga dapat diadaptasi untuk menggambar lingkaran.
Berikut ini langkah langkah untuk membentuk garis menurut algoritma Bressenham:
1. Tentukan dua titik yang akan dihubungkan
2. Tentukan salah satu titik sebagai titik awal yaitu (x_awal,y_awal) dan titik
     lainnya sebagai titik akhir(x_akhir,y_akhir).
3. Hitung Dx = x_akhir-x_awal, Dy = y_akhir � y_awal.
4. Hitung parameter = (2Dy) � Dx
5. Jika parameter kurang dari 0, maka parameter = parameter + (2 * Dy).
6. Jika tidak maka y_awal = y_awal +1 dan parameter = parameter + (2 * Dy) �(2 * Dx).
7. Gambar pixel di (x_awal, y_awal)
8. x= x+1
9. Ulangi langkah nomor 5-8 sampai x_awal = x_akhir.

untuk implementasinya bisa di lihat di sini

3.Algoritma Mid Point

Pada algoritma ini pembuatan lingkaran dilakukan dengan menentukan satu titik
awal. Bila titik awal pada lingkaran(x,y) maka terdapat tiga posisi lain, sehingga
dapat diperoleh delapan titik. Dengan demikian sebenarnya hanya diperlukan untuk
menghitung segmen 45� dalama menentukan lingkaran selengkapnya.
Algoritma Lingkaran Midpoint juga disebut algoritma lingkaran Bressenham.
Bressenham mengembangkan generator lingkaran yang cukup efisien. Algoritma
yang digunakan membentuk semua titik berdasarkan titik pusat dengan
penambahan semua jalur sekeliling lingkaran. Algoritma ini diturunkan dari algoritma
Midpoint untuk pembentukan garis. Dalam hal ini hanya diperhatikan bagian 45� dari
suatu lingkaran dan menggunakan CirclePoints untuk menampilkan titik dari seluruh
lingkaran.
Langkah langkah untuk membentuk lingkaran algoritma Midpoint:
1. Tentukan jari-jari dengan titk pusat lingkaran(x_pusat,y_pusat) kemudian diperoleh (x,y)=(0,r)
2. Hitung nilai dari parameter = p = 1-r
3. Gambar pixel pada delapan titik utama, yaitu :
    (x_pusat + x, y_pusat+y)
    (x_pusat � x, y_pusat+y)
    (x_pusat + x, y_pusat-y)
    (x_pusat � x, y_pusat-y)
    (x_pusat + y, y_pusat+x)
    (x_pusat � y, y_pusat+x)
    (x_pusat + y, y_pusat-x)
    (x_pusat � y, y_pusat-x)
    kemudian x = x+1
4. Jika p<0 maka p = p + ( 2x ) + 6
5. Jika tidak maka y = y-1 dan p = p + 2 * ( x-y ) +1
6. Ulangi No. 3 � 5 sampai x = y
Elips merupakan modifikasi dari bentuk lingkaran, dengan memasukkan mayor dan
minor axis pada prosedur lingkaran. Elips ditentukan oleh satu set titik dengan
memperhitungkan jumlah jarak dari kedua posisi.

sekian dulu ya...kita jumpa lagi di lain kesempatan.Daaaaaahhhhhh.....

 Selamat siang pemirsa....!!
mau bagi bagi tugas lagi nich,hehehe....
program ini adalah tugas saya di kuliah Pemrograman Komputer Grafis membuat Garis dengan Algoritma Bressenham.Mungkin masih kurang sempurna,tapi lumayan bisa buat referensi teman teman yang mungkin lagi sibuk Ubek ubek google.program ini saya buat pake java netbeans dengan plugin OpenGL.Kalau belum ngerti cara pake OpenGL di Netbeans,bisa dibaca di sini

Langsung saja di simak source programnya


import com.sun.opengl.util.Animator;

import java.awt.Frame;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import javax.media.opengl.GL;

import javax.media.opengl.GLAutoDrawable;

import javax.media.opengl.GLCanvas;

import javax.media.opengl.GLEventListener;

import javax.media.opengl.glu.GLU;



public class Bressenham implements GLEventListener {


public static void main(String[] args) {

Frame frame = new Frame("Bressenham");

GLCanvas canvas = new GLCanvas();


canvas.addGLEventListener(new Bressenham());

frame.add(canvas);

frame.setSize(640, 480);

final Animator animator = new Animator(canvas);

frame.addWindowListener(new WindowAdapter() {


@Override

public void windowClosing(WindowEvent e) {

// Run this on another thread than the AWT event queue to

// make sure the call to Animator.stop() completes before

// exiting

new Thread(new Runnable() {


public void run() {

animator.stop();

System.exit(0);

}

}).start();

}

});

// Center frame

frame.setLocationRelativeTo(null);

frame.setVisible(true);

animator.start();

}


public void init(GLAutoDrawable drawable) {

// Use debug pipeline

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


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.

}


public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {

GL gl = drawable.getGL();

GLU glu = new GLU();


if (height <= 0) { // avoid a divide by zero error!



height = 1;

}

final float h = (float) width / (float) height;

gl.glViewport(0, 0, width, height);

gl.glMatrixMode(GL.GL_PROJECTION);

gl.glLoadIdentity();

glu.gluPerspective(11000.0f, h, 1.0, 20.0);

gl.glMatrixMode(GL.GL_MODELVIEW);

gl.glLoadIdentity();

}


public void display(GLAutoDrawable drawable) {

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();


// Menggambar Garis Putus Putus Bawah

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

gl.glPointSize(12.0f);

int p1x=40;

int p1y=15;

int p2x=45;

int p2y=15;

int dx=Math.abs(p2x-p1x);

int dy=Math.abs(p2y-p1y);

int pk=2*dy-dx;

int k;

for (int x=0;x<10;x++){



for (k=40;k<p2x;k++){

if (pk<=0){

pk=pk+2*dy;

p1x-=1;



gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p1x, p1y-4);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p1x, p1y-25);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p1x, p1y-25-20);

gl.glEnd();

gl.glFlush();

}else {

pk=pk+(2*dy)-(2*dx);

p1x-=1;

p1y-=1;



gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p1x, p1y-4);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p1x, p1y-25);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p1x, p1y-25-20);

gl.glEnd();



gl.glFlush();

}

}

p1x-=10;

} // Menggambar Garis Putus Miring Kanan

int p3x=5;

int p3y=5;

int p4x=10;

int p4y=10;

int dx2=Math.abs(p4x-p3x);

int dy2=Math.abs(p4y-p3y);

int pk2=2*dy2-dx2;

int k2;

gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p3x+2, p3y+2);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p3x+2-10, p3y+2-10);

for (k2=p3x;k2<p4x;k2++){

if (pk2<=0){

pk2=pk2+2*dy2;

p3x-=1;



gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p3x, p3y);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p3x-10, p3y-10);





gl.glEnd();

gl.glFlush();

}else {

pk2=pk2+(2*dy2)-(2*dx2);

p3x-=1;

p3y-=1;



gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p3x, p3y);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p3x-10, p3y-10);







gl.glEnd();

gl.glFlush();

}

}

int p5x=-10;//menggambar garis putus putus miring ke kiri

int p5y=-10;

int p6x=-3;

int p6y=-17;

int dx3=Math.abs(p6x-p5x);

int dy3=Math.abs(p6y-p5y);

int pk3=2*dy3-dx3;

int k3;

gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p5x, p5y);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p6x, p6y);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p6x+9, p6y-9);


for (k3=-7;k3<p6x;k3++){

if (pk3<=0){

pk3=pk3+2*dy3;

p5x+=1;

gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p3x, p3y);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p5x+9, p5y-9);





gl.glEnd();

gl.glFlush();

}else {

pk3=pk3+(2*dy3)-(2*dx3);

p5x+=1;

p5y-=1;

gl.glBegin(GL.GL_POINTS);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p5x, p5y);

gl.glColor3f(1.0f, 0.0f, 0.0f);

gl.glVertex2f(p5x+9, p5y-9);





gl.glEnd();

gl.glFlush();

}

}



}


public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {

}

}

hehehehe....pusing gak bacanya ?hehehehe....
kalau di running jadinya seperti ini





sekian dulu ya....kita jumpa lagi di lain kesempatan.daaaahhhhhhh..........
Selamat malam pemirsa, tulisan ini merupakan tulisan yang saya pindah dari blog saya yang lama.

Sobat Pernah Belajar Pemrograman grafis dengan OpenGL...??
kira kira mudah Gak ??

hehehe...sebenarnya ini pengalaman pribadi saya waktu ada kuliah Pemrograman Komputer Grafis.Naah...dosen saya ternyata ngajaknya main main di OpenGL.berhubung saya kurang faham OpenGL saya mencoba cari cari informasi cara ngawinin OpenGL sama Netbeans soalnya saya baru bisa dikit dikit pake java.Untungnya Om Saya (Google) bisa jawab kegalauan saya.Saya di Kasih tau soal JOGL.

Apa itu JOGL..??
JOGL adalah library OpenGL untuk java yang biasanya dipakai di netbeans.
untuk Downloadnya silahkan download di sini.
atau kalo gak cocok dengan netbeans versi anda,bisa di download di sini.Anda bisa memilih sesuai dengan netbeans versi anda.
 ScreenShootnya seperti ini





Cara instal :
  1. jalankan Aplikasi Netbeans (Saya Menggunakan Netbeans 6.7.1, saat ini Netbeans 6.8 beta sudah di rilis)
  2. Klik �> Menu Tools �> plugins
  3. Pilih Tab Downloaded
  4. Klik tombol add Plugins.
  5. Browse ke directory tempat library Java openGL berada (yang berextensi .nbm)
  6. select all (Ctrl+A) (karena ada banyak library disana)
  7. Klik Open
  8. Install
  9. Next 10.Pilih �I accept the terms in all of the lincense agreements� Kemudian Klik Install 11.Tunggu sebentar kemudian Klik Continue 12.Tunggu sebentar kemudian klik Finish untuk merestart IDE Netbeans
Setelah JOGL terinstal pada Netbeans� pada IDE Netbeans telah disediakan demo contoh-contoh OpenGL pada Java. Muncul pada saat anda akan membuat New Project pada Netbeans.

selamat berkreasi dengan Java + OpenGL Anda.Maju terus Programmer Indonesia.
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