Anda di halaman 1dari 8

Pencocokan Tanda Tangan dengan Metode Wavelet

Rizky Izatul L.R. (10650028) Laeli Nurmasari (10650029) Ahmad Wahyu Rosyadi (10650031) Jurusan Teknik Informatika Fakultas Sains dan Teknologi Universitas Islam Negeri Maulana Malik Ibrahim Malang Jln. Gajayana No. 50 Malang E-mail: wahyu_rosyad@yahoo.co.id
masing masing komponen tersebut dapat keakuratan hasil dianalisis menurut level dekomposisinya. Proses dekomposisi akan mereduksi

Batasan masalah Untuk meningkatkan

diusahakan gambar yang diinput hasil scanner. Gambar berukuran 96x96 pixel. 1. Proses Input: image 96x96 pixel Proses: Memasukkan gambar Merubah gambar menjadi matriks dan

ukuran citra menjadi setengah dari ukuran awalnya. Pada transformasi wavelet, sebuah gambar didekomposisi menjadi subgambar pada frekuensi dan orientasi yang berbeda, yaitu lowlow (LL), low-high (LH), high-low (HL), dan high-high (HH). Seperti gambar 1.

mengatur warna yang dibutuhkan untuk aplikasi ini Matriks gambar akan diproses dengan dua macam proses, yaitu proses dekomposisi untuk mengetahui energi pada wavelet dan proses pelebaran matriks Setelah mengetahui energi pada wavelet dari gambar yang dianalisa maka akan dilakukan proses perhitungan jarak euclidean Menentukan tingkat kemiripan berdasarkan jarak euclidean dan pelebaran matriks Menghasilkan jumlah energi pada wavelet, jarak euclidean, tingkat kemiripan berdasarkan pelebaran matriks, keterangan cocok atau tidak, dan prosentase kecocokan. Proses perhitungan wavelet dapat

dilakukan dengan menggunakan bank filter yang merupakan kumpulan koefisien untuk memperoleh nilai rata rata dan nilai selisih secara berulang ulang. Bank filter tersebut berisi h0=h1=1/ sebagai koefisien low-pass yang

menghasilkan citra pendekatan, dan g0=1/ , g1=-1/ sebagai koefisien high-pass yang

2. Metode 2.1 Wavelet Wavelet adalah teknik matematika untuk fungsi mampu dekomposisi. menganalisis suatu Transformasi suatu sinyal data ke wavelet dengan dalam

menghasilkan citra detail.

mendekomposisi

frekuensi yang berbeda beda dan kemudian

Yang

kemudian

Stephane

Mallat

menunjuk pada citra tertentu. Jarak Euclidean dinyatakan oleh: ( ) ( )

memperkenalkan cara mudah untuk menghitung dekomposisi wavelet dengan algoritma piramida Mallat. Mallat memberi nilai koefisien low-pass ho=h1=1/2 dan koefisien high-pass g0=1/2, g1=1/2.

Dengan: D(A,B) = Jarak Euclidean antara iris A dan B

2.2 Pengukuran Energi pada Wavelet Perhitungan energi berfungsi untuk n

= Vektor ciri iris A = Vektor ciri iris B = Panjang vektor (Jumlah ciri tekstural) vektor A dan vektor B

menghitung energi yang dihasilkan oleh setiap citra hasil dekomposisi wavelet. Energi dibagi dalam 4 (empat) ciri, yaitu: a. Prosentase energi yang berhubungan dengan nilai pendekatan (aproksimasi), Ea dihitung berdasarkan prosentase jumlahan kuadrat dari nilai koefisien aproksimasi Ca dibagi C

2.4 Algoritma Pelebaran Matriks Merupakan algoritma yang digunakan untuk memperlebar atau memperbanyak data yang bukan nol dalam matriks. Yaitu jika dalam matriks terdapat suatu data yang bukan angka nol, seperti angka 1 maka sebelah kanan dan kiri angka tersebut akan diperlebar dengan mengganti angka nol dengan angka yang diinginkan. Algoritma ini digunakan untuk menambah

dengan jumlahan seluruh koefisien

(koefisien aproksimasi ditambah koefisien detail).

b.

Prosentase energi yang berhubungan dengan nilai detail pada arah horizontal.

tingkat keakuratan dalam pencocokan tanda tangan.

3. Penerapan metode dalam program

Mengatur warna
c. Prosentase energi yang berhubungan dengan nilai detail pada arah vertikal.
public int[][] setrgb(File file) throws IOException { BufferedImage img= ImageIO.read(file); int height = img.getHeight(); int width = img.getWidth();

d.

Prosentase energi yang berhubungan dengan nilai detail pada arah diagonal.

int rgb[][] = new int[height][width]; for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { int value = img.getRGB(j, i); int r = (value & 0x00ff0000) >> 16; int g = (value & 0x0000ff00) >> 8; int b = value & 0x000000ff; int gray = (r + g + b) / 3; rgb[i][j] = gray; }} return rgb; }

