algoritme curva

1. MAKALAH
“ ALGORITMA PEMBUATAN KURVA ”
Dosen Pengampu : Ali Muhammad, M.Kom.
Penyusun :
Muhammad Ridho 3061846015
STKIP PGRIBANJARMASIN
PROGRAM PENDIDIKAN TEKNOLOGI INFORMASI
TAHUN 2020/2021

2. i
KATA PENGANTAR
Puji Syukur disampaikan kehadirat Allah SWT, yang telah melimpahkan
Rahmat dan karunia-Nya, sehingga makalah ini dapat diselesaikan dengan baik.
Makalah dengan judul “ Algoritma Pembuatan Kurva ”, merupakan hasil rangkaian
untuk memenuhi tugas Komputer Grafik, makalah ini juga menguraikan beberapa
materi mengenai Teori-Teori dan juga untuk mempermudah pemahaman pada kita
semua, khususnya mahasiswa STKIP PGRI Banjarmasin.
Saya mengucapkan terima kasih kepada bapa Ali Muhammad selaku dosen PTI
Komputer Grafik yang telah memberikan tugas ini sehingga dapat menambah
pengetahuan dan wawasan sesuai dengan bidang studi yang saya tekuni.
Saya menyadari bahwa penulisan makalah ini masih jauh dari sempurna, oleh
karena itu kritik dan saran sangat diharapkan guna perbaikan dimasa mendatang dan
semoga bermanfaat bagi kita semua.
Banjarmasin, 3 April 2021
Penyusun

3. ii
DAFTAR ISI
Kata Pengantar ...................................................................................................................i
Daftar Isi.............................................................................................................................ii
BAB I PENDAHULUAN .........................................................................................3
1.1 Latar Belakang...........................................................................................3
1.2 Rumusan Masalah......................................................................................4
1.3 Tujuan Penulisan .......................................................................................4
BAB II PEMBAHASAN............................................................................................5
2.1 Pengertian Algoritma metode kurva Bezie .............................................5
2.2 Cara menentukan garis lurus Algoritma midpoint (elips) .........................6
2.3 Algoritma midpoint (elips) untuk penggambaran garis dalam C++ ........... 7
2.4 Cara menentukan lingkaran dari algoritma midpoint (elips).....................9
BAB III PENUTUP...................................................................................................17
3.1 Kesimpulan..............................................................................................17
3.2 Saran ........................................................................................................17
DAFTAR PUSTAKA ....................................................................................................18

4. 3
BAB I
PENDAHULUAN
1.1 LATAR BELAKANG
Pembuatan suatu lingkaran merupakan salah satu primitive yang
berperan dalam grafika komputer. Prinsip yang dipakai pada penelitian ini
dalam pembuatan lingkaran adalah menterjemahkan dari bahasa
matematika ke dalam bahasa pemrograman untuk metode Bezier dan
algoritma Bresenham. Untuk program-program terapan sederhana,lingkaran
yang diperoleh dari bentuk dasarkurva cukup memadai, tetapi seringkali
diinginginkan bentuk lingkaran yang jauh lebih rumit dan tidak teratur.
Bentuk fungsi matematis yang paling utama untuk menggambar
kurva sebagai dasar pembuatan bentuk lingkaran adalah fungsi parametrika
tau vector-valued function yaitu untuk sembarang titik pada suatu
permukaan, lokasinya ditentukan oleh dua buah para-meter u dan v biasanya
bernilai antara 0 dan 1, dan fungsi parametrik x,y, dan z merupa-kan lokasi-
lokasi titik pada kurva atau permukaan.
Algoritma de Casteljau [2] merupakan algoritma untuk membuat
kurva menggunakan sejumlah titik kontrol, dan menggunakan teknik in-
betweening untuk mendapatkan kurva yang diinginkan. Algoritma ini
dikembangkan oleh P. de Casteljau, dan merupakan cikal bakal kurva
Bezier, yang secara terpisah dikembangkan lebih lanjut oleh P. Bezier.
Algoritma de Casteljau untuk membuat kurva Bezier cukup ampuh secara
algoritmik, tetapi tidak secara eksplisit menyatakan bentuk
fungsionalnya. Karenaalasan ini, kemudian dikembangkan persamaan
lain untuk membuat kurva Bezier, yang sangat berguna untuk tujuan
analisis.

