GRAFIKA KOMPUTER

Hasil dari rendering
Bagian dari grafika komputer meliputi:
- Geometri: mempelajari cara menggambarkan permukaan bidang
- Animasi: mempelajari cara menggambarkan dan memanipulasi gerakan
- Rendering: mempelajari algoritma untuk menampilkan efek cahaya
- Citra (Imaging): mempelajari cara pengambilan dan penyuntingan gambar
Pengertian ALGORITMA
Algoritma Dasar, Algoritma Bresenham, dan Algoritma DDA pada garis lurus !
- Algoritma dasar menggambarkan piksel-piksel dalam garis lurus, parameter yang digunakan tergantung dari gradient, jika besarnya gradient diantara 0 dan 1, maka digunakan sumbu x sebagai parameter dan sumbu y sebagai hasil dari fungsi, sebaliknya, bila gradient melebihi 1, maka sumbu y digunakan sebagai parameter dan sumbu x sebagai hasil dari fungsi, hal ini bertujuan untuk menghindari terjadinya gaps karena adanya piksel yang terlewatkan. Hasil dari fungsi biasanya merupakan bilangan riil, sedangkan koordinat pixel dinyatakan dalam bilangan integer (x,y), maka diperlukan operasi pembulatan kedalam bentuk integer terdekat.
- Algoritma Bresenham merupakan perbaikan dari algoritma perhitungan koordinat piksel yang dengan cara menggantikan operasi bilangan riil perkalian dengan operasi penjumlahan, yang kemudian dikenal dengan Algoritma Bresenham. Pada algoritma bresenham, nilai y kedua dan seterusnya, dihitung dari nilai y sebelumnya, sehingga hanya titik y pertama yang perlu dilakukan operasi secara lengkap. Perbaikan algoritma ini ternyata tidak menghasilkan perbaikan yang cukup siginifikan. Perbaikan berikutnya dilakukan dengan cara menghilangkan operasi bilangan riel dengan operasi bilangan integer. Operasi bilangan integer jauh lebih cepat dibandingkan dengan operasi bilangan riel, terutama pada penambahan dan pengurangan.
- Algoritma DDA (Digitaal Diferensial Analyser) adalah pembentukan garis berdasarkan perhitungan dx maupun dy, menggunakan rumus dy=m*dx. Garis yang dibuat menggunakan endpoint, yaitu titik awal dan titik akhir, setiap koordinat titik yang membentuk garis diperoleh dari perhitungan, kemudian di konversikan menjadi nilai-nilai integer.
Menggambar Garis Sesuai Dengan Algoritmanya

Contoh Program :
Setpixel (X,Y) (X, Y)(X, Y)
Garis Horizontal
Garis Yang Membentang Secara Parallel Denagn Sumbu X Dengan Asumsi Titik P1 Pada Koordinat X1 Lebih Kecil Dari Pada X2 Dan P2 Sedangkan Y1 Dan Y2 Konstant
Algoritma:
- Menentukan Titik Awal (P1) Dan Titik Akhir (P2)
- Periksa Posisi Sumbu (Koordinat) Jika Titik Akhir < Titik Awal. Lakukan Inkrementasi Sumbu X Dari Titik Awal Sampai Titik Akhir Jika Tidak, Maka Lakukan Dekrementasi Sumbu X Dari Titik Awal Sampai Titik Akhir
- Tampilkan Garis Menggunakan Parameter Koor Dinan Yang Telah Dihitung

Garis Vertikal
Garis Yang Membentang Secara Parallel Dengan Sumbu Y Dengan Asumsi Titik P1 Pada Koordinat Y1 Lebih Kecil Daripada Y2 Dari P2, Sedangkan X1 Dan X2 Konstant.
Algoritma:
- Menentukan Titik Awal (P1) Dan Tititk Akhir (P2)
- Periksa Posisi Sumbu (Kordinat). Jika Titik < Titik Awal, Lakukan Inkrementasi Sumbu Y Dari Titik Awal Sampai Titik Akhir Jika Tidak, Maka Lakukan Dekkrementasi Sumbu Y Dari Titik Awal Sampai Titik Akhir.
- Tampilkan Garis Parameter Menggunakan Parameter Koordinat Yang Telah Dihitung.
Garis Diagonal
Garis Yang Membentang Secara Parallel 45 Derajat Dari Sumbu X Atau Sumbu Y Dengan Asumsi Titik Awal P1 Dengan Koordinant X1 Dan Y1 Lebih Kecil Dari Pada X2 Dan Y2 Atau Sebaliknya.
Algoritma:
- Menentukan Titik Awal (P1) Dan Titik Akhir (P2)
- Periksa Posisi Sumbu (Koordiat) Jika Tititk Akhir < Titik Awal. Lakukan Inkrementasi Sumbu X Dan Sumbu Y Dari Tititk Awal Sampai Titik Akhir, Jika Tidak, Maka Lakukan Dekrementasi Sumbu X Dan Sumbu Y Dari Titik Awal Sampai Titik Akhir
- Tampilkan Garis Menggunakan Parameter Koordinat Yang Dihitung.
Garis Bebas (Simple Digital Differential Analyzer/DDA)
Garis Yang Membentang Antara 2 Titik, P1 Dan P2, Selalu Membentuk Sudut YangBesarnya Sangat Bervariasi. Sudut Yang Terbentuk Menentukan Kemiringan Suatu Garis Disebut Gradient / Slop Atau Disimbolkan Dengan Parameter M. Jika Titik-Titik Yang Membetuk Garis Adalah :

