22

BAB III

METODE PENELITIAN

3.1. Perancangan Sistem dan Blok Diagram Sistem

Model penelitian yang akan dilakukan adalah model penelitian

pengembangan. Untuk mempermudah dalam memahami sistem yang akan dibuat

dapat dijelaskan melalui blok diagram pada Gambar 3.1.

Gambar 3.1. Blok Diagram

Penelitian yang dilakukan memiliki 2 tahap utama, yaitu bagian pre-

processing dan segmentasi menggunakan CPM.

1. Pre-processing

Pre-processing yaitu proses untuk filtering citra. filtering digunakan

untuk memperjelas bagian gambar tulang punggung yang biasanya kurang

terlihat jelas, dikarenakan tertutup tulang dada dan organ-organ tubuh yang

Citra hasil

Segmentasi menggunakan CPM

Pre-processing

Citra Sinar X Tulang Belakang

23

berada di sekitar daerah dada. Pre-processing yang digunakan yaitu Modified

Tophat filter dan Gaussian cropping. Modified Tophat filter digunakan untuk

mengurangi noise pada daerah tulang belakang. Gaussian cropping digunakan

untuk menghilangkan dan mengurangi noise dari bagian-bagian citra sinar x

yang tidak diperlukan.

2. Segmentasi menggunakan charged particle model (CPM)

Segmentasi dilakukan untuk memperoleh segmentasi kelengkungan

tulang belakang pada citra tulang belakang yang sudah selesai difilter. Setelah

didapatkan citra hasil filtering, maka selanjutnya inisialisasi partikel-partikel

di sekitar tulang belakang. Partikel-partikel ini yang nantinya akan bergerak

berdasarkan gaya total yang diperoleh dari gaya Lorentz dan Coulomb dari

citra.

3.2. Perancangan Perangkat Lunak

Pada perancangan CPM ini, penulis menggunakan compiler Microsoft

Visual C++ 2008 dan library yang digunakan adalah OpenCV v1.1, library ini

menyediakan fungsi-fungsi yang akan digunakan untuk pengolahan citra.

Dalam penulisan dan pembuatan program, akan meliputi bagian-bagian

penting dalam setiap langkah-langkah per bagian sesuai dengan algoritma atau

logika sekuensial dari awal sampai output. Flowchart program secara global

dijelaskan pada gambar 3.2.

24

Gambar 3.2. Flowchart program

Penjelasan flowchart:

1. Inputkan citra sinar x tulang belakang yang akan diproses.

2. Citra yang telah diinputkan selanjutnya diproses menggunakan Modified

Tophat filter

3. Citra hasil Modified Tophat filter selanjutnya diproses menggunakan Gaussian

cropping.

End

Citra hasil segmentasi

menggunakan CPM

Iterasi <1000

Hitung gaya Lorentz Inisialisasi partikel Iterasi dimulai dari 0

Gaussian Cropping

Modified Tophat filter

Input Citra Sinar X Tulang Belakang

Start

T

Y Hitung gaya Coulomb Hitung gaya total Update posisi partikel Iterasi bertambah 1

25

4. Hitung gaya Lorentz dari citra hasil Gaussian cropping, digunakan sebagai

medan gaya negatif.

5. Selanjutnya proses inisialisasi partikel-partikel yang nantinya akan bergerak

menuju tepi dari tulang belakang yang berada di citra.

6. Proses iterasi dimulai dari 0 dan akan berulang sebanyak 1000 iterasi.

7. Hitung gaya Coulomb dari partikel-partikel, kemudian kalkulasikan dengan

gaya Lorentz untuk mendapatkan gaya total, dari gaya total akan didapatkan

posisi baru dari tiap partikel.

8. Citra hasil segmentasi akan didapatkan setelah langkah ke-7 berulang

sebanyak iterasi yang ditentukan.

3.2.1. Perancangan Modified Tophat Filter

Tahap awal dari proses pre-processing adalah proses filtering untuk

memperjelas citra tulang belakang dan mengurangi noise di sekitar tulang

belakang menggunakan Modified Tophat filter.

Rumus Modified Tophat filter adalah :

modTH= 풇 ∘ 풃 풇풇 • 퐛

× Ɣ ...........................................................................(3.1)