5. 4
Algoritma Bresenham dipilih karena merupakan metode dasar
grafis yang sangat populer dan terkenal efisiensinya, Bresenham
memakai dasar integer arithmetic yang jauh lebih cepat daripada floating
point arithmetic yang biasa dipakai dan menggunakan suatu persamaan
mate-matis untuk mengetahui adanya baris atau kolom baru yang akan
dibuat dalam proses pembuatan suatu garis. Tetapi Bresenham juga
memiliki kekurangan yaitu timbulnya error jika dua segmen garis yang
overlap dibuat, error juga akan timbul jika sebuah segmen garis yang
intensitasnya berbeda overlap terhadap suatu segment garis yang sudah ada
1.2 RUMUSAN MASALAH
1. Apa yang dimaksud dengan Algoritma metode kurva Bezie ?
2. Apa yang dimaksud dengan Algoritma metode Bresenham?
3. Bagaimana Algoritma kurva Bezie untuk Flowchart ?
4. Bagaimana melakukan pengujian dan analisis algoritma pembuatan kurva ?
1.3 TUJUAN PENULISAN
1. Untuk mengetahui pengertian dari Algoritma metode kurva Bezie
2. Untuk mengetahui pengertian dari Algoritma metode Bresenham
3. Untuk mengetahui Algoritma kurva bezie untuk Flowchart
4. Untuk melakukan pengujian dan analisis algoritma pembuatan kurva

6. 5
BAB II
PEMBAHASAN
2.1 Pengertian Algoritma metode kurva Bezie
Metode kurva Bezier didefinisikan oleh titik-titik kontrol poligon seperti
ditunjukkan pada gambar 1. Kurva Bezier menggunakan fungsi blending yang
juga adalah basis Bernstein sehingga beberapa macam dari kurva Bezier dapat
diketahui. Beberapa definisi dari kurva Bezier yaitu :
 Fungsi basis adalah real.
 Tingkat definisi polinomial segmen kurva adalah satu lebih kecil dari jumlah
definisi titik-titik poligon.
 Kurva mengikuti bentuk dari definisi poligon.
 Titik-titik awal dan akhir dari kurva tepat sama dengan titik-titik awal dan
akhir dari definisi poligon.
 Arah vector di ujung-ujung dari kurva mempunyai arah yang sama dengan
awal dan akhir dari bentuk poligon.
 Kurva didalam convex hull dari definisi poligon.
Pada gambar 2 ditunjukkan contoh untuk empat titik poligon Bezier dan
kurva yang dihasilkan. Sehingga cepat dipelajari dan diperkirakan bentuk dari
kurva yang dihasilkan oleh suatu poligon Bezier. Kurva Bezier dengan suatu
parameter t memiliki persamaan matematika yang didefinisikan sebagai berikut :
Gambar 1. Kurva Bezier Dengan Definisi Poligon

7. 6
Gambar 2. Beberapa Kurva Bezier dengan empat titik Kontrol Poligon
Dengan fungsi blending atau basis Bernstein adalah :
dengan
keterangan :
 adalah fungsi factor blending atau basis Bernstein.
 adalah koefisien binomial3.
 adalah titik kontrol
dalah tingkat ke-n yang ke-I dari fungsi basis Bernstein. Disini n adalah
derajat dari definisi fungsi basis Bernstein. Dimana = 1 dan 0! = 1.
Harga maksimum dari tiap fungsi blending pada t = i/n

8. 7
Gambar 3. Kurva Fungsi Blending Bernstein
Titik akhir pada kurva Bezier dan titik akhir pada definisi poligon adalah tepat
sama. Hasil fungsi blending ini ditunjukkan pada gambar 3. Selanjutnya
ditunjukkan bahwa untuk memberikan nilai pada parameter t, hasil penjumlahan
terakhir dari fungsi basis adalah tepat sama dengan satu, yaitu :
2.2 Cara menentukan garis lurus Algoritma midpoint (elips)
Garis lurus dinyatakan dinyatakan dalam persamaan :
y = mx + c (1)
dimana : m : gradient dan
c : konstanta.
Untuk 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 riel,
sedangkan koordinat pixel dinyatakan dalam bilangan integer (x,y), maka diperlukan
operasi pembulatan kedalam bentuk integer terdekat.
Penggambaran garis lurus dengan metode diatas dimulai dengan operasi bilangan riel
untuk menghitung gradient m dan konstanta c.
m = (y2 - y1 ) / (x2-x1) (2)
c = y1 – m* x1 (3)
Operasi bilangan riel berikutnya adalah menghitung nilai y dengan persamaan (1)
untuk mendapatkan koordinat piksel (x,y), untuk setiap nilai x, dari =x1 sampai x=x2,
operasi inilah yang perlu dihindari, karena operasi ini memerlukan waktu operasi yang
besar.