2.3 Jarak Euclidean Merupakan jarak terdekat nilai vektor ciri citra. Proses perhitungannya dengan

menggunakan nilai-nilai parameter tertentu hasil dari ekstraksi citra sebelumnya. Nilai jarak Euclidean yang mendekati nilai nol, akan

Mengatur

masukan

data

untuk

//---------------------------for (int f=0;f<a.length; f++){ for(int g=0;g< matfildek_LH[0].length; g++){ detail_d3[0][g] = c[0][g]; detail_d3[1][g] = c[2][g]; detail_d3[2][g] = c[4][g]; //diketik sampai detail_d3[93][g] = c[91][g]; detail_d3[94][g] = c[93][g]; detail_d3[95][g] = c[95][g]; System.out.print(detail_d3[f][g]+"\t") ;}System.out.println();}

algoritma pelebaran matriks


pro.isiArray(tinggi, lebar); for (int i = 0; i < tinggi; i++) { for (int j = 0; j < lebar; j++) { if (maks < rgb[i][j]) { maks = rgb[i][j]; } if (min > rgb[i][j]) { min = rgb[i][j];}}} int tem = (maks - min) / 2; teng = min + tem; for (int i = 0; i < tinggi; i++) { for (int j = 0; j < lebar; j++) { if (rgb[i][j] > teng && rgb[i][j] <= maks) { pro.b[i][j] = 0;} else {pro.b[i][j] = 7;}}} for(int i= 0; i < pro.b.length; i++) { for (int j = 0; j < pro.b[0].length; j++){ if (j == (pro.b[0].length - 1) || j == (pro.b[0].length 2) && pro.b[i][j] == 1) {pro.b[i][j] = 0;}}}

//---------------------------perkalian dengan detail //---------------------------for(int i=0;i<c.length;i++){ for(int j=0;j<c[0].length;j++){ c[i][j]=0;}} for(int i =0; i < matfildek_LH.length; i++){ fo(int j=0; j< matfildek_LH[0].length; j++){ for(int k= 0; k < matfildek_LH.length; k++){ c[i][j] = c[i][j]+(matfildek_LH[k][i] * detail_d3[j][k]);}}}

dari

matriks matriks

filter apro

LH dan

hasil

Metode

wavelet

(dekomposisi)

dan jarak Euclidean


void wavel() { setfilterDe(a.length, a[0].length); //untuk perkalian setiap kolom dengan matriks filter LH for(int i=0;i<c.length;i++){ for(int j=0;j<c[0].length;j++){ c[i][j]=0; }} //kali pertama for(int i =0; i < matfildek_LH.length; i++){ for(int j=0;j< matfildek_LH[0].length; j++){ for(int k= 0; k < matfildek_LH.length; k++){ c[i][j]= c[i][j]+(matfildek_LH[i][k] * a[k][j]);}}}

//---------------------------Ditranspose //---------------------------for(int i= 0; i < matfildek_LH.length; i++){ for (int j=0; j < detail_d3[0].length; j++){matapro[i][j] = c[j][i]; }}

//---------------------------aproksimasi dikumpulkan dikiri dan detail dikanan //---------------------------for(int f++){ for(int g=0;g< matfildek_LH[0].length; g++){ detail_d5[f][0] = matapro[f][0]; f=0; f<matfildek_LH.length;

//---------------------------aproksimasi dikumpulkan diatas dan detail dikumpulkan dibawah

detail_d5[f][1] = matapro[f][2]; //diketik sampai detail_d5[f][95] = matapro[f][95];

} if (i == matbagapro5.length - 1) { an3 = matbagapro5[2][0]; anv3 = matbagver5[2][0]; anh3 = matbaghor5[2][0]; and3 = matbagdia5[2][0]; } if (i == matbagapro5.length - 1 && j == matbagapro5[0].length - 1) { an4 = matbagapro5[0][2]; anv4 = matbagver5[0][2]; anh4 = matbaghor5[0][2]; and4 = matbagdia5[0][2];} } } + + //kuadrat koefisien double jiv =anv1+anv2+anv3+anv4; double jih =anh1+anh2+anh3+anh4; double jid =and1+and2+and3+and4; double jia =an1+an2+an3+an4; double jml_energi_a=Math.pow(jiv, 2); double jml_energi_v=Math.pow(jih, 2); double jml_energi_h=Math.pow(jid, 2); double jml_energi_d=Math.pow(jia, 2); //kuadrat koefisien semua double total_energi=Math.pow((jiv + jih + jid + jia), 2); //menentukan jumlah energi double double double double ina inv inh ind = = = = (jml_energi_a (jml_energi_v (jml_energi_h (jml_energi_d / / / / total_energi) * 100;