Dimana : f = citra gambar

b = struktur elemen

∘ = operator morfologi closing

• = operator morfologi opening

Ɣ = attenuation factor

Alur proses Modified Tophat filter bisa dilihat pada flowchart dibawah ini :

26

Gambar 3.3. Flowchart Modified Tophat filter

Jika diprogram menggunakan rumus Modified Tophat filter, maka dapat ditulis

code program sebagai berikut :

int disk = 5, factor = 11; norMat(f, f32Image, 1); IplConvKernel *B =cvCreateStructuringElementEx(2*disk+1, 2*disk+1, disk, disk, CV_SHAPE_ELLIPSE, 0); //B = disk(5) cvMorphologyEx(f32Image,TH,tempMat,B,CV_MOP_OPEN,1);//opening cvMorphologyEx(f32Image,CL,tempMat,B,CV_MOP_CLOSE,1);//closing cvSub(TH,f32Image,TH); //TH=TH-f cvDiv(TH, CL, modTH, factor); //ModTH=(TH/CL)*atten_factor norMat(modTH,modTH); cvCopyImage(modTH,result);

Hasil yang diperoleh ditunjukan pada gambar 3.4 :

End

Citra hasil modified tophat filter

ModTH = x Ɣ

TH = TH – f

TH = f ∘ B (opening) CL = f • B (closing)

Inisialisasi struktur elemen (B) = disk(5) dan Attenuation Factor (Ɣ) = 11

Input Citra Sinar X (f)

Start

27

Gambar 3.4. Hasil Modified Tophat filter

Perancangan Modified Tophat filter dimulai dengan melakukan operasi

opening , yaitu proses erosi dilanjutkan dengan dilasi pada citra gambar dengan

struktur elemen bertipe disk dengan ukuran 5. Hasil dari proses opening kemudian

dikurangkan dengan citra awal dari citra gambar sehingga menyisakan tepi dari

objek saja. Selanjutnya dilakukan proses closing menggunakan citra awal, yaitu

proses dilasi yang dilanjutkan dengan erosi dengan menggunakan struktur elemen

berukuran sama. Proses opening menyebabkan citra menjadi lebih mengembang,

sebaliknya proses closing menyebabkan citra menyusut. Kemudian hasil dari

opening dikurangi citra awal dibagi dengan hasil closing untuk menghilangkan

sisa noise selanjutnya dikalikan dengan attenuation factor untuk memperjelas

bentuk tepi.

28

3.2.2. Perancangan Gaussian Cropping

Tahap kedua dari proses pre-processing adalah dengan menghilangkan

dan mereduksi noise pada bagian-bagian dari citra sinar x yang tidak diperlukan

khususnya bagian kanan dan kiri dari citra tulang belakang menggunakan

Gaussian cropping.

Rumus Gaussian cropping adalah :

Gaussian = 퐞퐱퐩(퐛 퐚)ퟐ

(ퟐ퐜)ퟐ ...........................................................................(3.2)

Keterangan : a = koordinat piksel pada citra

b = koordinat center of peak dari fungsi Gaussian

c = standar deviasi

Gambar 3.5. Kurva fungsi Gaussian (Sugianto, 2013)

Alur dari penggunaan Gaussian cropping bisa dilihat pada gambar 3.6 :

29

Gambar 3.6 Flowchart Gaussian cropping

Jika diprogram menggunakan rumus Gaussian cropping, maka dapat

ditulis kode program sebagai berikut :

Nilai piksel = nilai piksel * gaussian

Gaussian = 퐞퐱퐩(퐛 퐚)ퟐ

( )ퟐ

Y == 푦

Y<height citra

Inisialisasi garis Simpan koordinat dari

setiap garis (푥 , 푦 ) Y=0

Input Citra hasil ModTH

Start

Y

T

Y Nilai piksel = 0

Citra hasil segmentasi

menggunakan CPM

End

T

30

int counter=0; int jmlh_baru=jmlh;

//baris atas for (int i=1;i<=koordinat[1][2];i++)

for (int j=0;j<=edge->width;j++) edge->imageData[edge->widthStep*i + j*edge->nChannels]=0;

//baris tengah int index=1; for (int y=koordinat[1][2];y<=koordinat[jmlh_baru][2];y++){