9. 8
2.3 Algoritma midpoint (elips) untuk penggambaran garis dalam C++
Algoritma midpoint dikembangkan oleh Pitteway pada tahun 1967. Pada gambar 1, titik
abu-abu menyatakan posisi piksel, titik hitam menyatakan posisi piksel yang telah
digambar. Berdasarkan piksel ke n yang telah digambar, diperlukan metode untuk
menentukan piksel berikut yang akan digambar, karena penggambaran dilakukan dari
kiri ke kanan, maka piksel berikutnya harus pada kolom n+1. Karena gradien diantara 0
dan 1, maka piksel berikutnya adalah pada posisi titik p atau titik q.
Gambar 1. Garis Lurus
Persamaan garis lurus yang telah dinyatakan dalam persamaan (1) dapat dinyatakan
dalam fungsi x,y berikut.
f(x, y) = ax + by + c = 0 (4)
Fungsi f(x,y) dalam persamaan (4), akan memberikan nilai 0 pada setiap titik yang
terletak pada garis, dan bernilai positip pada setiap titik yang terletak dibawah garis,
dan bernilai negatif pada setiap titik yang terletak diatas garis.
Maka untuk menentukan apakah titik P atau Q sebagai koordinat piksel berikutnya,
maka dilakukan dengan cara menghitung nilai fungsi f(x,y) dalam persamaan (4) pada
titik P dan titik Q . Jika fungsi f(x,y) tersebut memberikan nilai positif, maka piksel
berikutnya adalah Q, sebaliknya piksel berikutnya adalah P.
g(x, y) = f(xn + 1, yn + 1/2) (5)
Fungsi g(x,y) persamaan (5) merupakan variabel penentu, dengan mengevaluasi g (x,
y) dapat ditentukan piksel berikutnya yang mana berdasarkan tanda plus atau minus
dari hasil fungsi g(x,y).
Untuk mempercepat komputasi fungsi g(x,y), dilakukan dengan cara incremental
berdasarkan nilai sebelumnya. Untuk setiap piksel, increment sederhana (DeltaG)
dipakai sebagai variabel penentu. Karena hanya ada 2 pilihan piksel pada setiap tahap,
maka hanya ada 2 increment yang dapat digunakan. Hal ini dilakukan dengan cara
pengurangan nilai g(x,y) yang berurutan dengan menggunakan persamaan 4 dan
persamaan 5.
DeltaG = a * DeltaX + b * DeltaY (6)

10. 9
Dimana DeltaX dan DeltaY adalah increment yang dipakai pada x dan y, yang bernilai
0 atau 1. Bila bergeser 1 piksel ke kanan :
DeltaG1 = a (7)
Bila bergeser 1 piksel ke kanan dan 1 piksel ke atas.
DeltaG2 = a + b (8)
Jadi nilai dari variable penentu dapat dihitung dari nilai sebelumnya dengan cara
menambah dengan (a) atau (a+b). Algoritma untuk menggambar garis lurus dari (x1,
y1) sampai (x2, y2) dilakukan dengan langkah-langkah sebagai-berikut:
1. Gambar piksel pertama (x1,y1). Hitung variabel penentu dengan persamaan (3).
2. Tentukan tanda variabel penentu. Jika variabel penentu bernilai positif, increment x
dan y dan tambahkan (a+b) pada vaiabel penentu, sebaliknya increment x dan y dan
tambahkan (a) pada variabel penentu.
3. Plot piksel pada posisi (x, y).
4. Ulangi langkah mulai langkah kedua, sampai piksel terakhir (x2,y2).

