UAS KOMPUTER GRAFIK PROGRAM PEMBUATAN GARIS DENGAN

ALGORITMA BRESENHAM MENGGUNAKAN BAHASA PEMROGRAMAN

C++

Dosen Pengampu:
Fitroh Amaludin, M.T

Oleh:

Mochammad Aldi (1412210017)

Muhammad Afif Syaifuddin (1412210055)
Muhammad Taufik Hidayat (1412210053)

Kelas 2021-C

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS TEKNIK
UNIVERSITAS PGRI RONGGOLAWE TUBAN
2021
Open Graphics Library (OpenGL
Open Graphics Library (OpenGL) merupakan sebuah library yang menyediakan
beberapa set prosedur dan berbagai fungsi yang memungkinkan digunakan untuk
menggambar sebuah objek dua dimensi (2D) dan tiga dimensi (3D). OpenGL bersifat open-
source, multi-platform, dan multi-language.OpenGL merupakan suatu antarmuka
pemrograman aplikasi (application programming interface/API) yang tidak tergantung pada
piranti dan platform yang digunakan, sehingga OpenGL dapat berjalan pada sistem operasi
Windows, UNIX, Linux, dan sistem operasi lainnya. Gambar 1.1 menunjukkan tahapan dari
OpenGL Pipeline dan Gambar 1.2 menunjukkan struktur program dari OpenGL

Algoritma Bresenham
Algoritma Bresenham merupakan algoritma yang dikembangkan oleh Bresenham pada tahun
1965. Algoritma ini merupakan perbaikan dari algoritma perhitungan koordinat piksel garis
lurus Dengan cara menggantikan operasi bilangan real perkalian dengan operasi penjumlahan.
Algoritma Bresenham merupakan algoritma yang sekarang digunakan di komputer grafis
modern. Algoritma ini Lebih baik dari algoritma DDA, karena menggunakan incremental
algorithm, yakni nilai sekarang Menggunakan nilai sebelumnya. Algoritma DDA digunakan
untuk tipe data integer, hal ini bertujuan Untuk menghindari operasi floating point. Algoritma
Bresenham menggunakan fungsi keputusan untuk Menentukan letak koordinat selanjutnya.
Algoritma Bresenham dapat dilakukan dengan menggunakan
Langkah-langkah berikut:
1. Bila titik awal garis (𝑥1, 𝑦1) dan akhir garis (𝑥2, 𝑦2), untuk inisialisasi awal, hitung:
• Selisih lebar = ∆𝑥 = 𝑥2 – 𝑥1
• Selisih tinggi = ∆𝑦 = 𝑦2 – 𝑦1
• 2∆𝑦 = 2(𝑦2 – 𝑦1)

2. Inisial parameter keputusan = 𝑝0 = 2∆𝑦 − ∆𝑥

3. Setiap 𝑥𝑘 di sepanjang garis, mulai dari 𝑘 = 0, cek kondisi berikut:

• Jika 𝑝𝑘 < 0 maka titik selanjutnya untuk digambar di : (𝑥𝑘 + 1, 𝑦𝑘) 𝑝𝑘+1 = 𝑝𝑘 +
2∆𝑦
• Selain itu maka titik selanjutnya untuk digambar di : (𝑥𝑘 + 1, 𝑦𝑘 + 1) 𝑝𝑘+1 = 𝑝𝑘 +
2∆𝑦 – 2∆𝑥
• Ulangi langkah diatas sebanyak ∆
• Bila 𝑚 > 1, inisial parameter keputusan = 𝑝0 = 2∆𝑥 − ∆𝑦

1
1. Sourcode kode program pembuatan garis dengan algoritma Bresenham
menggunakan bahasa pemrograman c++
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include
#include
<string.h>
<stdarg.h>
1
#include <GL/glut.h>
#include <iostream>

Using namespace std; 2

Void tampilan(void)
{
glClearColor(1.0, 1.0, 1.0, 0.0); // warna tampilan
glMatrixMode(GL_PROJECTION); 3
gluOrtho2D(0.0, 300.0, 0.0, 300.0);
}

Void garisBresenham(GLint x0, GLint y0, GLint xEnd, GLint yEnd)

{
GLint dx = (float) fabs((float) xEnd – x0); // Hitung dx
GLint dy = (float) fabs((float) yEnd – y0); // Hitung dy
GLint p = 2 * dy – dx; // Hitung parameter: p = 2dy – dx
GLint twoDy = 2 * dy; // Hitung twoDy = 2 * dy
GLint twoDyMinusDx = 2 * (dy – dx); // Hitung twoDyMinusDx = 2dy – 2dx / 2
* (dy – dx)
GLint x, y;

If (x0 > xEnd) {

// pk < 0
X = xEnd;
Y = yEnd;
xEnd = x;
} else {
X = x0;
Y = y0;
}
4
aturPixel(x, y);

while (x < xEnd) {

x++; // xk+1
if (p < 0)
p += twoDy; // pk = pk + 2dy
else {
y++; // yk+1
p += twoDyMinusDx; // pk = pk + twoDyMinusDx
}

aturPixel(x, y);
}
}

2
Void gambarGaris(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 0.0, 0.0); // warna garis
glPointSize(4.0); // ukuran titik
GLint x0 = 100; // x0 5
GLint y0 = 100; // y0
GLint xEnd = 170; // x1
GLint yEnd = 160; // y1
garisBresenham(x0, y0, xEnd, yEnd);
}

