IMPLEMENTASI ALGORITMA

PEMBENTUKAN GARIS DDA PADA

BAHASA C

Hamdan Nurachid[1], Deni Herdiansyah[2], Dona Gema Ramadhan[3], Esa Firmansyah, S.T., M. Kom.[4]
[1]
A2.1600074@mhs.stmik-sumedang.ac.id , A2.1600043@mhs.stmik-sumedang.ac.id[2],
A2.1600054@mhs.stmik-sumedang.ac.id[3]
, esa@stmik-sumedang.ac.id[4]

Jl. Angkrek Situ No.19, Situ, Sumedang Utara, Kabupaten Sumedang, Jawa Barat 45621

ABSTRAK

Garis adalah kumpulan titik-titik yang tersusun secara lurus dan linier dari titik awal sampai titik akhir. Penggambaran garis
dilakukan dengan menghitung posisi-posisi sepanjang jalur lurus antara dua posisi titik. Jalur lurus yang menghubungkan dua
titik tersebut sebenarnya adalah titik-titik yang saling berdempetan mengikuti arah jalur lurus tersebut. Titik dan garis adalah
contoh dari output primitif yang dapat digunakan untuk membentuk gambar, misalnya lingkaran, kerucut, permukaan
berbentuk persegi, kurva dan permukaan berbentuk lengkung, warna area dan karakter, dan lain-lain. Gambar-gambar seperti
rumah, tembok, gedung dan lain-lain merupakan obyek yang lengkap yang ditempatkan pada koordinat tertentu pada layar,
dimana obyek-obyek tadi sebenarnya tersusun dari kumpulan titik dan garis sebagai penyusunnya. Pada grafika komputer
mengenal algoritma pembentukan garis salah satunya adalah Algoritma DDA (Digital Differential Analyzer) yang
menggambarkan garis berdasarkan titik awal dan titik akhir dari suatu nilai. Algoritma DDA adalah algoritma pembentukan
garis berdasarkan perhitungan dx maupun dy, menggunakan rumus dy=m.dx. Semua koordinat titik yang membentuk garis
diperoleh dari perhitungan kemudian dikonversikan menjadi nilai integer.

Katakunci: garis, algoritma pembentukan garis, DDA.

1. PENDAHULUAN
Grafika Komputer adalah suatu bidang komputer yang mempelajari cara-cara meningkatkan dan
memudahkan komunikasi antara manusia dan mesin dengan jalan membangkitkan, menyimpan dan
memanipulasi gambar model suatu objek menggunakan komputer [1]. Pada grafika komputer tidak
terlepas dari yang namanya garis. Garis adalah kumpulan titik-titik yang memanjang secara tak
berhingga ke dua arah.Sebuah garis memiliki panjang tidak terbatas. Kumpulan dari titik-titik, untuk
membentuk garis lurus adalah dengan mengetahui titik awal dan titik akhir. Dengan mengetahui titik
awal dan titik akhir maka sebuah garis dapat dibentuk. Untuk menggambarkan proses pembuatan garis
dari titik awal ke titik akhir ada berbagai algoritma. Algoritma yang umum salah satunya adalah DDA
(Digital Differential Analyzer) yang kemudian dapat di implementasikan pada bahasa C dalam proses
pembentukan garis yang dibangun dari titik-titik.
2. TINJAUAN PUSTAKA

a. Algoritma DDA (Digital Differential Analyzer)

DDA adalah algoritma pembentuk garis yang dibuat menggunakan titik awal (x1, y1) dan titik akhir
(x2, y2). Setiap koordinat titik (xk, yk) yang membentuk garis diperoleh dari perhitungan, kemudian
hasil perhitungan dikonversikan menjadi nilai integer. Algoritma ini bisa digunakan untuk
menghitung garis dengan semua kemiringan. { 0 < m < 1 ; m>1 ; −1 < m < 0 ; m < −1 }. Berikut
adalah langkah-langkah pembentukan garis berdasarkan algoritma DDA:

