Cara Kerja Algoritma Lingkaran Bresenham Disertai Contoh Soal dan Tabel Iterasi

Dalam dunia grafika komputer, menggambar bentuk geometris dengan presisi adalah hal yang sangat penting. Salah satu algoritma yang paling populer untuk menggambar lingkaran adalah Algoritma Bresenham. Algoritma ini efisien, cepat, dan banyak digunakan dalam pemrograman grafis karena hanya menggunakan operasi aritmatika sederhana seperti penjumlahan, pengurangan, dan pergeseran bit, tanpa memerlukan operasi perkalian atau akar kuadrat.

Pengertian Algoritma Lingkaran Bresenham

Algoritma Lingkaran Bresenham adalah metode yang dikembangkan untuk menentukan titik-titik raster yang membentuk sebuah lingkaran pada layar komputer. Algoritma ini merupakan pengembangan dari Algoritma Bresenham untuk garis, yang pertama kali diperkenalkan oleh Jack Bresenham pada tahun 1962.

Prinsip utama algoritma ini adalah menentukan titik-titik lingkaran di satu kuadran dan memanfaatkan simetri lingkaran untuk menghasilkan titik-titik di kuadran lainnya. Dengan cara ini, kita hanya perlu menghitung seperempat dari lingkaran dan kemudian mereplikasi titik-titik tersebut di kuadran lain.

Keunggulan Algoritma Bresenham

Beberapa alasan algoritma Bresenham populer untuk menggambar lingkaran adalah:

1. Efisiensi tinggi – Tidak membutuhkan operasi perkalian atau akar kuadrat.
2. Cepat – Hanya menggunakan operasi penjumlahan dan pengurangan.
3. Akurasi – Menghasilkan lingkaran dengan tampilan visual yang halus di layar pixel.
4. Simpel – Mudah diimplementasikan dalam bahasa pemrograman apa pun.

Rumus Dasar Algoritma Lingkaran Bresenham

Misalkan kita ingin menggambar lingkaran dengan jari-jari $r$r dan titik pusat di $(x_c, y_c)$(xc​,yc​). Algoritma ini menggunakan keputusan berbasis nilai fungsi:$$f(x, y) = x^2 + y^2 – r^2$$f(x,y)=x2+y2−r2

Dimana:

• Jika $f(x+1, y-0.5) < 0$f(x+1,y−0.5)<0, maka titik di sebelah kanan dipilih.
• Jika $f(x+1, y-0.5) \ge 0$f(x+1,y−0.5)≥0, maka titik diagonal dipilih.

Langkah-langkahnya:

1. Mulai dari titik $(0, r)$(0,r)
2. Hitung nilai keputusan awal: $$d = 3 – 2r$$d=3−2r
3. Selama $x \le y$x≤y:
   • Jika $d < 0$d<0, maka $d = d + 4x + 6$d=d+4x+6
   • Jika $d \ge 0$d≥0, maka $d = d + 4(x – y) + 10$d=d+4(x−y)+10 dan $y = y – 1$y=y−1
   • $x = x + 1$x=x+1
4. Gunakan simetri lingkaran untuk mencetak titik di delapan oktaf.

Baca Juga : Heboh Pencairan BLT Februari 2026: Simak Penjelasan Resmi dari Kemensosga :

Contoh Soal

Misalkan kita ingin menggambar lingkaran dengan:

• Jari-jari $r = 5$r=5
• Titik pusat $(0,0)$(0,0)

Langkah pertama adalah inisialisasi:$$x = 0, \quad y = r = 5$$x=0,y=r=5 $$d = 3 – 2r = 3 – 10 = -7$$d=3−2r=3−10=−7

Tabel Iterasi Algoritma Bresenham

Berikut tabel iterasi untuk lingkaran dengan $r = 5$r=5:

Setiap titik yang dihitung kemudian direplikasi ke semua kuadran untuk membentuk lingkaran lengkap.

Pseudocode Algoritma Lingkaran Bresenham

Agar lebih jelas, berikut pseudocode untuk implementasi algoritma ini:

Input: r (radius), (xc, yc) (titik pusat)
x = 0
y = r
d = 3 - 2 * r
while x <= y:
    plot(xc + x, yc + y)
    plot(xc - x, yc + y)
    plot(xc + x, yc - y)
    plot(xc - x, yc - y)
    plot(xc + y, yc + x)
    plot(xc - y, yc + x)
    plot(xc + y, yc - x)
    plot(xc - y, yc - x)
    if d < 0:
        d = d + 4*x + 6
    else:
        d = d + 4*(x - y) + 10
        y = y - 1
    x = x + 1

Implementasi dalam Python

Berikut contoh implementasi sederhana algoritma Bresenham dalam Python menggunakan matplotlib:

Baca Juga : Universitas Teknokrat Indonesia Masuk 10 Besar Kampus Swasta Terbaik Nasional Versi AppliedHE ASEAN 2026

import matplotlib.pyplot as pltdef bresenham_circle(xc, yc, r):
    x = 0
    y = r
    d = 3 - 2 * r
    points = []    while x <= y:
        points.extend([
            (xc + x, yc + y),
            (xc - x, yc + y),
            (xc + x, yc - y),
            (xc - x, yc - y),
            (xc + y, yc + x),
            (xc - y, yc + x),
            (xc + y, yc - x),
            (xc - y, yc - x)
        ])
        if d < 0:
            d = d + 4*x + 6
        else:
            d = d + 4*(x - y) + 10
            y -= 1
        x += 1
    return points# Visualisasi
circle_points = bresenham_circle(0, 0, 5)
xs, ys = zip(*circle_points)
plt.scatter(xs, ys)
plt.gca().set_aspect('equal', adjustable='box')
plt.show()

Kode di atas akan menghasilkan lingkaran dengan radius 5 di layar komputer dengan koordinat pusat di $(0,0)$(0,0).

Tips Optimasi dan Penerapan

1. Gunakan integer – Hindari tipe data float agar lebih cepat.
2. Simetri – Selalu gunakan simetri 8 oktaf untuk mempercepat perhitungan.
3. Aplikasi – Digunakan dalam game, grafika 2D, CAD, dan perangkat embedded.
4. Kombinasi – Bisa digabungkan dengan algoritma lain seperti midpoint circle untuk variasi.

Kesimpulan

Algoritma Lingkaran Bresenham adalah metode efisien untuk menggambar lingkaran dengan menggunakan operasi integer. Dengan memahami langkah-langkah dan tabel iterasi, programmer dapat menggambar lingkaran dengan cepat dan akurat di layar komputer. Contoh implementasi Python menunjukkan betapa sederhana algoritma ini diterapkan dalam dunia nyata.

Dengan pemahaman ini, Anda tidak hanya bisa menggambar lingkaran, tetapi juga mengembangkan algoritma untuk bentuk lain, atau mengoptimalkan grafika pada sistem yang terbatas sumber daya.

Penulis : reyfen