if (y==koordinat[index][2]){ y=koordinat[index][2];

float nilai=0; for (int x=0;x<=edge->width;x++){

double gaussian=0; gaussian=((koordinat[index][1]-x) *(koordinat[index][1]-x)) / ((2*10)*(2*10)); gaussian=exp(-(gaussian)); nilai=(uchar)edge -> imageData[edge->widthStep*y + x*edge->nChannels]; edge->imageData[edge->widthStep * y

+ x* edge->nChannels]=nilai* gaussian; } index=index+1; }else{ for (int x=0;x<edge->width;x++){ edge->imageData[edge->widthStep * y + x*edge->nChannels] =(uchar)edge ->imageData [edge->widthStep*(y-1) +

x*edge->nChannels]; } } } //baris bawah for (int y=koordinat[jmlh_baru][2];y<=edge->height-1;y++) for (int x=0;x<=edge->width;x++) edge->imageData[edge->widthStep*y + x*edge->nChannels]=0; cvDestroyWindow("Gaussian Filter"); cvNamedWindow("Gaussian Filter",1); cvShowImage("Gaussian Filter",edge); //kosongkan SLL while (!InitContour.empty()){ InitContour.pop_back(); } std::cout<<"kosong"<<std::endl;

Kode program untuk proses inisialisasi diletakkan pada function terpisah,

ditulis sebagai berikut:

void gausian(IplImage * img) {

cvCopyImage(img,temp); int k=0; int l=0; for (int x=0;x<InitContour.size();x++) { cvLine(temp, InitContour[k], InitContour[l],

cvScalarAll(100), 1);

31

cvShowImage( "srcImage", temp ); k=l; l=l+1; }

} void filter( int event, int x, int y, int flags, void* ptr) {

if(event == CV_EVENT_LBUTTONDOWN) { gausian((IplImage *)ptr); jmlh=jmlh+1; InitContour.push_back(cvPoint(x,y)); koordinat[jmlh][1]=x; koordinat[jmlh][2]=y; q=1; } if (q==1) { if (event==CV_EVENT_MOUSEMOVE) { gausian((IplImage *)ptr); jmlh=jmlh+1; InitContour.push_back(cvPoint(x,y)); koordinat[jmlh][1]=x; koordinat[jmlh][2]=y; } }

}

Diawali dengan membuat inisialisasi pada citra tulang belakang

menggunakan gerakan mouse dan menyimpan setiap titik yang dilewati oleh

mouse. Untuk setiap titik tersebut akan menjadi titik puncak dari fungsi Gaussian

sehingga semakin ke kanan dan ke kiri dari koordinat x dari titik puncak akan

menghasilkan nilai Gaussian yang mendekati nilai 0, nilai Gaussian tersebut

kemudian dikalikan dengan nilai piksel awal untuk menghasilkan nilai piksel yang

baru. Penentuan nilai variabel c disesuaikan dengan lebar dari tulang belakang.

Hasil yang diperoleh ditunjukan oleh Gambar 3.7.

32

Gambar 3.7 Hasil Gaussian cropping dengan nilai c=10

3.2.3. Perancangan Charged Particle Model (CPM)

Perancangan CPM meliputi perancangan negative field yang diaplikasikan

sebagai gaya Lorentz citra sinar x dan partikel positif yang diaplikasikan sebagai

gaya Coulomb. Setelah gaya Lorentz dan Coulomb didapat maka diteruskan

dengan perhitungan pergerakan partikel. Partikel bergerak sebanyak 1000 iterasi,

dimana tiap iterasinya dihitung nilai Coulomb, gaya total, kecepatan partikel,

percepatan partikel, dan posisi partikel yang baru.

A. Perancangan Negatif Field

Gaya Lorentz pada citra berfungsi sebagai medan gaya negatif. Hasil

perhitungan dari medan gaya negatif dan partikel positif ini yang menunjukkan

arah partikel positif untuk bergerak. Perhitungan gaya Lorentz menggunakan

33

rumus yang ada pada persamaan (2.7). Alur dari perancangan gaya Lorentz sesuai

dengan flowchart pada gambar 3.8.

Gambar 3.8. Flowchart menghitung gaya Lorentz