//---------------------------Membagi bagian kedalam apro, hor, ver, diagonal //---------------------------for (int i = 0; i < detail_d5.length; i++){ for (int j=0; j < detail_d5[0].length; j++){ if (i < detail_d5.length/2 & j < detail_d5[0].length/2) { matbagapro[i][j] = detail_d5[i][j]; matbaghor[i][j] matbagver[i][j] = = detail_d5[i][j detail_d5[i detail_d5.length/2]; detail_d5.length/2][j]; matbagdia[i][j]=detail_d5[i+detail_d5. length/2][j+detail_d5.length/2];}}}

Setelah

itu

kita

akan

mendapatkan

matriks

aproksimasi, detail horizontal, detail vertikal, detail diagonal. Catatan: karena aplikasi ini menggunakan

dekomposisi level 5 maka proses di atas diulang sebanyak 4 kali lagi. Perhitungan energi wavelet Dalam program ini untuk menentukan energi kami memakai 4 koefisien dari masing masing matrik hasil dekomposisi level 5.
for(int i=0;i<matbagapro5.length;i++){ for(int j++){ an1 = matbagapro5[0][0]; anv1 = matbagver5[0][0]; anh1 = matbaghor5[0][0]; and1 = matbagdia5[0][0]; if (j == matbagapro5[0].length - 1) { an2 = matbagapro5[2][2]; anv2 = matbagver5[2][2]; anh2 = matbaghor5[2][2]; and2 = matbagdia5[2][2]; j=0;j<matbagapro5[0].length;

total_energi) * 100; total_energi) * 100; total_energi) * 100; //mengisi data energi if (total_appro == 0 && total_ver == 0 && total_hor == 0 && total_diag == 0) { this.total_appro = ina; this.total_ver = inv; this.total_hor = inh; this.total_diag = ind; } else { this.total_appro2 = ina; this.total_ver2 = inv; this.total_hor2 = inh; this.total_diag2 = ind;

} //menentukan jarak euclidean void jarakEu(){ double hhh = 0; double ap = Math.pow((getTotal_appro() - getTotal_appro2()), 2); double a2 = ap / getTotal_appro(); double v = Math.pow((getTotal_ver() getTotal_ver2()), 2); double v2 = v / getTotal_ver(); double h = Math.pow((getTotal_hor() getTotal_hor2()), 2); double h2 = h / getTotal_hor(); double d = Math.pow((getTotal_diag() getTotal_diag2()), 2); double d2 = d / getTotal_diag(); this.jar_e = Math.sqrt(a2 + v2 + h2 + d2); }

Kami memberi nilai 3 untuk indeks-1 dan indeks+1 dari indeks angka 1, dan angka 5 untuk indeks-2 dan indeks+2 dari angka 1.
void prosesM2(){ for(int i =0; i < pro.a.length; i++) { for(int j = 0; j < pro.a[0].length; j++){ if 1) { pro.a[i][j] = 3;} if 1){ pro.a[i][j] = 5;} if (j < pro.a.length && pro.a[i][j] == 1 && pro.a[i][j + 1] == 0) { pro.a[i][j + 1] = 3;} if (j < pro.a.length 1 && pro.a[i][j] == 3 && pro.a[i][j + 1] == (j < pro.a.length 3 && pro.a[i][j] == 0 && pro.a[i][j + 2] == (j < pro.a.length 2 && pro.a[i][j] == 0 && pro.a[i][j + 1] ==

Algoritma Pelebaran Matriks Untuk gambar 1: Kami memberi nilai 9 untuk indeks-1 dan indeks+1 dari indeks angka 7, dan angka 11 untuk indeks-2 dan indeks+2 dari angka 7.
void prosesM1() { for(int i = 0; i < pro.b.length; i++) { for(int j=0;j<pro.b[0].length;j++){ if(j<pro.b.length-2&&pro.b[i][j]==0&& pro.b[i][j + 1] == 7) { pro.b[i][j] = 9; } if(j<pro.b.length-3&&pro.b[i][j]==0&& pro.b[i][j + 2] == 7){ pro.b[i][j] = 11; } if (j < pro.b.length && pro.b[i][j] == 7 && pro.b[i][j + 1] == 0) { pro.b[i][j + 1] = 9; } if(j<pro.b.length-1&&pro.b[i][j]==9&& pro.b[i][j + 1] == 0){ pro.b[i][j + 1] = 11; }}}}

0) { pro.a[i][j + 1] = 5;}

//---------------------------Pencarian kecocokan berdasarkan algoritma pelebaran matriks //---------------------------void cariCocok(){ for (int i = 0; i < a.length; i++) { for (int j = 0; j < a[0].length; j++) { c[i][j] = b[i][j] - a[i][j]; }} for (int i = 0; i < c.length; i++) { for (int j = 0; j < c[0].length; j++) {if (c[i][j] == 7 || c[i][j] == -1) { double baru = 1; this.beda += baru; } if (c[i][j] == 2 || c[i][j] == 4 || c[i][j] == 6 || c[i][j] == 8 || c[i][j] == 10) { double baru = 1; this.sama += baru; } if (b[i][j] == 5 || b[i][j] == 7) {

Untuk gambar 2:

double baru = 1; this.total_item += baru; }}} this.total = sama + beda; rata = ((sama) / (sama + beda)) * 100; }