void nama_kelompok()
{
Cout << “Nama anggota kelompok : “ << endl;
Cout << “1. Muhammad Afif Syaifuddin (1412210055)” << endl; 6
Cout << “2. Mochammad Aldi (1412210017)” << endl;
Cout << “3. Muhammad Taufik Hidayat (1412210053)” << endl;
}

Int main(int argc, char** argv)

{ 7

nama_kelompok(); 8

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(400, 400);
glutInitWindowPosition(0, 0);
glutCreateWindow(“Algoritma Bresenham”); 9
tampilan();
glutDisplayFunc(gambarGaris);
glutMainLoop();
return 0;
}

3
2. Penjelasan Sourcode kode program pembuatan garis dengan algoritma Bresenham
menggunakan bahasa pemrograman c++

1) sekelompok "preprocessor directives" atau pernyataan "include" dalam bahasa

pemrograman C/C++. Setiap baris tersebut menyertakan berkas kepala (header file)
dari pustaka tertentu. Berikut adalah penjelasan fungsi masing-masing header:
Kode tersebut menyertakan header-file dari beberapa pustaka yang berfungsi untuk:
a. `math.h`: Memberikan fungsi-fungsi matematika standar.
b. `stdio.h`: Menyediakan fungsi-fungsi dasar untuk masukan dan keluaran.
c. `stdlib.h`: Berisi fungsi-fungsi untuk manajemen memori dan utilitas umum.
d. `string.h`: Memanipulasi string dalam bahasa C.
e. `stdarg.h`: Bekerja dengan argumen variabel dalam fungsi.
f. `GL/glut.h`: Dukungan pembuatan aplikasi berbasis grafis menggunakan
OpenGL.
g. `iostream`: Dukungan masukan/keluaran menggunakan objek “stream” dalam
bahasa C++.

2) `using namespace std` adalah pernyataan dalam C++ yang memungkinkan akses
langsung ke semua fungsi dan objek dari pustaka standar C++ (std) tanpa menuliskan
awalan "std::" sebelumnya. Ini membuat kode lebih ringkas, tetapi dapat menyebabkan
potensi tabrakan nama jika digunakan bersama dengan pustaka lain yang memiliki
nama yang sama.

3) Fungsi `tampilan` yang mengembalikan tipe data void, artinya fungsi ini tidak
mengembalikan nilai (tidak ada return). Fungsi ini digunakan untuk melakukan
beberapa pengaturan tampilan pada lingkungan OpenGL.
Penjelasan dari setiap baris dalam fungsi tampilan:
a. `glClearColor(1.0, 1.0, 1.0, 0.0);`: Mengatur warna latar belakang layar menjadi
putih (RGB: 1.0, 1.0, 1.0) dengan opasitas (alpha) 0.0.
b. `glMatrixMode(GL_PROJECTION);`: Mengaktifkan mode matriks proyeksi
OpenGL.
c. `gluOrtho2D(0.0, 300.0, 0.0, 300.0);`: Menetapkan sistem koordinat proyeksi
dalam rentang (0.0, 300.0) pada sumbu x dan y, sehingga mengatur objek yang
akan digambar akan terlihat dalam jendela berukuran 300x300 piksel.

4) Fungsi `garisBresenham` adalah sebuah implementasi algoritme Bresenham untuk