Penjelasan flowchart:

1. Citra input didefinisikan sebagai variabel f.

2. Hitung Gradient Map dari f dan simpan dengan variabel (gx,gy).

3. Setelah mendapat (gx,gy), langkah selanjutnya adalah mencari nilai magnitude

didefinisikan sebagai variabel e.

4. Dari variabel e langkah selanjutnya adalah menghitung energi potensial.

5. Hitung Gradient Map dari energi potensial hasil dari langkah sebelumnya,

simpan ke variabel (Ex,Ey).

34

6. Langkah terakhir adalah menghitung gaya Lorentz (FLx,FLy).

Yang jika diimplementasikan dalam bentuk program ditulis seperti di bawah ini :

IplImage *src; CvMat *CH, *fx, *fy, *X, *Y, *x, *y; char gam[100], lok[100]; double ip,is,in,itot; //load image grayscale --> src strcpy(lok, "C:/2/fr10"); strcpy(gam, lok); strcat(gam, ".jpg"); src = cvLoadImage(gam, CV_LOAD_IMAGE_GRAYSCALE); CH = cvCreateMat(m, n, CV_32FC1); fx = cvCreateMat(m, n, CV_32FC1); fy = cvCreateMat(m, n, CV_32FC1); X = cvCreateMat(m, n, CV_32FC1); Y = cvCreateMat(m, n, CV_32FC1); x = cvCreateMat(1, n, CV_32FC1); y = cvCreateMat(1, m, CV_32FC1); //menghitung gradient map terhadap sumbu x citra input --> fx for(int j=0; j<m; j++){ for(int i=0; i<n; i++){ ip = ((double)src -> imageData [src->widthStep*j + (i+1)*src->nChannels]); is = ((double)src -> imageData [src->widthStep*j + i*src->nChannels]); in = ((double)src -> imageData [src->widthStep*j + (i-1)*src->nChannels]); if(i==0){ itot = ip-is; }else if(i==n-1){ itot = is-in; }else{ itot = ((ip - is) + (is - in)) / 2; } cvmSet(fx, j, i, itot); } } //menghitung gradient map terhadap sumbu y citra input --> fy for(int j=0; j<m; j++){ for(int i=0; i<n; i++){ ip = ((double)src -> imageData [src->widthStep*(j+1) + i*src->nChannels]); is = ((double)src -> imageData [src->widthStep*j + i*src->nChannels]); in = ((double)src -> imageData [src->widthStep*(j-1) + i*src->nChannels]); if(j==0){ itot = ip-is; }else if(j==m-1){ itot = is-in; }else{ itot = ((ip - is) + (is - in)) / 2; } cvmSet(fy, j, i, itot);

35

} } //menghitung magnitude --> CH for (int j=0; j<m; j++){ for (int i=0; i<n; i++){ double aa = cvmGet(fx, j, i); double bb = cvmGet(fy, j, i); double cc = sqrt((aa * aa) + (bb * bb)); cvmSet(CH, j, i, cc); } } for (float i=0; i<n; i++){ cvmSet(x, 0, i, i+1); } for (float i=0; i<m; i++){ cvmSet(y, 0, i, i+1); } for (float j=0; j<m; j++){ for (float i=0; i<n; i++){ cvmSet(X, j, i, i+1); cvmSet(Y, j, i, j+1); } } for (int j=0; j<m; j++){ for (int i=0; i<n; i++){ LorentzForceX(X,Y,CH,cvmGet(x,0,i),cvmGet(y,0,j),i,j); LorentzForceY(X,Y,CH,cvmGet(x,0,i),cvmGet(y,0,j),i,j); } }

Program diatas diletakkan pada void main(). Pada penjelasan

flowchart nomor 4 dan 5 diatas dijadikan satu menjadi persamaan (2.6).

Kemudian persamaan (2.6) disubstitusikan dengan persamaan (2.5) didapatkan

persamaan (2.7) yang sudah mencakup langkah 4 sampai 6 pada penjelasan

flowchart diatas, kode program tersebut diletakkan pada dua function berikut:

double LorentzForceX (CvMat* X, CvMat* Y, CvMat* CH, double x, double y, int I, int J) double LorentzForceY (CvMat* X, CvMat* Y, CvMat* CH, double x, double y, int I, int J) Kode program dari function diatas adalah sebagai berikut:

