LINE EQUATION (PERSAMAAN GARIS)

Gradien suatu garis adalah perbandingan antara komponen y (kordinat) dan komponen
x (absis) antara dua titik pada garis itu. Gradien suatu garis biasanya dinotasikan dengan
huruf kecil m. Perhatikan gambar dibawah ini !

komponen y dari garis AB = y2 - y1 ; komponen x dari garis AB = x2 - x1, maka :

Catatan : gradien sebuah garis sering disebut kecondongan sebuah garis atau koefisien arah
sebuah garis.
Persamaan garis lurus ditulis dengan rumus :

y = Mx + b

1.1 Garis dengan gradien m dan melalui 1 titik

Perhatikan gambar dibawah ini !

Pada garis l terdapat titik A dengan koordinat (x1, y1) dan titik B dengan koordinat bebas,
yaitu (x , y), bila gradien garis l dinyatakan dengan m, maka AB terdiri atas semua titik (x,y)
dengan hubungan berikut ini :

y - y1 = m (x - x1)
Kesimpulan :
Persamaan garis dengan gradien m dan melalui sebuah titik (x1 , y1), adalah :

y - y1 = m (x - x1)

1.2 Persamaan garis yang melalui dua titik

Gradien garis yang melalui titik (x1, y1) dan (x2, y2) yaitu
gambar di bawah ini,

seperti pada

Selanjutnya dengan menggunakan rumus persamaan garis dengan gradient m dan melalui
sebuah titik (x1 , y1), yaitu y - y1 = m ( x - x1 ) dapat diperoleh rumus berikut :

y - y1 = m ( x - x 1 )
y - y1

y - y1 = y 2 - y1 =

Kesimpulan :
Persamaan garis yang melalui titik (x1, y1) dan (x2, y2) yaitu :

FLOWCHART ALGORITMA LINE EQUATION

IMPLEMENNTASI PROGRAM ALGORITMA LINE EQUATION

program hitung_gradien_dan_persamaan garis ;
uses wincrt;
var
x1,y1,x2,y2,m,xy:real;
begin
writeln('-------------------------------------------------------------');
writeln('PROGRAM HITUNG GRADIEN');
writeln('DAN PERSAMAAN GARIS LURUS');
writeln('-------------------------------------------------------------');
writeln;
write('Koordinat x1=');readln(x1);

writeln;
write('Koordinat y1=');readln(y1);
writeln;
write('Koordinat x2=');readln(x2);
writeln;
write('Koordinat y2 =');readln(y2);
writeln;
m:=(y2-y1)/(x2-x1);
writeln('Gradien Garis =',m:0:0);
writeln;
xy:=-1*m*x1+y1;
writeln('Persamaan Garis =y:',m:0:0,'x',xy:0:0);
writeln;
writeln('------------------------------------------------------------');
end.

LINE CLIPPING
Kliping sebuah garis P1 dan P2 dengan jendela L, R, T, dan B akan berhubungan
dengan garis yang terletak di dalam jendela dan garis di luar jendela. Garis yang berada di
dalam jendela adalah garis yang akan ditampilkan (P1 P2), sedangkan garis yang terletak
di luar jendela dibuat tidak tampak (P1 P1 dan P2 P2)

Untuk menentukan letak sebuah garis di dalam jendela kliping dilakukan analisis
letak titik yang menentukan garis tersebut dan memastikan bahwa titik-titik tersebut berada
di dalam jendela kliping.

Titik Asli

Titik Semu

Kondisi X

Kondisi Y

P1(x,y)

P1(x,y)

P1(x) L

P1(y) T

P2(x,y)

P2(x,y)

P2(x) R

P2(x) B

Kondisi garis terhadap jendela kliping :

Invisible
Visible
Halfpartial

atas, bawah, kiri atau kanan

Vollpartial : Terpotong penuh oleh jendela kliping. Garis melintasi jendela kliping

: Tidak kelihatan, terletak di luar jendela kliping

: Terletak di dalm jendela kliping
: Terpotong sebagian oleh jendela kliping, bisa hanya dnegan bagian

FLOWCHART ALGORITMA LINE CLIPPING

LINE CLIPPING MENGGUNAKAN COHEN-SUTHERLAND ALGORITHM

Hubungan antara sebuah garis dengan jendela kliping dapat ditulis seperti hubungan
antara titik awal dan titik akhir sebuah garis dengan jendela kliping
P1(x,y) dan P2(x,y) W(L,R,T,B)