11. 10
2.4 Cara menentukan lingkaran dari algoritma midpoint (elips)
Kurva lingkaran dinyatakan dinyatakan dalam persamaan :
(x-xc) 2 + (y-yc) 2 = r 2 (9)
dimana : (xc,yc) : koordinat titik pusat lingkaran
r : jari-jari lingkaran
Untuk menggambarkan piksel-piksel dalam kurva lingkaran, dapat digunakan sumbu x
dari x = (xc-r) sampai x = (xc+r) sebagai parameter dan sumbu y sebagai hasil dari
persamaan (10)
y = yc +- sqrt(r 2 - (x-xc) 2 (10)
Algoritma ini memerlukan waktu operasi yang besar, karena mengandung operasi bilangan
riel perkalian maupun eksponential, dan menghasilkan posisi koordinat piksel yang tidak
merata, karena terjadinya gaps yang disebabkan adanya perubahan gradient.
Untuk menghindari posisi koordinat piksel yang tidak merata, koordinat piksel (x,y)
dinyatakan dengan menggunakan koordinat polar dalama persamaan (11)
x = xc + r cos q (11a)
y = yc + r sin q (11b)
Persamaan (11) diatas mengandung operasi bilangan riel perkalian untuk mendapatkan
koordinat piksel (x,y), untuk setiap nilai x, dari x = (xc-r) sampai x = (xc+r), operasi inilah
yang perlu dihindari, karena operasi ini memerlukan waktu operasi yang besar.

12. 11
2.5 Algoritma midpoint (elips) untuk penggambaran garis dalam C++
Komputasi untuk membuat kurva lingkaran dimulai dengan mengidentifikasi bagian-
bagian dari lingkaran yang dapat ditentukan dengan menggunakan sifat simetri, hal ini
dilakukan dengan cara membagai lingkaran dengan masing-masing mempunyai sudut
sebesar 45 , sehingga dalam sebuah lingkaran dibagi menjadi 8 bagian. Sebagai contoh,
digambarkan bagian dari lingkaran dari sudut 90 sampai 45 .
Seperti pada algoritma midpoint untuk garis lurus, maka pada setiap tahapan, terdapat
2 koordinat piksel yang harus dipilih yaitu (x+1, y) atau (x+1, y-1).
Gambar 2. Lingkaran
Langkah berikutnya, adalah menyatakan persamaan lingkaran dan fungsi untuk
menentukan variabel penentu. Persamaan lingkaran dengan pusat (0,0) dinyatakan
dalam persamaan (12).
f(x, y) = x*x + y+y - r*r = 0 (12)
Fungsi f(x, y) persamaan (12) akan bernilai positif jika titik (x,y) diluar lingkaran, dan
bernilai negatif jika titik (x,y) didalam lingkaran. Fungsi untuk variabel penentu dan
increment dinyyatakan dalam persamaan (13), (14), dan (15).
g(x, y) = (x + 1)*(x + 1) + (y - 1/2)*(y - 1/2) - r*r (13)
DeltaG1 = 2x + 3 (14)
DeltaG2 = 2x - 2y + 5 (15)
Berbeda dengan nilai dari increment pada algoritma garis lurus yang bernilai konstan,
pada kurva lingkaran, increment tidak konstan. Terlihat bahwa komputasi increment
memerlukan operasi perkalian, tetapi operasi perkalian dapat diubah dengan cara
komputasi nilai increment secara increment pula, sehingga diperlukan 2 komputasi
increment dalam setiap piksel yang diproses. Secara umum, kurva polinomial orde n
memerlukan n level increment. Pada titik awal (x1,y1), komputasi variabel penentu
mempunyai bagian bilangan riel, sehingga operasi bilangan integer tidak dapat
digunakan secara langsung. Dalam praktek hal ini diselesaikan dengan cara
menambahkan nilai 1/4 pada variable penentu.

13. 12
2.6 Hasil pengukuran Algoritma midpoint (elips)
Kurva lingkaran dinyatakan dinyatakan dalam persamaan :
(x-xc) 2 + (y-yc) 2 = r 2 (9)
dimana : (xc,yc) : koordinat titik pusat lingkaran
r : jari-jari lingkaran
Untuk menggambarkan piksel-piksel dalam kurva lingkaran, dapat digunakan sumbu x
dari x = (xc-r) sampai x = (xc+r) sebagai parameter dan sumbu y sebagai hasil dari
persamaan (10)
y = yc +- sqrt(r 2 - (x-xc) 2 (10)
Algoritma ini memerlukan waktu operasi yang besar, karena mengandung operasi
bilangan riel perkalian maupun eksponential, dan menghasilkan posisi koordinat piksel
yang tidak merata, karena terjadinya gaps yang disebabkan adanya perubahan gradient.
Untuk menghindari posisi koordinat piksel yang tidak merata, koordinat piksel (x,y)
dinyatakan dengan menggunakan koordinat polar dalama persamaan (11)
x = xc + r cos q (11a)
y = yc + r sin q (11b)
Persamaan (11) diatas mengandung operasi bilangan riel perkalian untuk mendapatkan
koordinat piksel (x,y), untuk setiap nilai x, dari x = (xc-r) sampai x = (xc+r), operasi
inilah yang perlu dihindari, karena operasi ini memerlukan waktu operasi yang besar.
Tabel 1. Waktu Dan Rasio Penggambaran Garis Lurus (1/100 detik)
Algoritma
Panjang garis
640x 100 640x 10 640x 1
Algoritma
Persamaan (1)
4647 19 473 17 49 8
Algoritma DDA
3862 16 390 14 43 7
Algoritma
Bresenham
2702 11 274 10 33 6
Algoritma
MidPoint
242 1 28 1 6 1

14. 13
Tabel 2. Waktu Dan Rasio Penggambaran Lingkaran (1/100 detik)
Algoritma Jari-
jari
480x 100 480x 10 480x 1
Algoritma
Persamaan (10)
2265 15 253 15 29 14
Algoritma
Bresenham
146 1 17 1 2 1
Algoritma
MidPoint
148 1 16 1 2 1
2.7 Hasil Dari Penerapan Algoritma midpoint (elips) dalam C++
Source code
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <math.h>
int line_mat(int x1,int y1,int x2,int y2,int color);
int line_dda(int x1,int y1,int x2,int y2,int color);
int line_bre(int x1,int y1,int x2,int y2,int color);
int line_mid(int x1,int y1,int x2,int y2,int color);
int circ_mat(int xc,int yc,int r,int color);
int circ_bre(int xc,int yc,int r,int color);
int circ_mid(int xc,int yc,int r,int color);
int main(void)
{
int elapse;
struct time t1,t2;
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int xmax, ymax;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();

15. 14
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %sn", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
setcolor(getmaxcolor());
xmax = getmaxx();
ymax = getmaxy();
// get start time
gettime(&t1);
printf("The Start time is: %2d:%02d:%02d.%02dn",
t1.ti_hour, t1.ti_min, t1.ti_sec, t1.ti_hund);
// draw line graphics
// line_mat(0,0,xmax*1,ymax*1,1);
// line_dda(0,0,xmax*1,ymax*1,1);
// line_bre(0,0,xmax*1,ymax*1,1);
// line_mid(0,0,xmax*1,ymax*1,1);
// draw circle graphics
// circ_mat(320,240,480*50,1);
// circ_bre(320,240,480*50,1);
// circ_mid(320,240,480*50,1);
// get finish time
gettime(&t2);
printf("The Finish time is: %2d:%02d:%02d.%02dn",
t2.ti_hour, t2.ti_min, t2.ti_sec, t2.ti_hund);
// elapse time
elapse = (t2.ti_hour*60*60*100+t2.ti_min*60*100+t2.ti_sec*100+t2.ti_hund)-
(t1.ti_hour*60*60*100+t1.ti_min*60*100+t1.ti_sec*100+t1.ti_hund);
printf("The Elapse time is: %d x 1/100 second n",elapse);
/* clean up */
getch();
closegraph();
return 0;
}
int line_mat(int x1,int y1,int x2,int y2,int color)
// Algorithm y = m * x + b
// It is assumed that x1 < x2 and the gradient is less than 1.

16. 15
{ float m = ((float) (y2 - y1)) / ((float) (x2 - x1));
float c = y1 - m * x1;
for ( int x = x1; x <= x2; x++)
{ float fy = m * x + c;
int y = fy + 0.5;
putpixel(x,y,color);
}
return(0);
}
int line_dda(int x1,int y1,int x2,int y2,int color)
// Algorithm digital differential analyzer
{ int dx,dy,step,k;
float x_increment,y_increment,x,y;
dx = x2-x1; dy = y2-y1;
// determine maximum step
if (abs(dx) > abs(dy)) step=abs(dx); else step=abs(dy);
x_increment = float(dx) / float(step);
y_increment = float(dy) / float(step);
x = x1; y = y1;
putpixel(int (x+0.5),int(y+0.5),color);
for (k=1;k<=step;k++)
{ x = x+x_increment;
y = y+y_increment;
putpixel(int(x+0.5),int(y+0.5),color);
}
return(0);
}
int line_bre(int x1,int y1,int x2,int y2,int color)
// Algorithm Bresenham
{ int dx,dy,x,y,x_end;
int p,const1,const2;
dx = x2-x1; dy = y2-y1;
p = 2*dy-dx; y = y1;
const1 = 2*dy; const2 = 2*(dy-dx);
// determine which point to use as start, which as end
if (x1 > x2)
{ x = x2; y = y2; x_end = x1; }
else
{ x = x1; y = y1; x_end = x2; }
putpixel(x,int(y+0.5),color);
while ( x < x_end )
{ x++;
if ( p < 0 )
p = p+const1;
else

17. 16
{ y = y+1;
p = p+const2;
}
putpixel(x,int(y+0.5),color);
}
return(0);
}
int line_mid(int x1,int y1,int x2,int y2,int color)
// Algorith midpoint
// It is assumed that x1 < x2 and the gradient is less than 1.
{ int x,y=y1;
int a = y2 - y1;
int b = x2 - x1;
int G = 2 * a - b; // Decision variable
int DeltaG1 = 2 * (a - b);
int DeltaG2 = 2 * a;
for (x = x1; x <= x2; x++)
{ if (G > 0)
{ G += DeltaG1;
y++; ; // Next column and row.
putpixel(x,y,color);
}
else
{ G += DeltaG2;
// y not changed // Next column.
putpixel(x,y,color);
}
}
return (0);
}
int circ_mat(int xc,int yc,int r,int color)
// Algorithm y = yc +/- sqrt(r^2-(x-xc)^2)
// It is assumed that theta 45 degrees
{ int x, y, dy;
for ( x = xc; x <= xc+int (r/2); x++)
{ dy = int( sqrt( double(r)*double(r)- double ((x-xc)*(x-xc))) + 0.5);
putpixel(x,yc+dy,color);
}
return(0);
}
int circ_bre(int xc,int yc,int r,int color)
// Algorithm y = yc +/- sqrt(r^2-(x-xc)^2)
// It is assumed that theta 45 degrees

18. 17
{ int x, y, p;
x = 0; y = r; p = 3 - 2 * r;
while ( x < y )
{ putpixel(xc+x,yc+y,color);
if ( p < 0 ) p = p + 4 * x + 6;
else
{ p = p + 4 * ( x-y) + 10;
y = y -1;
}
x++;
}
return (0);
}
int circ_mid(int xc,int yc,int r,int color)
/* Draw the second octant of a circle centred on the top
left corner of the screen. This particular algorithm will only draw
an arc whose inclination is between 0 and 45 degrees.
*/
{ int x, y, G, DeltaG1, DeltaG2;
x = 0; y = r;
G = 1 - r;
DeltaG1 = 3; DeltaG2 = -2 * r + 5;
while (x < y)
{ if (G < 0)
{ G += DeltaG1;
DeltaG1 += 2;
DeltaG2 = DeltaG2 + 2;
}
else
{ G += DeltaG2;
DeltaG1 += 2;
DeltaG2 += 4;
y--;
}
x++;
putpixel(xc+x,yc+y,color);
}
return(0);
}

19. 18
BAB III
PENUTUP
3.1 KESIMPULAN
Dari hasil pengamatan dan uji coba yang dilakukan, dapat kesimpulan:
1. Pembuatan lingkaran dengan menggunakan algoritma Bresenham lebih cepat
prosesnya sebesar 1.44 kali dibandingkan dengan metode Bezier .
2. Sedangkan ditinjau dari akurasi, lingkaran Bezier lebih baik dibandingkan
lingkaran Bresenham dengan error koordinat X lebih kecil 0,038379671 dan error
koordinat Y lebih kecil 0,026411257
3. Dengan kecepatan prosesor komputer seperti Pentium dengan aneka tipenya
yang memiliki kecepatan eksekusi cukup tinggi maka dapat disimpulkan secara
keseluruhan bahwa metode Bezier lebih baik dibandingkan algoritma Bresenham
karena memiliki akurasi yang lebih baik.
3.2 SARAN
Demikian makalah yang saya susun ini, semoga dapat memberikan
inspirasi bagi para pembaca agar bisa menyusun makalah yang lebih baik dari
makalah ini. Dan semoga dengan membaca makalah ini bisa menjadi masukan
dan saran kepada berbagai pihak lainya, terima kasih.

20. 19
DAFTAR PUSTAKA
Bresenham, Jack, A Linear Algorithm for Incremental Digital Display of Circular Arcs.
Association for Computing Machinery, Inc.,1977.
Farin, Gerald, Curves and Surfaces for CAGD, 3rd ed. Arizona: Academic Press, 1988.
Hearn, Donald, and M. Pauline Baker, Computer Graphics, Prentice-Hall, 1986.
Piegl, L, Interactive Data Interpolasi by Rational Bezier Curves, IEEE. April 1987. p. 45-58.
Rogers, David F., Mathematical Elements for Computer Graphic, NewYork:McGraw Hill,1990.