for (int s=0; s<m; s++){ for (int t=0; t<n; t++){ double a,b;

36

a = cvmGet(X, s, t); b = cvmGet(Y, s, t); cvmSet(Rx, s, t, a-x); cvmSet(Ry, s, t, b-y); } }//ri-Rk......(1) for (int s=0; s<m; s++){ for (int t=0; t<n; t++){ double a = cvmGet(Rx, s, t); double b = cvmGet(Ry, s, t); double c = (a*a)+(b*b); double d = sqrt(c*c*c); cvmSet(R, s, t, d); } }// (ri-Rk)^3......(2) for (int s=0; s<m; s++){ for (int t=0; t<n; t++){ double a = cvmGet(Rx, s, t); double c = cvmGet(CH, s, t); double d = a*c; if (d==(-0)) d=0; cvmSet(Rx, s, t, d); } }//ek * (ri-Rk)......(3) double ac=0; for (int s=0; s<m; s++){ for (int t=0; t<I; t++){ double a = cvmGet(Rx, s, t); //Ry untuk LorentzY double c = cvmGet(R, s, t); double d = a/c; ac=ac+d; } }//jumlahkan semua nilai tiap piksel pada kolom ke-0 sampai (I-1) double fh=0; for (int s=0; s<m; s++){ for (int t=I+1; t<n; t++){ double f = cvmGet(Rx, s, t); //Ry untuk LorentzY double h = cvmGet(R, s, t); double i = f/h; fh=fh+i; } }//jumlahkan semua nilai tiap piksel pada kolom ke-(I+1) sampai n Ex=ac+fh; //jumlahkan kedua nilai di atas double ac=0; for (int s=0; s<J; s++){ double a = cvmGet(Rx, s, I); //Ry untuk LorentzY double c = cvmGet(R, s, I); double d = a/c; ac=ac+d; }//jumlahkan semua nilai tiap piksel pada kolom ke=i //baris ke-0 sampai (J-1) double fh=0; for (int s=(J+1); s<m; s++){ double f = cvmGet(Rx, s, I); //Ry untuk LorentzY

37

double h = cvmGet(R, s, I); double i = f/h; fh=fh+i; }//jumlahkan semua nilai tiap piksel pada kolom ke=i //baris ke-(J+1) sampai m Ex=Ex+ac+fh; //jumlahkan kedua nilai di atas ditambah dengan nilai //Ex sebelumnya return(Ex); //nilai Ex sebagai nilai akhir dari gaya LorentzX //Ey untuk LorentzY

Perhitungan nilai gaya Lorentz diatas diujicobakan pada citra berukuran 10x20

piksel seperti yang ditunjukkan pada Gambar 3.9.

Gambar 3.9. Citra berukuran 10x20 piksel

Nilai tiap-tiap piksel yang didapat dari hasil perhitungan gaya Lorentz dari

gambar 3.9 terhadap sumbu x adalah sebagai berikut :

88.0136 132.995 143.097 68.1244 0.614066 -20.3432 -102.779 -161.597 -118.691 -75.7633 130.631 173.818 99.2419 -15.3685 -31.8323 -0.30634 -31.5865 -129.011 -154.236 -103.792 172.102 146.647 79.4903 3.68569 -55.6242 -9.41755 -55.1135 -103.836 -128.764 -127.789

175.5 104.518 54.2632 -3.33751 -81.0894 -0.77267 -42.7589 -72.8272 -96.6623 -127.571 171.356 88.0211 41.8488 -9.56371 -91.4246 2.34226 -34.1241 -58.9244 -81.4581 -121.924 167.42 82.3215 35.8796 -14.0223 -93.4487 4.26558 -28.6939 -52.4371 -76.9728 -120.273