1. Tentukan dua titik yang akan dihubungkan dalam pembentukan garis.

2. Tentukan salah satunya sebagai titik awal (x1, y1) dan yang lain sebagai titik akhir (x2, y2).
3. Hitung : dx = x2 − x1 dan dy = y2 − y1
4. Tentukan step, dengan ketentuan berikut:

- bila |dx| > |dy| maka step = |dx|

- bila tidak, maka step = |dy|

5. Hitung penambahan koordinat piksel dengan persamaan:

x_inc = dx / step y_inc = dy / step

6. Koordinat selanjutnya :

x = x + x_inc y = y + y_inc

7. Lakukan pembulatan u = Round(x), v = Round(x), kemudian plot piksel (u, v) pada layar
8. Ulangi point 6 dan 7 untuk menentukan posisi piksel berikutnya sampai x = x2 dan y = y2.
b. Pengertian Bahasa Pemrograman C 
Bahasa Pemrograman C adalah sebuah bahasa pemrograman komputer yang bisa digunakan untuk
membuat berbagai aplikasi (general-purpose programming language), mulai dari sistem operasi
(seperti Windows atau Linux), antivirus, software pengolah gambar (image processing),
hingga compiler untuk bahasa pemrograman, dimana C banyak digunakan untuk membuat bahasa
pemrograman lain yang salah satunya adalah PHP[2].

Meskipun termasuk general-purpose programming language, yakni bahasa pemrograman yang bisa

membuat berbagai aplikasi, bahasa pemrograman C paling cocok merancang aplikasi yang
berhubungan langsung dengan Sistem Operasi dan hardware. Ini tidak terlepas dari tujuan awal
bahasa C dikembangkan[2].

Bahasa pemrograman C dibuat pertama kali oleh Dennis M. Ritchie pada tahun 1972. Saat itu
Ritchie bekerja di Bell Labs, sebuah pusat penelitian yang berlokasi di Murray Hill, New Jersey,
Amerika Serikat. Ritchie membuat bahasa pemrograman C untuk mengembangkan sistem
operasi UNIX. Sebelumnya, sistem operasi UNIX dibuat menggunakan bahasa assembly (assembly
language). Akan tetapi bahasa assembly sendiri sangat rumit dan susah untuk dikembangkan [2].
 Dengan tujuan mengganti bahasa assembly, peneliti di Bell Labs membuat bahasa pemrograman B.
Namun bahasa pemrograman B juga memiliki beberapa kekurangan, yang akhirnya di lengkapi
oleh bahasa pemrograman C[2].

Dengan bahasa C inilah sistem operasi UNIX ditulis ulang. Pada gilirannya, UNIX menjadi dasar
dari banyak sistem operasi modern saat ini, termasuk Linux, Mac OS (iOS), hingga sistem
operasi Android[2].

3. PEMBAHASAN
Algoritma DDA (Digital Differential Analyzer) adalah algoritma pembentukan garis berdasarkan
perhitungan Dx dan Dy,yaitu pembuatan garis dengan langkah umum sebagai berikut: [4]
1. Tentukan Titik Awal dan Akhir
    Titik Awal    (x1,y1)
    Titik Akhir   (x2,y2)
2. Pengubahan Posisi (steps)
    Jika Dx > DY maka steps  = DX
    Jika tidak maka steps  = DY
    Dx = X2 - X1
    Dy = Y2 - Y1
    Perubahan nilai X (X_inc) = Dx/steps
    Perubahan nilai Y (Y_inc) = Dy/steps
3. Perulangan (ubah posisi dan gambar)
    X = X + X_inc 
    Y = Y + Y_inc

Berdasarkan rumus di atas maka dapat diimplementasikan dalam suatu bentuk program dengan
bahasa C.

// Algoritma DDA

#include <GL\freeglut.h>
#include <GL\glut.h>
#include <iostream>

using namespace std;