menggambar garis dengan menggunakan pustaka grafis atau OpenGL. Algoritme
Bresenham digunakan untuk menggambar garis dengan efisien tanpa menggunakan
operasi floating-point (bilangan pecahan). Fungsi ini menerima koordinat titik awal
`(x0, y0)` dan titik akhir `(xEnd, yEnd)` sebagai argumen.
Berikut adalah penjelasan dari setiap baris dalam fungsi `garisBresenham`:
a. `GLint dx = (float) fabs((float) xEnd – x0);`: Menghitung selisih antara `xEnd`
dan `x0`, lalu mengambil nilai absolutnya untuk mendapatkan nilai `dx` (delta
x).
b. `GLint dy = (float) fabs((float) yEnd – y0);`: Menghitung selisih antara `yEnd`
dan `y0`, lalu mengambil nilai absolutnya untuk mendapatkan nilai `dy` (delta
y).

4
 c. `GLint p = 2 * dy – dx;`: Menghitung parameter awal `p` berdasarkan algoritme
Bresenham.
d. `GLint twoDy = 2 * dy;`: Menghitung `twoDy`, yang akan digunakan dalam
perhitungan selanjutnya.
e. `GLint twoDyMinusDx = 2 * (dy – dx);`: Menghitung `twoDyMinusDx`, yang
akan digunakan dalam perhitungan selanjutnya.
f. `if (x0 > xEnd) { ... }`: Memastikan bahwa garis yang digambar bergerak dari
kiri ke kanan dengan membandingkan `x0` dan `xEnd`. Jika titik awal `(x0, y0)`
memiliki nilai `x` yang lebih besar dari titik akhir `(xEnd, yEnd)`, maka titik
awal dan akhir akan ditukar.
g. `aturPixel(x, y);`: Menggambar pixel dengan koordinat `(x, y)` menggunakan
fungsi `aturPixel`. Fungsi ini mungkin adalah bagian dari kode yang tidak
disertakan dalam fragmen yang Anda berikan.
h. `while (x < xEnd) { ... }`: Menggambar garis dari titik awal ke titik akhir
menggunakan algoritme Bresenham. Loop ini berjalan dari `x` titik awal hingga
mencapai `x` titik akhir.
i. `x++;`: Meningkatkan nilai `x` menjadi titik berikutnya.
j. `if (p < 0) ... else { ... }`: Memeriksa apakah parameter `p` lebih kecil dari 0.
Jika benar, maka nilai `p` akan diperbarui menggunakan rumus `p += twoDy`;
jika tidak, maka nilai `p` dan `y` akan diperbarui menggunakan rumus `p +=
twoDyMinusDx` dan `y++`.
k. `aturPixel(x, y);`: Menggambar pixel dengan koordinat `(x, y)` menggunakan
fungsi `aturPixel` setelah perubahan nilai `x` dan/atau `y`.
l. Fungsi `garisBresenham` ini akan menggambar garis mulai dari titik `(x0, y0)`
hingga titik `(xEnd, yEnd)` dengan efisien berkat algoritme Bresenham.
Namun, untuk hasil yang akurat, Anda harus memastikan bahwa fungsi
`aturPixel(x, y)` dengan benar menggambar pixel pada koordinat `(x, y)` yang
sesuai.

5) Fungsi `gambarGaris` adalah fungsi yang menggunakan pustaka OpenGL untuk

menggambar sebuah garis merah menggunakan algoritme Bresenham. Fungsi ini tidak
menerima argumen apa pun dan memiliki tipe data `void`, artinya tidak mengembalikan
nilai (tidak ada `return`).
Berikut adalah penjelasan dari setiap baris dalam fungsi `gambarGaris`:
a. `glClear(GL_COLOR_BUFFER_BIT);`: Membersihkan buffer warna layar
sebelum menggambar. Ini akan menghapus gambar sebelumnya dan
mempersiapkan layar untuk menggambar garis baru.
b. `glColor3f(1.0, 0.0, 0.0);`: Mengatur warna garis menjadi merah (RGB: 1.0, 0.0,
0.0) dengan ketiga komponen warna merah maksimal, dan komponen hijau dan
biru minimum (sehingga warna menjadi merah).
c. `glPointSize(4.0);`: Mengatur ukuran titik menjadi 4.0. Meskipun fungsi ini
tidak langsung digunakan dalam `gambarGaris`, mungkin digunakan di tempat
lain dalam kode yang tidak ditampilkan.
d. `GLint x0 = 100;`: Mendefinisikan variabel `x0` dengan nilai 100 sebagai
koordinat x titik awal garis.
e. `GLint y0 = 100;`: Mendefinisikan variabel `y0` dengan nilai 100 sebagai
koordinat y titik awal garis.