167.521 80.2915 32.6223 -16.3481 -95.0389 5.21113 -26.5801 -49.958 -75.5929 -118.83 165.129 79.4959 31.0238 -18.3915 -95.754 5.40245 -26.406 -47.6149 -71.8976 -117.938 164.387 77.8843 29.1481 -19.0991 -97.118 5.17375 -24.7204 -46.008 -70.2287 -116.133 163.753 77.1663 28.1702 -19.8747 -97.6683 5.5132 -24.3757 -45.1108 -68.8029 -115.023 163.246 76.7536 27.7391 -20.2475 -97.8299 5.65636 -24.1892 -44.6319 -68.071 -114.374 162.942 76.5766 27.6421 -20.2936 -97.8277 5.70693 -24.0953 -44.4342 -67.7495 -113.974 162.849 76.718 27.9146 -20.0239 -97.6736 5.69847 -24.2137 -44.5416 -67.7276 -113.761 163.046 77.4008 28.8055 -19.2402 -97.2874 5.52523 -24.7741 -45.1849 -68.149 -113.765 163.744 79.3162 30.9802 -17.3622 -96.3358 4.7558 -26.4325 -47.0403 -69.5292 -114.091 165.171 84.7014 36.1198 -12.6919 -92.9475 1.47897 -31.3752 -52.0606 -73.5178 -114.751 164.966 101.394 47.5173 -9.91632 -84.8399 -4.52043 -37.3974 -63.6232 -85.8848 -114.369 146.107 138.453 63.6729 -42.5529 -81.7438 4.36892 -12.5231 -77.3288 -111.616 -104.245 92.8302 123.263 62.201 -26.7152 -32.6177 -13.2994 -22.4757 -78.8592 -98.6632 -69.6802 58.3159 68.691 54.4202 14.6163 -12.2017 -17.6183 -43.2968 -67.7901 -57.9619 -47.2275

38

Nilai tiap-tiap piksel yang didapat dari hasil perhitungan gaya Lorentz dari

gambar 3.9 terhadap sumbu y adalah sebagai berikut :

69.3786 118.156 169.682 142.362 109.183 105 130.439 135.911 86.336 49.7954 68.9034 114.166 78.5412 42.3371 -0.29054 -10.8891 7.87279 47.5936 73.2699 44.832 48.236 55.4428 -13.3538 21.2765 1.12856 -10.0006 -14.5801 -28.2751 29.0034 27.9903

19.4998 5.24815 -31.7258 -36.5684 -59.8018 -64.9066 -48.2962 -31.915 -2.06007 11.5047 6.97394 1.29011 -8.84695 -13.6314 -18.9553 -20.8897 -16.2796 -9.53139 -0.00075 6.02884 5.12057 3.23435 -1.32576 -4.90363 -7.72763 -7.26096 -4.7884 -0.12884 2.57686 3.91392 1.89259 1.54925 -0.44343 -2.40664 -4.35352 -4.45807 -3.76507 -2.84381 0.146992 1.70904 -0.66823 -2.40577 -3.40954 -5.54383 -6.1188 -7.4167 -6.34561 -5.55092 -2.28078 -0.33896 -2.36739 -2.41663 -4.78575 -5.15023 -6.42459 -6.86254 -6.32679 -4.77875 -3.88331 -2.05617 -3.5954 -3.91917 -4.62996 -5.13204 -5.78748 -5.609 -5.38198 -5.19421 -4.09997 -3.16162

-4.66227 -5.00715 -5.29038 -5.51207 -5.65172 -5.64231 -5.52327 -5.28627 -4.86929 -4.36989 -6.27698 -6.39431 -6.37328 -6.28524 -6.19681 -6.14605 -6.13213 -6.10292 -5.98612 -5.74519 -8.20501 -8.00505 -7.5529 -7.04176 -6.66924 -6.57642 -6.75987 -7.07312 -7.32102 -7.34494 -10.5414 -9.76799 -8.4788 -7.17894 -6.25712 -6.14903 -6.82892 -7.87144 -8.82903 -9.29164 -13.5661 -11.5279 -7.98079 -5.24634 -2.62297 -2.76488 -5.00239 -7.76452 -10.5384 -11.9138 -17.4475 -13.2601 -2.67965 2.58831 13.7872 13.5791 3.20758 -4.47956 -13.0181 -16.1817 -31.4903 -26.8202 18.1646 -0.04895 -5.10149 -3.19249 4.42238 12.033 -19.0984 -24.6875 -59.2013 -92.4452 -43.2519 -80.5076 -55.4201 -45.2283 -50.0695 -30.5813 -61.8331 -41.6405 -70.3938 -128.038 -146.115 -135.668 -80.9469 -70.8441 -97.0844 -107.008 -88.9458 -50.2074 -63.9405 -98.5591 -145.558 -131.769 -116.266 -109.296 -111.365 -106.031 -68.9028 -44.7975