Untuk menentukan relasi tersebut diperlukan suatu struktur data pembantu yang
disebut pointcode. Dengan pointcode kita dapat mengidentifikasi posisi titik

terhadap jendela kliping.

Nilai untuk pointcode l, r, t dan b adalah 1 dan 0 yang merupakan nilai logika yang

dapat dimengerti dengan nilai true dan false.

Suatu titik yang visible berarti titik tersebut terletak di dalam jendela kliping, dan

invisible jika terletak di luar jendela kliping.

Suatu titik itu visible dengan pointcode jika nilai l, r, t dan b adalah nol, artinya jika
salah satu nilai dari l, r, t dan b tidak sama degan nol maka dapat diketahui bahwa

titik tersebut terletak di luar jendela kliping dan diketahui pada posisi mana.
Berdasarkan urutan kode, pointcode ditentukan :

Pointcode

Arti Kode

0000

Terletak di dalam jendela kliping

0001

Terletak di sebelah kiri jendela kliping

0010

Terletak di sebelah kanan jendela kliping

0100

Terletak di sebelah bawah jendela kliping

0101

Terletak di sebelah kiri bawah jendela kliping

0110

Terletak di sebelah kanan bawah jendela

1000

kliping
Terletak di sebelah atas jendela klipig

1001

Terletak di sebelah kiri atas jendela kliping

1010

Terleak di sebelah kanan atas jendela kliping

Titik terletak di dalam jendela kliping jika jumlah keempat pointcode adalah nol :L +

R+T+B =0
Titik terletak di luar jendela kliping jika jumlah keempat pointcode lebih besar

dari nol. L + R + T + B > 0

Visibilitas suatu garis tergantung dari pointcode pada kedua titik yang membentuk
garis tersebut, yaitu P1 dan P2.
- Jika P1 dan P2 di dalam jendela kliping maka garis adalah visible
- Jika salah satu dari titik P1 atau P2 di uar jendela kliping, artinya garis adalah
halfpartial
Jika titik P1 dan P2 di luar jendela kliping, artinya garis adalah invisible.
Jika P1 dan P2 melintasi jendela kliping, artinya garis adalah vollpartial

Algoritma Kliping Cohen Sutherland :

1.
Tentukan regioncode dari setiap endpoint
2.
Jika kedua endpoint memiliki regioncode 0000, maka garis berada di
3.

4.

dalam jendela kliping. Gambar garis tersebut

Jika tidak, lakukan operasi logika AND untuk kedua regioncode
3.1.
Jika hasilnya 0000, maka buang garis tersebut (tolak)
3.2.
Jika tidak (hasilnya 000), maka dibutuhkan kliping
3.2.1 Pilih salah satu endpoint yang berada di luar jendela kliping
3.2.2 Cari titik persinggungan pada batas jendela (berdasarkan regioncode)
3.2.3 Ganti endpoint dengan titik persinggungan dan update regioncode
3.2.4 Ulangi langkah 2 hingga diperoleh garis klipping yang diterima dan
yang ditolak
Ulangi langkah 2 untuk garis yang lain.

Daerah titik persinggungan dapat dilihat dari nilai bit :

- Jika bit 1 = 1, titik persinggungan ada di atas
- Jika bit 2 = 1, titik persinggungan ada di bawah
- Jika bit 3 = 1, titik persinggungan ada di kanan
- Jika bit 4 = 1, titik persinggungan ada di kiri

Titik persinggungan dapat dicari dengan persamaan garis :

- Persinggungan antara batas KIRI dan KANAN

Persinggungan antara batas ATAS dan BAWAH

IMPLEMENTASI PROGRAM LINE CLIPPING MENGGUNAKAN COHENSUTHERLAND ALGORITHM

#define OutCode int
const int INSIDE = 0; // 0000
const int LEFT = 1; // 0001
const int RIGHT = 2; // 0010
const int BOTTOM = 4; // 0100
const int TOP = 8;

// 1000