double persenMe2 = (persenMe / 100) * 80; double persen3 = (persen2 / 100) * 20; akhir = persen3 + persenMe2; tf_persen_ahir.setText(String.valueOf( akhir)); } else if ((hasil >= 0.158) && (persenMe <= 50)) { akhir = 0; tf_persen_ahir.setText(String.valueOf( 0)); } if (akhir > 50) { tf_keterangan.setText("Cocok"); } else { tf_keterangan.setText("Tidak Cocok"); }

Untuk mencari kecocokan berdasarkan

matriks

hasil dari pelebaran matriks kami menggunakan rumus:

Dengan sama diperoleh jika dalam matriks hasil penjumlahan antara matriks gambar 1 dan gambar 2 terdapat nilai 2, 4, 6, 8,atau 10. Dan beda diperoleh jika terdapat angka 7 atau -1.

Pencarian kecocokan akhir


double hasil = inti.getJar_e(); double persen = 0; if (hasil <= 1) { persen = hasil * 100; } else { persen = 100; } double persen2 = 100 - persen; double persenMe = pro.getRata(); double akhir = 0; if ((hasil <= 0.158) && (persenMe > 50)) { double persenMe2 = (persenMe / 100) * 50; double persen3 = (persen2 / 100) * 50; akhir = persen3 + persenMe2; tf_persen_ahir.setText(String.valueOf( persen2)); } else if ((hasil >= 0.158) && (persenMe > 50)) { double persenMe2 = (persenMe / 100) * 80; double persen3 = (persen2 / 100) * 20; akhir = persen3 + persenMe2; tf_persen_ahir.setText(String.valueOf( akhir)); } else if ((hasil <= 0.158) && (persenMe <= 50)) {

Untuk menentukan nilai akhir kecocokan tanda tangan kami menggabungkan hasil dari perhitungan jarak euclidean dan penjumlahan matriks tadi. Dan kemudian kami buat kondisi bila: 1. Hasil a(jarak euclidean) lebih kecil sama dengan 0.158 dan hasil b(penjumlahan matriks) lebih besar dari 50 maka hasil akhir didapat dari 50% dari a dan 50% dari b. 2. Hasil a(jarak euclidean) lebih besar sama dengan 0.158 dan hasil b(penjumlahan matriks) lebih besar dari 50 maka hasil akhir didapat dari 20% dari a dan 80% dari b. 3. Hasil a(jarak euclidean) lebih kecil sama dengan 0.158 dan hasil b(penjumlahan matriks) lebih kecil sama dengan 50 maka hasil akhir didapat dari 20% dari a dan 80% dari b. 4. Hasil a(jarak euclidean) lebih besar sama dengan 0.158 dan hasil b(penjumlahan matriks) lebih kecil sama dengan 50 maka hasil akhir 0.

Dan setelah itu diberi kondisi jika diatas 50 maka cocok dan jika dibawah 50 tidak cocok.

4. Percobaan Aplikasi Langkah 1: Input gambar 1

Contoh:

Gambar 3 Langkah 2: Input gambar 2 Hasil:

Gambar 4

Langkah 3: Menentukan kecocokan dan hasil akhir

Gambar 5

Contoh:

Daftar Pustaka http://eprints.undip.ac.id/25390/1/ML2F001605.pdf http://www.scribd.com/doc/96716187/TugasPengenalan-Pola-Citra-Tekstur-dengan-MetodeJarak-Euclidean http://eprints.undip.ac.id/35707/1/L2F607010_MT A.pdf

Hasil:

Seperti contoh di atas bahwa jika total lebih besar dari 50 maka tanda tangan dinyatakan cocok.