Algoritma Pembentuk Lingkaran

Secara umum prosedur pembentuk lingkaran dibuat dengan rumus dasar

x2+y2=R2. Terdapat beberapa cara untuk membentuk suatu lingkaran namun tidak
efisien. Lingkaran dapat dibuat dengan menggambarkan seperempat lingkaran karena
bagian lain dapat dibuat sebagai bagian yang simetris.
a. Algoritma Simetris delapan titik
Pada algoritma ini pembuatan lingkaran dilakukan dengan menentukan satu titik
awal. Bila titik awal pada lingkaran(x,y) maka terdapat tiga posisi lain, sehingga
dapat diperoleh delapan titik. Dengan demikian sebenarnya hanya diperlukan
untuk menghitung segmen 45 dalama menentukan lingkaran selengkapnya.
Dengan titik pusat lingkaran tertentu, delapan titik simetris dapat ditampilkan
dengan prosedur Circle Point Sebagai berikut:
procedure CirclePoints(x, y, value:integer);
begin
putPixel(x,y,value);
putPixel(-x,y,value);
putPixel(x,-y,value);
putPixel(-x,-y,value);
putPixel(y,x,value);
putPixel(-y,x,value);
putPixel(y,-x,value);
putPixel(-y,-x,value);
end;
b. Algoritma Lingkaran Midpoint
Algoritma Lingkaran Midpoint juga disebut algoritma lingkaran
Bressenham. Bressenham mengembangkan generator lingkaran yang cukup efisien.
Algoritma yang digunakan membentuk semua titik berdasarkan titik pusat dengan
penambahan semua jalur sekeliling lingkaran. Algoritma ini diturunkan dari algoritma
Midpoint untuk pembentukan garis. Dalam hal ini hanya diperhatikan bagian 45 dari
suatu lingkaran, yaitu oktan kedua dari x=0 ke x=R/v2, dan menggunakan CirclePoints
untuk menampilkan titik dari seluruh lingkaran.
Langkah langkah untuk membentuk lingkaran algoritma Circle Midpoint:
1. Tentukan radius r dengan titk pusat lingkaran(xc,yc) kemudian diperoleh
(x0,y0)=(0,r)
2. Hitung nilai dari parameter
P0=5/4r
3. Tentukan nilai awal k=0, untuk setiap posisi xk berlaku sebagai berikut:
o Bila P < 0, maka titik selanjutnya adalah (x y )dan
k k+1, k)
P =P +2x +1
k+1 k k+1
Bila tidak, maka selanjutnya adalah(x y ), dan P =P +2x +1
k+1, k1 k+1 k k+1
2y
k+1
Dimana 2x 2x +2 dan 2y =2y 2
k+1= k k+ k
4. Tentukan titik simetris pada ketujuh oktan yang lain
5. Gerakkan setiap posisi pixel(x,y) pada garis melingkar dari lingkaran dengan

titik pusat (xc,yc) dan tentukan nilai koordinat:

x=x+x y=y+y
cc
6. Ulangi langkah ke3 sampai 5, sehingga x>=y
Contoh algoritma lingkaran midpoint
Untuk menggambarkan algoritma Bressenham dalam pembentukan suatu
lingkaran dengan titik pusat (0,0) dan radius 10, perhitungan berdasarkan pada oktan dari
kuadran pertama di mana x=0 sampai x=y. Nilai parameter dapat ditentukan dengan
P =1r =110=9
0
Koordinat titk awal adalah(x,r)=(0,8).
K P (X Y oktan1
k k+1, k+1)
(0,8)
0 7 (1,8)
1 4 (2,8)
2 1 (3,7)
3 6 (4,7)
4 3 (5.6)
5 2 (6,5)
Prosedur algoritma lingkaran midpoint
Input yang digunakan pada prosedur ini adalah koordinat titik pusat dan radius
lingkaran. Posisi pixel ditentukan dengan rutin setPixel.
uses graph,crt;
{tambahkan pada bagian ini prosedur penginisialisasian device,
lihat pada bab 1}
procedure circlePlotPoints(xCenter,yCenter,x,y:integer);
begin
putPixel(xCenter+x, yCenter+y,30);
putPixel(xCenter-x, yCenter+y,30);
putPixel(xCenter+x, yCenter-y,30);
putPixel(xCenter-x, yCenter-y,30);
putPixel(xCenter+y, yCenter+x,30);
putPixel(xCenter-y, yCenter+x,30);
putPixel(xCenter+y, yCenter-x,30);
putPixel(xCenter-y, yCenter-x,30);
end;
procedure circleMidPoint (xCenter,yCenter,radius:integer);
var
x,y,p:integer;
begin
x:=0;
y:=radius;
p:=1-radius;
circlePlotpoints(xCenter,yCenter,x,y);
while x
begin
x:=x+1;;
if p<0 then
p:=p+(2*x+1)
else
begin

y:=y-1;
p:=p+(2*(x-y)+1);
end;
end;
circlePlotPoints(xCenter,yCenter,x,y);
end;
begin
init;
circleMidPoint(100,100,90);
readkey;
destroy;
end.
created by : Pagus33@gmail.com