B. Perancangan Partikel Positif

Partikel positif yang digunakan merupakan partikel yang diberi gaya

Coulomb sehingga partikel bermuatan positif. Partikel positif akan saling tolak

menolak dengan partikel positif lainnya, dan tarik menarik dengan medan negatif

citra. Alur dari perancangan gaya Coulomb sesuai dengan flowchart pada gambar

3.10.

39

Gambar 3.10. Flowchart Menghitung Gaya Coulomb

Flowchart pada Gambar 3.10 jika diimplementasikan dalam bentuk program

ditulis seperti berikut :

int s=0, sx[100], sy[100]; double CoulombX[100], CoulombY[100]; for (int i=0;i<s;i++){ CoulombX[i]=0; CoulombY[i]=0; for (int j=0;j<s;j++){ if (j != i){ if ((sx[i]-sx[j] != 0) && (sy[i]-sy[j] != 0)){ CoulombX[i] = CoulombX[i] + ((sx[i]-sx[j]) / pow(Absolut(sx[i] - sx[j]), 3)); CoulombY[i] = CoulombY[i] + ((sy[i]-sy[j]) / pow(Absolut(party[i] - party[j]), 3)); }else if (partx[i] - partx[j] == 0){ CoulombY[i] = CoulombY[i] + ((sy[i]-sy[j]) / pow(Absolut(party[i] - party[j]), 3)); }else if (party[i] - party[j] == 0){ CoulombX[i] = CoulombX[i] + ((sx[i]-sx[j]) / pow(Absolut(sx[i] - sx[j]), 3)); } } } }

End

CoulombForce = (Fcx , Fcy)

퐹 =푠 − 푠

푠 − 푠

퐹 =푠 − 푠

푠 − 푠

[sx , sy] = inisialisasi partikel (f)

Baca citra input f

Start

40

Kode program untuk proses inisialisasi diletakkan pada function terpisah,

ditulis sebagai berikut:

void showContent(IplImage * img){ cvCopyImage(img,temp); for (int i=0;i<=part;i++){ cvCircle(temp, cvPoint(sx[i],sy[i]), 2, CV_RGB(255,0,0)); } cvShowImage("CPM", temp);

} void on_mouse( int event, int x, int y, int flags, void* ptr){

if (event == CV_EVENT_LBUTTONDOWN){ sx[part] = x; sy[part] = y; printf("%i %i %i\n",part,sx[part],sy[part]); part++; showContent((IplImage *)ptr); }

}

Untuk mendapatkan nilai gaya Coulomb dimulai dengan input partikel

yang dilakukan dengan cara klik pada citra lokasi piksel yang diinginkan.

Koordinat piksel partikel disimpan pada variabel sx[s] untuk koordinat sumbu x

dan sy[s] untuk koordinat sumbu y, dengan s adalah indeks partikel. Setelah

proses inisialisasi, perhitungan dilakukan berdasarkan sumbu x dan y. Hasil dari

perhitungan sumbu x disimpan dalam variabel CoulombX, dan CoulombY untuk

menyimpan hasil dari perhitungan sumbu y.

C. Perancangan Perhitungan Pergerakan Partikel

Gaya total didapatkan dengan menjumlahkan gaya Lorentz dan gaya

Coulomb. Sesuai dengan rumus yang ada pada persamaan (2.10). Berdasarkan

penelitian yang dilakukan Jalba dkk, partikel yang bergerak memiliki energi

potensial sehingga disebut partikel dinamis, maka rumus untuk menghitung gaya

total menjadi Persamaan (3.3).

퐹(퓇 ) = 푤 퐹 (퓇 ) + 푤 퐹 (퓇 )− 훽휐 ............................................................. (3.3)

41

( ) = 푣 ( ) = −∇∅(푟)| = 퐹(푟 (푡))

.................................................................. (3.4)

Dimana ∅ adalah energi potensial partikel, 푟 adalah posisi, 푣 adalah