5
 f. `GLint xEnd = 170;`: Mendefinisikan variabel `xEnd` dengan nilai 170 sebagai
koordinat x titik akhir garis.
g. `GLint yEnd = 160;`: Mendefinisikan variabel `yEnd` dengan nilai 160 sebagai
koordinat y titik akhir garis.
h. `garisBresenham(x0, y0, xEnd, yEnd);`: Memanggil fungsi `garisBresenham`
dengan argumen `(x0, y0, xEnd, yEnd)` untuk menggambar garis dari titik `(x0,
y0)` ke titik `(xEnd, yEnd)` menggunakan algoritme Bresenham. Fungsi
`garisBresenham` akan mengatur warna garis dan menggambar garis sesuai
dengan algoritme tersebut.
Panggilan fungsi `gambarGaris()` kemungkinan akan dilakukan dalam fungsi `main`
atau di tempat lain dalam kode untuk menggambar garis merah menggunakan OpenGL
dengan menggunakan algoritme Bresenham.

6) Fungsi `nama_kelompok` adalah fungsi yang digunakan untuk mencetak nama

sebagai identitas dari nama pembuat atau nama kelompok pembuat. Fungsi ini tidak
menerima argumen apa pun dan memiliki tipe data `void`, artinya tidak mengembalikan
nilai (tidak ada `return`). Panggilan fungsi `nama_kelompok()` kemungkinan akan
dilakukan dalam fungsi `main` atau di tempat lain dalam kode untuk mencetak output
ke layar.

7) Fungsi int main() adalah titik masuk (entry point) dari program C/C++

8) Pemangila fungsi `nama_kelompok()` untuk di cetak ke layar.

9) Kode yang Anda berikan adalah implementasi dasar dari program menggunakan
pustaka GLUT (OpenGL Utility Toolkit) untuk menggambar garis dengan algoritme
Bresenham. Berikut adalah penjelasan baris per baris:
a. `glutInit(&argc, argv);`: Inisialisasi pustaka GLUT dan mengolah argumen
baris perintah yang mungkin diberikan ke program. `&argc` adalah alamat dari
variabel yang menyimpan jumlah argumen, dan `argv` adalah array yang berisi
argumen-argumen tersebut.
b. `glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);`: Menetapkan mode
tampilan untuk jendela OpenGL. Dalam hal ini, digunakan mode
`GLUT_SINGLE`, yang berarti tampilan akan menggunakan satu buffer
gambar saja, dan `GLUT_RGB`, yang menetapkan mode warna menjadi RGB.
c. `glutInitWindowSize(400, 400);`: Menetapkan ukuran jendela OpenGL
menjadi 400x400 piksel.
d. `glutInitWindowPosition(0, 0);`: Menetapkan posisi jendela pada layar
komputer. Dalam hal ini, jendela akan muncul di posisi 0, 0 (sudut kiri atas
layar).
e. `glutCreateWindow(“Algoritma Bresenham”);`: Membuat jendela dengan judul
“Algoritma Bresenham”.
f. `tampilan();`: Memanggil fungsi `tampilan()` untuk melakukan pengaturan
tampilan awal, seperti warna latar belakang dan sistem koordinat.

6
 g. `glutDisplayFunc(gambarGaris);`: Menetapkan fungsi `gambarGaris` sebagai
fungsi yang akan dipanggil ketika jendela harus digambar ulang. Fungsi ini akan
menggambar garis menggunakan algoritme Bresenham.
h. `glutMainLoop();`: Memulai perulangan utama GLUT yang akan menangani
semua peristiwa (events) dan memproses tampilan jendela secara terus-menerus
hingga program dihentikan.
i. `return 0;`: Mengembalikan nilai 0 dari fungsi `main` sebagai tanda program
berakhir dengan sukses.
Secara keseluruhan, kode tersebut menciptakan jendela berukuran 400x400 piksel
dengan judul “Algoritma Bresenham”, kemudian memanggil fungsi `gambarGaris`
untuk menggambar garis dengan algoritme Bresenham di dalam jendela tersebut.