1. LINGKARAN
Untuk membentuk suatu lingkaran, ada beberapa algoritma yang bisa digunakan :
a. ALGORITMA LINGKARAN 8 TITIK SIMETRIS
Proses pembentukan lingkaran dengan algoritma ini dapat dilakukan dengan menentukan suatu titik
awal. Bila titik awal pada lingkaran (x,y) maka terdapat tiga posisi lain, sehingga dapat diperoleh
delapan titik.
b. ALGORITMA LINGKARAN TITIK TENGAH (MID POINT)
Algoritma mid point juga disebut algoritma lingkaran Bressenham. Bressenham mengembangkan
generator lingkaran yang cukup efisien. Algoritma yang digunakan membentuk semua titik
berdasarkan titik pusat dengan penambahan semua jalur disekeliling lingkaran.
Langkah-langkah dalam pembentukan lingkaran dengan algoritma mid point adalah sebagai
berikut :
a. Masukkan jari-jari dan pusat lingkaran dan dapatkan titik permulaan pada keliling yang berpusat
pada titik awal sebagai :
b. Hitung nilai awal parameter keputusan sebagai berikut :
c. Pada masing-masing posisi , mulai dari k=0, lakukan tes berikut :
Jika < 0 titik berikut sepanjang lingkaran yang berpusat (0,0) adalah
titik berikutnya untuk lingkaran adalah
dengan dan
d. Tentu titik simetri untuk 7 oktan yang lain
e. Pindahkan masing-masing posisi piksel ke bagian lingkaran yang berpusat dan lukis nilai
koordinat.
f. Ulangi langkah c sampai e hingga
Contoh Program pembentukan lingkaran dengan algoritma mid point
Diketahui jari-jari lingkaran r = 10 dan titik pusat (0,0)
Buatlah table perhitungan untuk titik yang dihasilkan oleh algoritma mid points
Jawab
Tabel perhitungan
Penggambaran lingkaran dengan algoritma mid point untuk titik pusat (0,0), dimulai dari kuadran
pertama yaitu dari x = 0 ke x = y.
Nilai awal parameter keputusan adalah :
Untuk lingkaran yang berpusat pada koordinat awal, titik awal adalah =(0,10), dan nilai kenaikan
untuk penghitungan parameter keputusan adalah :
Perhitungan dapat dilihat pada table berikut :
K
0
1
2
3
4
5
6 -6
-1
6
-3
8
5
6 (1,10)
(2,10)

(3,10)
(4,9)
(5,9)
(6,8)
(7,7) 2
4
6
8
10
12
14 20
20
20
18
18
16
14

Script Program dan Pembahasan

#include