// Compute the bit code for a point (x, y) using the clip rectangle
// bounded diagonally by (xmin, ymin), and (xmax, ymax)
OutCode ComputeOutCode(double x, double y)
{
OutCode code;
code = INSIDE;
if (x < xmin)

// initialized as being inside of clip window

// to the left of clip window

code |= LEFT;
else if (x > xmax)

// to the right of clip window

code |= RIGHT;
if (y < ymin)

// below the clip window

code |= BOTTOM;
else if (y > ymax)

// above the clip window

code |= TOP;
return code;

}
// CohenSutherland clipping algorithm clips a line from
// P0 = (x0, y0) to P1 = (x1, y1) against a rectangle with
// diagonal from (xmin, ymin) to (xmax, ymax).
void CohenSutherlandLineClipAndDraw(double x0, double y0, double x1, double y1)
{
// compute outcodes for P0, P1, and whatever point lies outside the clip
rectangle
OutCode outcode0 = ComputeOutCode(x0, y0);
OutCode outcode1 = ComputeOutCode(x1, y1);
bool accept = false;
while (true) {
if (!(outcode0 | outcode1)) {

//logical or is 0. Trivially accept and get

out of loop
accept = true;
break;
} else if (outcode0 & outcode1) {

//logical and is not 0. Trivially reject

and get out of loop

break;
} else {
// failed both tests, so calculate the line segment to clip
// from an outside point to an intersection with clip edge
double x, y;
// At least one endpoint is outside the clip rectangle; pick it.
OutCode outcodeOut = outcode0? outcode0 : outcode1;
// Now find the intersection point;
// use formulas y = y0 + slope * (x - x0), x = x0 + (1 / slope) * (y - y0)
if (outcodeOut & TOP) {

// point is above the clip rectangle

x = x0 + (x1 - x0) * (ymax - y0) / (y1 - y0);

y = ymax;
} else if (outcodeOut & BOTTOM) {

// point is below the clip

rectangle
x = x0 + (x1 - x0) * (ymin - y0) / (y1 - y0);

y = ymin;
} else if (outcodeOut & RIGHT) {

// point is to the right of clip

rectangle
y = y0 + (y1 - y0) * (xmax - x0) / (x1 - x0);
x = xmax;
} else if (outcodeOut & LEFT) {

// point is to the left of clip

rectangle
y = y0 + (y1 - y0) * (xmin - x0) / (x1 - x0);
x = xmin;
}
// Now we move outside point to intersection point to clip
// and get ready for next pass.
if (outcodeOut == outcode0) {
x0 = x;
y0 = y;
outcode0 = ComputeOutCode(x0, y0);
} else {
x1 = x;
y1 = y;
outcode1 = ComputeOutCode(x1, y1);
}
}
}
if (accept) {
// Following functions are left for implementation by user based on his
platform(OpenGL/graphics.h etc.)
DrawRectangle(xmin, ymin, xmax, ymax);
LineSegment(x0, y0, x1, y1);
}
}

ALGORITMA MIDPOINT UNTUK PENGGAMBARAN GARIS

Algoritma midpoint dikembangkan oleh Pitteway pada tahun 1967. Pada gambar di
atas, 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.

Persamaan garis lurus dalam persamaan y = mx + c dapat dinyatakan dalam fungsi x,y
berikut.
f(x, y) = ax + by + c = 0 ..(1)

Fungsi f(x,y) dalam persamaan di atas, 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 di atas 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)

Fungsi g(x,y) persamaan di atas 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 1 dan persamaan 2.

DeltaG = a * DeltaX + b * DeltaY (3)

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 (4)
Bila bergeser 1 piksel ke kanan dan 1 piksel ke atas.
DeltaG2 = a + b (5)
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 c = y1

m* x1.

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

3.
4.

tambahkan (a) pada variabel penentu.

Plot piksel pada posisi (x, y).
Ulangi langkah mulai langkah kedua, sampai piksel terakhir (x2,y2).

IMPLEMENTASI PROGRAM ALGORITMA MIDPOINT

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <math.h>
int line_mid(int x1,int y1,int x2,int y2,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();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", 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.%02d\n",
t1.ti_hour, t1.ti_min, t1.ti_sec, t1.ti_hund);// draw line graphics
// line_mid(0,0,xmax*1,ymax*1,1);
// get finish time
gettime(&t2);
printf("The Finish time is: %2d:%02d:%02d.%02d\n",
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_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);
}

DAFTAR PUSTAKA

http://genius.smpn1mgl.sch.id/file.php/1/animasi/matematika/persamaan%20garis
%20lurus/index.html
http://courses.wccnet.edu/~palay/precalc/218601.htm
http://blogaanwati.files.wordpress.com/2013/02/grafik-komputer-clipping.pdf.
http://selametsubu.blogspot.com/2010/10/cohensutherland-line-clipping-algorithm.html
http://faculty.petra.ac.id/kgunadi/midpoint.html