//identifier fungsi
void init();
void display(void);
void dda(void);

//  posisi window di layar

int window_x;
int window_y;

//  ukuran window
int window_width = 720;
int window_height = 480;

//  judul window
char *judul_window = "Algoritma DDA";

void main(int argc, char **argv)

{
//  inisialisasi GLUT (OpenGL Utility Toolkit)
glutInit(&argc, argv);
// set posisi window supaya berada di tengah
window_x = (glutGet(GLUT_SCREEN_WIDTH) - window_width) / 2;
window_y = (glutGet(GLUT_SCREEN_HEIGHT) - window_height) / 2;
glutInitWindowSize(window_width, window_height); //set ukuran window
glutInitWindowPosition(window_x, window_y); //set posisi window

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); // set display RGB dan double

buffer
glutCreateWindow(judul_window);

init();

glutDisplayFunc(display); // fungsi display

glutMainLoop(); // loop pemrosesan GLUT
}

void init()
{
glClearColor(0.0, 0.0, 0.0, 0.0); //set warna background
glColor3f(255., 8.0, 1.0); //set warna titik
glPointSize(2.0); //set ukuran titik
glMatrixMode(GL_PROJECTION); //set mode matriks yang digunakan
glLoadIdentity(); // load matriks identitas
gluOrtho2D(0.0, 600.0, 0.0, 600.0); // set ukuran viewing window
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT); //clear color
dda(); //panggil fungsi dda
glutSwapBuffers(); //swap buffer
}

void dda(void) {
int x1, y1, x2, y2;
float x,y,dx, dy, steps, x_inc, y_inc;
 //tentukan titik awal dan akhir
x1 = 1;
y1 = 1;
x2 = 500;
y2 = 500;
x = x1;
y = y1;

//hitung dx dan dy
dx = x2 - x1;
dy = y2 - y1;

//hitung steps
if (dx > dy) {
steps = dx;
}
else steps = dy;

//hitung perubahan nilai x (x_inc) dan y (y_inc)

x_inc = dx / steps;
y_inc = dy / steps;

//gambar titik awal

glBegin(GL_POINTS);
glVertex2i(x, y); // gambar titik awal

//perulangan untuk menggambar titik-titik

do {
x += x_inc; // x = x + x_inc
y += y_inc; // y = y + y_inc
glVertex2i(round(x), round(y)); //gambar titik
} while (x < x2);

glEnd();
glFlush();

4. HASIL
 Dengan menentukan tiitk awal dan titik akhir pada kode program maka akan membentuk suatu garis
yang dihasilkan dari banyak titik-titik pada perulangannya. Hasilnya seperti dibawah ini.

Pembentukan garis di atas bukanlah sepenuhnya garis lurus melainkan berupa titik-titik yang diulang
sehingga membentuk garis lurus berdasarkan titik awal dan titik akhir.

5. PENUTUP
Pembentukan garis diciptakan dari ratusan bahkan ribuan titik-titik yang saling terhubung satu sama lain
sehingga mampu membentuk suatu garis. Menurut algoritma pembentukan garis DDA (Digital
Differential Analyzer) garis dibentuk berdasarkan perhitungan Dx dan Dy, dengan menggunakan rumus
Dy = m. Dx [3]. Garis dibuat dengan menentukan dua endpoint atau posisi awal dan posisi akhir dari
suatu garis. Implementasi pembentukan garis dapat di praktekan pada bahasa pemrograman C/C++ agar
mengetahui proses garis yang dibentuk dari titik-titik.

DAFTAR PUSTAKA

[1] https://www.teknoborneo.com/2017/03/apa-itu-grafika-komputer.html

[2] https://www.duniailkom.com/tutorial-belajar-c-pengertian-bahasa-pemrograman-c/

[3] http://gustiam74.blogspot.co.id/2016/04/algoritma-pembentukan-garis-dda-dan.html

[4] http://demamteknologia.blogspot.com/2016/10/algoritma-dda.html