#pragma hdrstop
#include
#include "math.h"
#pragma resource "*.dfm"
TForm1 *Form1;
int tergambar, XC,YC,QX,QY;
= script tersebut menjelaskan awal dari pembuatan program yang lain.
================================================
====================
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
= Awal antar muka
================================================
====================
void __fastcall TForm1::FormActivate(TObject *Sender)
{
Image1->Canvas->Rectangle(0,0,Image1->Width,Image1->Height);
}
================================================
====================
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Close();

}
= untuk menjalankan button close
================================================
====================
void __fastcall TForm1::Button1Click(TObject *Sender)
{
tergambar=false;
Image1->Canvas->Rectangle(0,0,Image1->Width,Image1->Height);
}
= untuk menjalankan button yang berisi baru
================================================
====================
void __fastcall TForm1::Image1MouseDown(TObject *Sender, TMouseButton
Button, TShiftState Shift, int X, int Y)
{
tergambar=true; XC=X; YC=Y;
}
================================================
====================
void __fastcall TForm1::CirclePlotpoint(int XC, int YC, int X, int Y)
{
Image1->Canvas->Pixels[XC+X][YC+Y]=clBlack;
Image1->Canvas->Pixels[XC-X][YC+Y]=clBlack;
Image1->Canvas->Pixels[XC+X][YC-Y]=clBlack;
Image1->Canvas->Pixels[XC-X][YC-Y]=clBlack;
Image1->Canvas->Pixels[XC+Y][YC+X]=clBlack;
Image1->Canvas->Pixels[XC-Y][YC+X]=clBlack;
Image1->Canvas->Pixels[XC+Y][YC-X]=clBlack;
Image1->Canvas->Pixels[XC-Y][YC-X]=clBlack;
}
void __fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button,
TShiftState Shift, int X, int Y)
{ int R;
Button1Click(Sender);
tergambar=false;
QX=X; QY=Y;
R=int(sqrt(pow(XC-QX,2)+pow(YC-QY,2)));
if (RadioGroup1->ItemIndex==0)
{ CircleMidPoint(XC,YC,R); }
}
================================================
====================
void __fastcall TForm1::CircleMidPoint(int XC, int YC,int R)
{int x,y,p,k=0;
R=10;
x=0; y=R; p=1-R;
judul((float)x,(float)y,k,p);

do
{
k++;
if (p<0) { x=x+1; }
else
{ x=x+1; y=y-1; }
if (p<0) { p=p+2*x+1; }
else { p=p+2*(x-y)+1; }
CirclePlotpoint(XC,YC,x,y);
tampil((float)x,(float)y,k,p);
} while (x
}
//================================================
====================
void __fastcall TForm1::tampil(float x,float y, int k, int p)
{
{
char tampilX[20],tampilY[20],tampilK[20],tampilPk[20];
int i,xt=200, yt=15;
//Menampilkan bilangan asli tanpa pembulatan
_gcvt(x,7,tampilX);
_gcvt(y,7,tampilY);
_gcvt(p,7,tampilPk);
if (k==0) { for (i=0; i<20;i++) { tampilK[i]='\0'; } }
else { _gcvt(k-1,10,tampilK); }
k=k+2;
//Menampilkan koordinat X dan Y
Image1->Canvas->TextOut(xt-50, k*yt,tampilK);
Image1->Canvas->TextOut(xt+100, k*yt,"(");
Image1->Canvas->TextOut(xt+120, k*yt,tampilX);
Image1->Canvas->TextOut(xt+150, k*yt,",");
Image1->Canvas->TextOut(xt+160, k*yt,tampilY);
Image1->Canvas->TextOut(xt+190, k*yt,")");
Image1->Canvas->TextOut(xt, k*yt,tampilPk);
}
}
void __fastcall TForm1::judul(float x,float y, int k, int p)
{
int xt=200, yt=15, kt=2;
Image1->Canvas->TextOut(xt-50,(kt-1)*yt,"k");
Image1->Canvas->TextOut(xt, (kt-1)*yt,"pk");
Image1->Canvas->TextOut(xt+100, (kt-1)*yt,"(x k+1,y k+1)");
}
Output

3.3

Algoritma Pembentukan Lingkaran

Pada umumnya, lingkaran digunakan sebagai komponen dari suatu gambar. Prosedur
untuk menampilkan lingkaran dan elips dibuat dengan persamaan dasar dari lingkaran
x2+y2=r2.
Lingkaran adalah kumpulan dari titik-titik yang memiliki jarak dari titik pusat yang sama
untuk semua titik. Lingkaran dibuat dengan menggambarkan seperempat lingkaran, karena
bagian lain dapat dibuat sebagai bagian yang simetris. Penambahan x dapat dilakukan dari 0
ke r sebesar unit step, yaitu menambahkan y untuk setiap step.

Simetris delapan titik

Proses pembuatan lingkaran dapat dilakukan dengan menentukan satu titik awal. Bila titik
awal pada lingkaran (x,y), maka terdapat tiga posisi lain, sehingga dapat diperoleh delapan
titik. Dengan demikian, hanya diperlukan untuk menghitung segmen 45 o dalam menentukan
lingkaran selengkapnya. Delapan titik simetris, yaitu :
Kuadran I (x,y),(y,x)
Kuadran II (-x,y),(-y,x)
Kuadran III (-x,-y),(-y-x)
Kuadran IV (x,-y),(y,-x)
Algoritma lingkaran midpoint disebut juga algoritma lingkaran Bressenham. Algoritma yang
digunakan membentuk semua titik berdasarkan titik pusat dengan penambahan semau jalur
disekeliling lingkaran. Dalam hal ini hanya diperhatikan bagian 45 o dari suatu lingkaran,
yaitu oktan kedua dari x = 0 ke x = R/
, dan menggunakan prosedur circle point untuk
menampilkan titik dari seluruh lingkaran.
fcircle(x,y)

1)
2)
3)

4)

fungsi lingkaran menggambarkan posisi midpoint antara pixel yang terdekat dengan
jalur lingkaran setiap step. Fungsi lingkaran menentukan parameter pada algoritma
lingkaran.
Langkah-langkah pembentukan lingkaran :
Tentukan radius r dengan titik pusat lingkaran (xc,yc) kemudian diperoleh (xc,yc)= 0,r).
Hitung nilai dari parameter P0 = 1-r
Tentukan nilai awal k = 0, untuk setiap posisi xk berlaku sbb :
Bila pk <0, maka titik selanjutnya adalah (xk+1,yk)
Pk+1 = pk +2xk+1+1
Bila pk >0, maka titik selanjutnya adalah (xk+1,yk-1)
Pk+1 = pk +2 xk+1+1 - 2 yk+1
Dimana 2 xk+1 = 2 xk + 2 dan 2 yk+1 = 2 yk 2
Tentukan titik simetris pada ketujuh oktan yang lain.

5)
6)

Gerakkan setiap posisi pixel (x,y) pada garis melingkar dari lingkaran dengan titik pusat
(xc,yc) dan tentukan nilai koordinat : x= x + xc dan y = y + yc
Ulangi langkah ke 3 -5, sampai dengan x>=y
Contoh :
Untuk menggambarkan algoritma Bressenham dalam pembentukan suatu lingkaran dengan
titik pusat (0,0) dan radius 10, perhitungan berdasarkan pada oktan dari kuadran pertama
dimana x =0 sampai x =y.
Penyelesaian :
(x0,y0) =(0,0) r = 10
(x0,y0) = (0,10) 2x0 = 0, 2y0 = 20
parameter p0 = 1-r = -9