Algoritma DDA Bekerja Bekerja Atas Dasar Penambahan Nilai X Dan Y. Pada Garis Lurus, Turunan Pertama Dari X Dan Y Adalah Konstanta. Sehingga Untuk Memperoleh Suatu Tampilan Dengan Ketelitian Tinggi, Suatu Garis Dapat Dibangkitkan Dengan Menambah Nilai X Dan Y Masing-Masing Sebesar E∆X Dan E∆Y, Dengan E besaran Dengan Nilai Yang Sangat Kecil. Kondisi Ideal Ini Sukar Dicapai, Karenanya Pendekatan yang Mungkin Dilakukan Adalah Berdasarkan Piksel-Piksel Yang Bisa Dialamati/Dicapai Atau Melalui Penambahan Atau Pengurangan Nilai X Dan Y Dengan Suatu Besaran Dan Membulatkannya Ke Nilai Integer Terdekat.
Algoritma Bresenham


Kondisi Awal :
Jika M < 1, Maka M Bernilai Positif Bresenham Melakukan Inkremen 1 Untuk X Dan 0 Atau 1 Untuk Y.
Jika Current Pixel (Xk,Yk)
Dimanakah Pixel Berikutnya Akan Di-Plot, Apakah Di (Xk+1, Yk+1)= (Xk+1, Yk), Atau (Xk+1, Yk+1)? Tentukan Nilai Parameter Keputusan
Algoritma Bresenham Untuk |M| < 1:
- Input 2 Endpoints, Simpan Endpoints Kiri Sebagai (X0,Y0)
- Panggil Frame Buffer (Plot Titik Pertama)
- Hitung Konstanta ∆ X, ∆Y,2∆Y,2∆Y -2∆X Dan Nilai Awal Parameter Keputusan P0=2∆ Y-∆X
Pada Setiap Xk Da Garis Dimulai Dari K=0 Ujilah:
Jika Pk<0,Plot (Xk+1,Y ) Dan Pk +1=Pk+2∆ Y Maka Plot (Xk+1 Yk) Dan Pk+1=Pk+2∆ Y – 2∆X Ulangi Tahap 4 ∆ X Kali.
Contoh
Hitunglah Posisi Piksel Hingga Membentuk Sebuah Garis Yang Menghubungkan Titik (12,10) Dan (17,14)
Jawab :
Grafika Komputer – objek garis dengan algoritma DDA dan bresenham
obejak garis dengan algoritma DDA dan bresenham …..jikalau anda ingin mempelajari lebih jauh dan mencoba coding ini anda harus mempunyai master visual studio….kayaknya kalau anda belum punya mungkin di mbaaaaaah GOOGLE banyak deh heheheheh…..
langsung saja di liat yah dan di coba hehehe…..#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdarg.h>
#include<glut.h>
#include<math.h>
void display(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0,300.0,0.0,300.0);
}
void setPixel(GLint xCoordinate, GLint yCoordinate)
{
glBegin(GL_POINTS);
glVertex2i (xCoordinate,yCoordinate);
glEnd();
glFlush();
}
void lineBres (GLint x0,GLint y0,GLint xEnd,GLint yEnd)
{
GLint dx = (float)fabs((float) xEnd – x0);
GLint dy = (float)fabs((float) yEnd – y0);
GLint p = 2* dy – dx;
GLint twoDy = 2 * dy;
GLint twoDyMinusDx = 2 *(dy-dx);
GLint x,y;
if(x0 > xEnd){
x= xEnd;
y= yEnd;
xEnd= x;
}else{
x=x0;
y=y0;
}
setPixel(x,y);
while(x<xEnd){
x++;
if(p<0)
p +=twoDy;
else{
y++;
p +=twoDyMinusDx;
}
setPixel(x,y);
}
}
void drawMyLine(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 0.0, 0.0);
glPointSize (4.0);
GLint x0 = 100;
GLint y0 = 150;
GLint xEnd = 200;
GLint yEnd = 200;
lineBres (x0, y0, xEnd, yEnd);
}
int main (int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(400, 400);
glutInitWindowPosition(0, 0);
glutCreateWindow(“Digital Differential Analyzer Algorithm”);
display();
glutDisplayFunc(drawMyLine);
glutMainLoop();
return 0;
}