LAPORAN TUGAS MINGGU 6

Komputer Grafik Teori

Laporan ini disusun untuk memenuhi Tugas Mata Kuliah Komputer Grafik Teori.

Disusun oleh:

Alex Sinaga 191524033

PROGRAM STUDI D4 TEKNIK INFORMATIKA

JURUSAN TEKNIK KOMPUTER DAN INFORMATIKA
POLITEKNIK NEGERI BANDUNG
2021
 Analisis Algoritma Midpoint Circle

Algoritma midpoint circle merupakan algoritma pembentuk lingkaran dengan cara membagi
lingkaran menjadi delapan bagian. Algoritma tersebut akan menggambar satu bagian lalu
selanjutnya dapat menentukan 7 bagian yang lainnya. Mengapa dengan hanya menggambar satu
bagian dapat menggambar bagian lainnya? Hal tersebut dikarenakan lingkaran adalah objek
simetris, sehingga hal ini dimanfaatkan guna mengurangi pekerjaan pada saat menggambar
lingkaran. Berikut bagian-bagian lingkaran yang dimaksud:
Bagian x y

1 a b

2 -a b

3 a -b

4 -a -b

5 b a

6 -b a

7 b -a

8 -b -a

Berdasarkan ilustrasi diatas, kita simpulkan bagian-bagian tersebut saling bercermin (reflection)
dengan syarat saling bersebelahan satu dengan yang lainnya. Hal ini tentu sangat mendukung
pernyataan diatas, yaitu “Algoritma tersebut akan menggambar satu bagian lalu selanjutnya
dapat menentukan 7 bagian yang lainnya”. Berikut source code dari midpoint circle tersebut:
func plotCircle(x,y,absis,ordinat):
var absisC = x
var ordinatC = y

setPixel(absisC + absis, ordinatC + ordinat, Color.white) # (a,b) [R1]

setPixel(absisC - absis, ordinatC + ordinat, Color.black) # (-a,b) [R2]
setPixel(absisC + absis, ordinatC - ordinat, Color.blue) # (a,-b) [R3]
setPixel(absisC - absis, ordinatC - ordinat, Color.red) # (-a,-b)[R4]

setPixel(absisC + ordinat, ordinatC + absis, Color.green) # (b,a) [R1]

setPixel(absisC - ordinat, ordinatC + absis, Color.orange) # (-b,a) [R2]
setPixel(absisC + ordinat, ordinatC - absis, Color.sienna) # (b,-a) [R3]
setPixel(absisC - ordinat, ordinatC - absis, Color.hotpink) # (-b,-a)[R4]
func midpointCircle(x,y,jangkauan):
var absis = 0
var ordinat = jangkauan
var plot = 1-jangkauan
plotCircle(x,y,absis,ordinat)
while(absis<ordinat):
absis+=1
if plot<0:
plot+=2*absis+1
else:
ordinat-=1
plot+=2*(absis-ordinat)+1
plotCircle(x,y,absis,ordinat)
 Analisis Algoritma Midpoint Elips

Algoritma midpoint elips merupakan algoritma pembentuk elips dengan cara membagi elips
menjadi empat kuadran. Sama halnya dengan lingkaran, algoritma pembentuk elips ini akan
menggambar satu kuadran lalu akan menggambarkan ketiga lainnya.
Kuadran pertama dibagi menjadi dua bagian. Titik plot untuk bagian I, lalu koordinat akhir
bagian I dijadikan koordinat awal bagian II.
Dua cara menggambarkan kedua bagian tersebut:
I. Posisi awal di titik (0,r), lalu bergeser/digambarkan searah jarum jam sesuai dengan
jalur elips pada kuadran pertama. Setiap pergeseran dalam x disaat slope > 1.
II. Posisi awal di titik (r,0) lalu bergeser/digambarkan berlawanan arah jarum jam. Setiap
pergeseran dalam y disaat slope > -1.

Ilustrasi pembagian region pada penggambaran elips

Ilustrasi penggambaran elips

Berikut source code dari midpoint elips tersebut:
void ellipseMidpoint (int xCenter, int yCenter, int Rx, int Ry)
{
int Rx2 = Rx*Rx;
int Ry2 = Ry*Ry;
int twoRx2 = 2*Rx2;
int twoRy2 = 2*Ry2;
int p;
int x = 0;
int y = Ry;
int px = 0;
int py = twoRx2 * y;
void ellipsePlotPoints (int, int, int, int);
// Plot the first set of points
ellipsePlotPoints (xCenter, yCenter, x, y);
// Region 1 *I
p = ROUND (Ry2 - (Rx2 * Ry) + (0.25 * Rx2));
while (px < py) {
x++;
px += twoRy2;
if (p < 0)
p += Ry2 + px;
else {
y--;
py -= twoRx2;
p += Ry2 + px - py;
}
ellipsePlotPoints (xCenter, yCenter, x, y);
}
/* Region 2 */
p = ROUND (Ry2*(x+0.5)*(x+0.5) + Rx2*(y-1)*(y-1) - Rx2*Ry2);
while (y > 0) {
y--;
py -= twoRx2;
if (p > 0){
p += Rx2 - py;
}
else {
x++;
px += twoRy2;
p += Rx2 - py + px;
}

ellipsePlotPoints (xCenter, yCenter, x, y);

}

void ellipsePlotPoints (int xCenter, int yCenter, int x, int y)

{
putpixel (xCenter + x, yCenter + y,WHITE);
putpixel (xCenter - x, yCenter + y,WHITE);
putpixel (xCenter + x, yCenter - y,WHITE);
putpixel (xCenter - x, yCenter - y,WHITE);

}
MATA
extends "res://Library/CompleteLib.gd"

func _ready():
pass

func _draw():
var i; var j; var k; var l;
i=randi()%int(max_width)
j=randi()%int(max_height)
k=randi()%500
l=randi()%500
rotasi(Vector2(250,250),Vector2(200,200),90)
elipsMidpoint(i,j,k,l)
pass

func elipsPlotPoint(xCenter,yCenter,x,y):
setPixel(xCenter + x, yCenter + y, Color.white)
setPixel(xCenter - x, yCenter + y, Color.blue)
setPixel(xCenter + x, yCenter - y, Color.yellow)
setPixel(xCenter - x, yCenter - y, Color.orange)
pass

func elipsMidpoint(xCenter,yCenter,Rx,Ry):
var Rx2 = Rx*Rx
var Ry2 = Ry*Ry
var twoRx2 = 2*Rx2
var twoRy2 = 2*Ry2
var p
var x = 0
var y = Ry
var px = 0
var py = twoRx2 * y
#elipsPlotPoint(xCenter,yCenter,x,y)

# Plot first set of points

elipsPlotPoint(xCenter,yCenter,x,y);

# Region 1
p = round(Ry2 - (Rx2 * Ry) + (0.25 * Rx2))
while(px<py):
x+=1
px+=twoRy2
if(p<0):
p+=Ry2+px
else:
y-=1
py-=twoRx2
p+=Ry2+px-py
elipsPlotPoint(xCenter,yCenter,x,y)
elipsPlotPoint(xCenter,yCenter,x,y)

# Region 2
p = round(Ry2*(x * 0.5)*(x + 0.5) + Rx2*(y-1)*(y-1) - Rx2*Ry2)
while(y>0):
y-=1
py-=twoRx2
 if(p>0):
p+=Rx2-py
else:
x+=1
px+=twoRy2
p+=Rx2-py+px
elipsPlotPoint(xCenter,yCenter,x,y)
elipsPlotPoint(xCenter,yCenter,x,y)
pass