kecepatan, dan 푎 adalah percepatan. Bila dibandingkan dengan Persamaan (2.3),

Persamaan (3.3) memiliki tambahan, 퐹 (푟 ) = −훽푣 , yaitu pengurangan

energi yang diperlukan partikel agar mencapai keadaan setimbang, digunakan

untuk mengurangi energi potensial (Jalba dkk, 2004). Persamaan (3.3) dan (3.4)

di atas belum bisa untuk disubstitusi dikarenakan 퐹(푟 (푡)) belum diketahui,

namun masih bisa untuk mencari turunan pertamanya, yang artinya bisa

menggunakan deret Taylor agar persamaan tersebut bisa digunakan.

Untuk memudahkan, tiap partikel menggunakan interval waktu yang

sama yaitu ∆푡. Oleh karena itu, pada setiap interval waktu 푡 = 푡 + ∆푡 gaya

yang bekerja pada tiap partikel 푝 dihitung sesuai dengan persamaan (3.3) untuk

mendapatkan percepatan partikel 푝 . Kemudian untuk mendapatkan kecepatan,

percepatan, dan posisi dalam tiap interval waktu bisa menggunakan metode Euler.

Metode ini dapat mengakibatkan error yang terakumulasi tiap interval waktu.

Oleh karena itu, dikembangkan metode alternatif yang efisien yang

didasarkan pada deret Taylor yang memanfaatkan nilai-nilai yang dihitung

sebelumnya untuk mendapatkan percepatan dan kecepatan (yaitu metode

bertingkat). Untuk mencari kecepatan, percepatan, dan posisi dalam satu interval

waktu menggunakan persamaan seperti berikut:

푟(푡 + ∆푡) = 푟(푡) + ∆푡 푣(푡) + ∆푡 푎(푡) + ∆푡 ( ) ................................... (3.5)

푣(푡 + ∆푡) = 푣(푡) + ∆푡 푎(푡) + ∆푡 ( ) ...................................................... (3.6)

42

Karena implementasi persamaan 푑푎(푡)/푑푡 pada komputasi susah

dilakukan, dapat digunakan (kuadrat) Lagrange polynomial 퐿(푡), dalam satuan

waktu {푡 , 푡 − ∆푡, 푡 − 2∆푡} (Jalba dkk, 2004). Mengambil turunan dari

polynomial, dan mensubstitusi 푡 = 푡 , maka didapat persamaan sebagai berikut.

( ) = ( ) =∆

(3푎(푡 )− 4푎(푡 − ∆푡) + 푎(푡 − 2∆푡)) ................ (3.7)

Berdasarkan Persamaan (3.3) sampai (3.7) diatas maka bila diasumsikan

massa dari partikel positif adalah 1 maka implementasi dalam program adalah

sebagai berikut :

percx[i][ite] = (w1 * CoulombX[i]) + (w2 * lorentx) - (beta * kecx[i][ite-1]); percy[i][ite] = (w1 * CoulombY[i]) + (w2 * lorenty) - (beta * kecy[i][ite-1]); kecx[i][ite] = kecx[i][ite-1] + (deltat * percx[i][ite-1]) + (0.5 * deltat * deltat * (((3 * percx[i][ite-1]) - (4 * percx[i][ite-2]) + percx[i][ite-3]) / (2 * deltat))); kecy[i][ite] = kecy[i][ite-1] + (deltat * percy[i][ite-1]) + (0.5 * deltat * deltat * (((3 * percy[i][ite-1]) - (4 * percy[i][ite-2]) + percy[i][ite-3]) / (2 * deltat))); posx[i][ite] = posx[i][ite-1] + (deltat * kecx[i][ite-1]) + (0.5 * deltat * deltat * percx[i][ite-1]) + (0.167 * deltat * deltat * deltat * (((3 * percx[i][ite-1]) - (4 * percx[i][ite-2]) + percx[i][ite-3]))); posy[i][ite] = posy[i][ite-1] + (deltat * kecy[i][ite-1]) + (0.5 * deltat * deltat * percy[i][ite-1]) + (0.167 * deltat * deltat * deltat * (((3 * percy[i][ite-1]) - (4 * percy[i][ite-2]) + percy[i][ite-3])));