IMPLEMENTASI ALGORITMA AFFINE SCALE...

IMPLEMENTASI ALGORITMA AFFINE SCALE

INVARIANT FEATURE TRANSFORM UNTUK

PENGENALAN WAJAH PADA CITRA SKETSA

SKRIPSI

Disusun Oleh :

Mukhlis

NIM : 108091000062

PROGRAM SARJANA (S1) KOMPUTER

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS SAINS DAN TEKNOLOGI

UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH

JAKARTA

2015

i

IMPLEMENTASI ALGORITMA AFFINE SCALE

INVARIANT FEATURE TRANSFORM UNTUK

PENGENALAN WAJAH PADA CITRA SKETSA

SKRIPSI

Diajukan sebagai salah satu syarat untuk memperoleh gelar Sarjana Komputer

Pada Program Studi Teknik Informatika Fakultas Sains dan Teknologi

Universitas Islam Negeri Syarif Hidayatullah Jakarta

Disusun Oleh :

Mukhlis

NIM : 108091000062

PROGRAM SARJANA (S1) KOMPUTER

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS SAINS DAN TEKNOLOGI

UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH

JAKARTA

2015

iv

PERNYATAAN

DENGAN INI SAYA MENYATAKAN BAHWA SKRIPSI INI BENAR-BENAR

HASIL KARYA SENDIRI YANG BELUM PERNAH DIAJUKAN SEBAGAI SKRIPSI

ATAU KARYA ILMIAH PADA PERGURUAN TINGGI ATAU LEMBAGA

MANAPUN.

Jakarta, Juni 2015

Mukhlis

v

Nama : Mukhlis

Program Studi : Teknik Informatika

Judul : Implementasi Algoritma Affine Scale Invarirant Feature

Transform Untuk Pengenalan Wajah Pada Citra Sketsa

ABSTRAK

Skripsi ini membahas penggunaan algoritma Affine Scale Invariant Feature

Transform dalam mengekstraksi ciri khusus (feature) yang terdapat dalam citra

sketsa dan foto. Dari ciri feature tersebut akan dicari kecocokkan antara citra

sketsa dan foto. Sehingga foto hasil identifikasi dapat memiliki wajah yang sama

atau setidaknya mirip dengan wajah pada citra sketsa. Hasil dari penelitian ini

menunjukkan bahwa metode Affine Scale Invariant Feature Transform dapat

mengidentifikasi feature dengan baik, ini terlihat dari banyaknya feature yang

dihasilkan. Hasil pencocokkan dari sample yang digunakan menunjukkan bahwa

metode Affine Scale Invariant Feature Transform dapat digunakan untuk

mengidentifikasi wajah pada citra sketsa.

Kata Kunci : Pengolahan Citra, Pengenalan Wajah, Citra Sketsa, Scale Invariant,

ASIFT

vi

KATA PENGANTAR

Puji dan syukur kehadirat Allah SWT atas segala karunia, rahmat dan

kekuatan, juga segala petunjuk dan kemudahan sehingga penulis dapat

menyelesaikan penulisan skripsi ini. Shalawat serta salam selalu kita haturkan

kepada junjungan kita Nabi besar Muhammad SAW beserta keluarganya, para

sahabatnya, dan para pengikutnya.

Skripsi ini berjudul ”Implementasi Algoritma Affine Scale Invariant

Feature Transform Untuk Pengenalan Wajah Pada Citra Sketsa”, yang

disusun untuk memenuhi salah satu syarat dalam menyelesaikan program S1 pada

Program Studi Teknik Informatika di Universitas Islam Negeri Syarif

Hidayatullah Jakarta.

Pada kesempatan yang berbahagia ini, penulis mengucapkan terima kasih

kepada:

1. Ibu A. Hanifa Setianingrum, M.Si. selaku Pembimbing I dan Bapak Victor

Amrizal, M.Kom selaku Pembimbing II, yang senantiasa meluangkan waktu

ditengah-tengah berbagai kesibukan dan aktifitasnya untuk membimbing

penulis dalam menyelesaikan skripsi ini.

2. Ibu Arini, ST., MT. selaku Ketua Program Studi Teknik Informatika, Bapak

Feri Fahrianto, M.Sc. selaku Sekretaris Program Studi Teknik Informatika,

dan Bapak Dr. Agus Salim, M.Si., selaku Dekan Fakultas Sains dan

Teknologi, Universitas Islam Negeri Syarif Hidayatullah Jakarta.

vii

3. Pimpinan Perpustakaan Utama dan Perpustakaan Fakultas Sains dan

Teknologi yang telah memberikan fasilitas untuk mengadakan studi

kepustakaan.

4. Kepada semua dosen Program Studi Teknik Informatika yang telah

membimbing penulis untuk menambah wawasan mengenai pengetahuan di

bidang teknik informatika.

5. Umi dan Abi yang selalu memberikan dukungan kepada penulis berupa moril,

materil, semangat, kasih sayang, dan doa yang tiada hentinya.

6. Sanak Famili yang turut memberikan motivasinya kepada penulis.

7. Teman-teman TI B 2008, TI Software Engineering 2008, dan TI UIN 2008

yang telah berjuang bersama dalam menempuh pendidikan di Prodi Teknik

Infomatika, Universitas Islam Negeri Syarif Hidayatullah Jakarta.

8. Akhirnya, penulis berharap semoga skripsi ini dapat bermanfaat. Saran dan

kritik untuk kesempurnaan skripsi ini dapat disampaikan melalui email

[email protected].

Jakarta, 20 Mei 2015

Mukhlis

10809100006

viii

DAFTAR ISI

HALAMAN JUDUL ...................................................................................... i

LEMBAR PENGESAHAN SKRIPSI .......................................................... ii

LEMBAR PENGESAHAN UJIAN .............................................................. iii

LEMBAR PERNYATAAN ........................................................................... iv

ABSTRAK ...................................................................................................... v

KATA PENGANTAR .................................................................................... vi

DAFTAR ISI ................................................................................................... viii

DAFTAR GAMBAR ...................................................................................... xi

DAFTAR TABEL .......................................................................................... xiii

BAB I PENDAHULUAN ............................................................................... 1

1.1. Latar Belakang ................................................................................. 1

1.2. Rumusan Permasalahan ................................................................... 2

1.3. Batasan Masalah .............................................................................. 2

1.4. Tujuan Penelitian ............................................................................. 3

1.5. Manfaat Penelitian ........................................................................... 3

1.6. Sistematika Peneliatian .................................................................... 4

BAB II LANDASAN TEORI ........................................................................ 5

2.1. Pengolahan Citra Digital ...................................................................... 5

2.2. Scale Infariant Feature Transform(SIFT) ........................................... 6

2.1.1. Pencarian Nilai Ekstrema pada Skala Ruang .................................. 7

ix

2.1.2. Penentuan Keypoint ......................................................................... 9

2.1.3. Penentuan Orientasi ......................................................................... 11

2.1.4. Deskriptor Keypoint ......................................................................... 12

2.3. Affine Transformation .......................................................................... 13

2.4. Affine Scale Invariant Feature Transform ........................................... 14

2.3.1. Algoritma ASIFT ............................................................................. 16

2.5. Matlab .................................................................................................. 17

2.6. Metode Prototyping ............................................................................. 19

2.7. Falase Acceptance Rate(FAR), False Rejection Rate(FRR) dan

Equal Erorr Rate(EER) ........................................................................ 23

BAB III METODOLOGI PENELITIAN .................................................... 24

3.1. Metode Pengumpulan Data .................................................................. 24

3.1.1. Studi Pustaka ................................................................................... 24

3.1.2. Penelitian Sejenis ............................................................................. 25

3.2. Metode Pengembangan Prototipe ........................................................ 26

3.2.1 Pengumpulan Kebutuhan ................................................................. 27

3.2.1.1 Analisa Sistem ................................................................................ 27

3.2.1.2 Identifikasi Masalah ....................................................................... 27

3.2.1.3 Usulan Penyelesaian Masalah ........................................................ 27

3.2.1.4 Kebutuhan Perangkat Lunak dan Perangkat Keras ......................... 27

3.2.2 Membangun Prototype .................................................................... 28

3.2.2.1. Desain Image Processing ......................................................... 28

3.2.2.2. Desain Interface........................................................................ 29

x

3.2.3 Mengkodekan System ..................................................................... 29

3.2.4 Pengujian aplikasi ............................................................................ 29

3.3. Kerangka Berfikir................................................................................. 30

BAB IV PEMBAHASAN DAN HASIL ....................................................... 31

4.1. Pengumpulan Kebutuhan ..................................................................... 31

4.1.1. Analisa Sistem ................................................................................. 31

4.1.2. Identifikasi Masalah ........................................................................ 32

4.1.3. Usulan Penyelesaian Masalah ......................................................... 32

4.1.4. Kebutuhan perangkat Lunak dan Perangkat Keras.......................... 32

4.2. Membangun Prototype ......................................................................... 33

4.2.1. Desain Image Processing ................................................................ 33

4.2.2. Desain Interface ............................................................................... 42

4.3. Mengkodekan Sistem ........................................................................... 44

4.4. Pengujian Prototipe .............................................................................. 62

BAB V PENUTUP .......................................................................................... 67

5.1. Kesimpulan ........................................................................................... 67

5.2. Saran ..................................................................................................... 67

DAFTAR PUSTAKA .....................................................................................

LAMPIRAN ....................................................................................................

xi

DAFTAR GAMBAR

Gambar 2.1 Diagram Difference-of-Gaussian ................................................. 8

Gambar 2.2 Ilustrasi pencarian maksimum atau minimum lokal dari citra

DoG .................................................................................................................. 9

Gambar 2.3 Deskriptor dari perhitungan besar gradien dan orientasi serta

gambar lingkaran Gaussian (kiri) dan gambar deskriptor keypoint (kanan) .... 12

Gambar 2.4 Keypoint yang diperoleh dari suatu citra menggunakan SIFT ..... 13

Gambar 2.5. Model kamera proyektif u = S1G1Au0. A adalah mengubah

sebuah proyektif planar (Homography). G1 adalah anti-aliasing Gaussian

filtering. S1 adalah sampling CCD .................................................................. 14

Gambar 3.1.1 Alur Kerangka Berpikir ............................................................. 30

Gambar 4.1 Contoh citra hasil pengkaburan(blurring) 1S.jpg dengan

ukuran 828x1164, 414x582, 207x291,103x145 ............................................... 35

Gambar 4.2 Contoh citra hasil pengkaburan(blurring) 1F.jpg dengan

ukuran 2048x1536, 1024x768, 512x384, 256x192 .......................................... 36

Gambar 4.3 Contoh citra blurring menjadi citra DoG ..................................... 37

Gambar 4.4 Contoh Mencari Ekstrema dalam citra DoG ................................ 38

Gambar 4.5 Contoh Histogram Orientasi......................................................... 39

Gambar 4.6 Contoh pemberian finger print pada keypoint .............................. 40

Gambar 4.7 Memasukkan orientasi pada hitogram lingkaran ......................... 40

Gambar 4.8 gradient orientasi yang mengalami pembobotan gaussian ........... 41

Gambar 4.9 Gambar Interface Halaman Utama .............................................. 43

xii

Gambar 4.9 Desain Interface Halaman Utama ................................................ 43

Gambar 4.10 Desain Interface Inisialisasi ....................................................... 43

Gambar 4.11 DesainInterface Identifikasi Sketsa ............................................ 44

xiii

DAFTAR TABEL

Tabel 3.1. Tabel Perbandingan Studi Literatur Sejenis.................................... 25

Tabel 4.1. Tabel Spesifikasi Kebutuhan Perangkat Keras ............................... 32

Tabel 4.2. Perangkat Lunak Yang Digunakan ................................................. 33

Tabel 4.3 Hasil Matching Keypoint ................................................................. 42

Tabel 4.4 Jumlah Keypoint Citra Sketsa .......................................................... 62

Tabel 4.5 Jumlah Keypoint Citra Foto ............................................................. 64

Tabel 4.6 Hasil Pengujian FER dan FRR ........................................................ 65

Tabel 4.7 Jumlah Match Keypoint Citra Sketsa dan Foto ................................ 66

1

BAB I

PENDAHULUAN

1.1. Latar Belakang

Dewasa ini banyak terjadi kejahatan, yang terkadang pelaku kriminal tidak

dapat ditangkap setelah kejadian terjadi. Polisi dapat mengidentifikasi pelaku

kejahatan dari keterangan saksi atau dari kamera pengawas. Wajah pelaku

kejahatan dapat dibuat sketsa wajahnya berdasarkan dari informasi tersebut.

Sketsa wajah tersebut dianalisa sehingga didapatkan foto wajah dari pelaku

kejahatan tersebut. Untuk mempermudah dalam menganalisa sketsa wajah

dibutuhkan sistem yang dapat mengidentifikasi sketsa sehingga didapatkan foto

wajah yang cocok.

Citra sketsa dan citra foto memiliki dua perbedaan yang terletak pada

tekstur dan bentuknya. Perbedaan tekstur antara citra sketsa dan citra foto terjadi

karena pembuatan citra sketsa secara manual yang biasanya menggunakan pensil

atau pulpen. Sedangkan perbedaan bentuk terjadi karena bentuk dari citra sketsa

yang dibuat merupakan penggambaran dari informasi deskriptif mengenai wajah

pelaku. Ada beberapa metode yang dapat digunakan untuk mengatasi masalah ini

salah satunya adalah menggunakan metode Scale Invariant Feature

Ttransform(SIFT).

Dalam tugas akhir yang dibuat oleh saudara Yuwono dari Universitas

Kristen Maranatha, beliau menggunakan metode SIFT untuk menngenali wajah

2

dari citra input berupa sketsa. Dalam penelitiannya beliau mengungkapkan bahwa

metode SIFT dapat digunakan untuk mendeteksi wajah pada citra sketsa.

Penulis menemukan modifikasi dari metode SIFT yang bernama metode

Affine Scale Invariant Feature Transform (ASIFT). Metode ASIFT ini

menambahkan factor sudut pandang yang mendefinisikan orientasi axis dari

kamera. Metode ini dapat mengidentifikasi fiture yang telah mengalami distorsi

affine yang besar dengan mengukurnya menggunakan parameter baru yaitu

transisi kemiringan. Metode ini diklaim lebih baik dalam proses ekstraksi fiture.

Oleh karena itu penulis ingin membuat protype aplikasi untuk menguji apa

metode ASIFT dapat menganalisa wajah pada citra sketsa.

1.2. Rumusan Permasalahan

Masalah yang akan dibahas pada penelitian ini adalah sebagai berikut:

1. Bagaimana cara identifikasi pengenalan ciri sketsa wajah dan foto

wajah?

2. Bagaimana Hasil Identifikasi dan pencocokan sketsa wajah dan

foto wajah menggunakan ASIFT?

1.3. Batasan Masalah

Dalam Tugas Akhir ini, terdapat batasan-batasan masalah yang dibahas

sebagai berikut :

1. Input Sketsa wajah menggunakan tipe Viewed Sketch

2. Dalam proses pencocokan wajah, hanya digunakan foto dan sketsa

yang memiliki pose wajah menghadap ke depan (frontal view),

3

tingkat pencahayaan normal, dan tidak menggunakan aksesoris

apapun.

3. Menggunakan lima pasang citra dan sketsa wajah, karena running

time proccess analisa pengenalan wajah maka penulis hanya

menggunakan lima pasang sample citra.

4. Format file citra yang digunakan adalah .jpg

5. Pengenalan wajah ini dilakukan dalam simulasi dengan

menggunakan MATLAB

6. Sketsa wajah dan foto wajah dimasukkan menggunakan scanner ke

dalam komputer.

1.4. Tujuan Penelitian

1. Melakukan identifikasi sketsa wajah dan foto wajah menggunakan

metode ASIFT.

2. Melakukan pencocokkan antara sketsa wajah dan foto wajah.

1.5. Manfaat Penelitian

1. Menambah pengetahuan penulis, terutama mengenai proses

pengenalan wajah.

2. Dapat menjadi refrensi untuk membuat aplikasi pengenalan wajah

dari citra masukan berupa sketsa.

4

1.6. Sistematika Penelitian

Penyusunan laporan tugas akhir terdiri dari lima bab sebagai berikut :

Bab I. Pendahuluan

Pada bab ini akan dibahas mengenai latar belakang, perumusan masalah,

identifikasi masalah, tujuan, pembatasan masalah, dan sistematika

penulisan dari tugas akhir ini.

Bab II. Landasan Teori

Pada bab ini akan dibahas mengenai teori-teori penunjang yang akan

digunakan untuk merancang protipe aplikasi pengenalan wajah

menggunakan metode Affine Scale Invariant Feature Transform dengan

citra masukan berupa citra sketsa wajah.

Bab III. Metodologi Penelitian

Pada bab ini akan dibahas penjelasan tentang desain perancangan protype

perangkat lunak untuk pengenalan wajah menggunakan metode Affine

Scale Invariant Feature Transform dengan citra masukan berupa citra

sketsa wajah.

Bab IV. Pembahasan dan Hasil

Bab ini berisi proses yang penulis lakukan dalam membuat protype

pengenalan wajah pada citra sketsa dan hasil pengujian dari dari sample

sketsa.

Bab V. Kesimpulan dan Saran

Bab ini berisi tentang kesimpulan dari hasil pengujian program dan saran-

saran yang diperlukan untuk pengembangan di masa mendatang.

5

BAB II

LANDASAN TEORI

2.1. Pengolahan Citra Digital

Ada dua prinsip daerah aplikasi pengolahan citra digital, peningkatan

informasi piktoral untuk interpretasi manusia, dan pengolahan data citra digital

untuk penyimpanan, transmisi, dan representasi bagi peralatan

presepsi(preception).

Satu dari aplikasi citra digital yang pertama adalah industri surat kabar,

ketika citra pertama kali dikirim dengan kabel kapal selam antara London dan

New York. Pengenalan sistem transmisi kabel laut Bartlane pada awal tahun 1920

mengurangi waktu yang dibutuhkan untuk mentransmisikan citra melintasi

atlantik lebih dari satu minggu sampai kurang dari tiga jam. Awalnya sistem

Bartlane dapat mengkodekan citra dalam lima perbedaan level keabuan.

Kemampuan ini ditingkatkan menjadi 15 level pada tahun 1929 (Prasetyo, 2011).

Walaupun sistem Bartlane diliputi oleh citra digital, proses yang dilakukan

tidak dipandang sebagai hasil pengolahan citra digital karena komputer tidak

digunakan dalam pembuatannya.pengolahan citra digital erat kaitannya dengan

perkembangan komputer digital. Nyatanya, citra difital membutuhka banyak

tempat penyimpanan (storage) dan kekuatan komputasi (Prasetyo, 2011)

6

.Komputer pertama yang cukup kuat untuk melakukan

pekerjaanpengolahan cita digital muncul pada tahun 1960. Bekerja menggunakan

teknik komputer untuk meningkatkan citra dari sebuah tempat penelitian dimulai

oleh Jet Propulsion Laboratory(Pasadena, California) pada tahun 1964 ketika

gambar bulan ditransmisikan oleh Ranger 7 yang kemudian diproses oleh

komputer untuk menyempurnakan bermacam - macam jenis distorsi citranya

(Prasetyo, 2011).

2.2. Scale Infariant Feature Transform(SIFT)

Pada tahun 1999, David G. Lowe seorang peneliti dari University of

British Columbia memperkenalkan suatu metode baru dalam ekstraksi fiture dari

suatu citra. Metode ekstraksi fiture ini disebut sebagai Scale Invariant Fiture

Transform(SIFT). Dengan menggunakn SIFT ini, suatu citra akan di ubah menjadi

vektor fiture lokal yang kemudian akan digunakan sebagai pendekatan dalam

mendeteksi objek yang dimaksud.

Sebagai metode ektraksi fiture pada pengenalan objek, SIFT ini memiliki

kelebihan – kelebihan sebagai berikut :

1. Hasil ektraksi fiture bersifat invariant sebagian terhadap ukuran,

translasi dan rotasi dua dimensi.

2. Hasil ekstraksi fiture bersifat invariant sebagian terhadap

perubahan iluminasi dan perubahan sudut pandang tiga dimensi.

3. Mampu meng-ekstrak banyak keypoint dari citra yang tipikal

4. Hasil ekstraksi fitur benar – benar mencirikan secara khusus

(distincsive)

7

Dengan kelebihan – kelebihan tersebut, penggunaan metode SIFT banyak

dikembangkan untuk aplikasi pengenalan objek.

Secara garis besar, alur proses yang berjalan pada metode SIFT terdiri

empat tahap, yaitu :

1. Mencari Nilai Ekstrema Pada Skala Ruang

2. Menentukan Keypoint

3. Penentuan Orientasi

4. Descriptor keypoint

Setelah melalui tahapan tersebut maka akan diperoleh fiture – fiture lokal

yang digunakan sebagai descriptor dari suatu objek.

2.1.1. Pencarian Nilai Ekstrema pada Skala Ruang

Pencarian nilai ekstrim maximum dan minimum pada skala ruang

merupakan tahap awal dalam penentuan keypoint dari suatu citra. Dengan

menggunakan fungsi Gaussian, citra pada skala ruang dapat didefinisikan sebagai

fungsi L(x,y,σ), yang diperoleh dari hasil konvolusi skala – variable Gaussian,

G(x,y,σ), dengan citra masukan I(x,y), sehingga diperoleh (Lowe, 2004) :

L(x,y,σ) = G(x,y,σ) * I(x,y)................................................................... (2.1)

dimana * adalah operasi konvolusi antara x dan y dan G(x,y,σ) adalah skala

variable Gaussian (Lowe, 2004):

G(x,y,σ) = �

�� (��)/��..................................................................(2.2)

Citra hasil Difference-of-Gaussian, D(x, y, σ), diperoleh dengan

melakukan operasi konvolusi pada citra masukan dengan filter Difference-of-

Gaussian, maka (Lowe, 2004):

8

D(x, y, σ) = G(x,y,kσ) - G(x,y,σ) * I(x,y)

= L(x,y,kσ) - L(x,y,σ)............................................................(2.3)

Dari persamaan (2.3) terlihat bahwa citra hasil Difference-of-Gaussian

sebenarnya merupakan selisih antara citra hasil pengkaburan Gaussian dengan

nilai skala k yang berbeda. Proses ini diilustrasikan sebagai berikut:

Gambar 2.1 Diagram Difference-of-Gaussian (Lowe, 2004)

Citra hasil konvolusi kemudian dikelompokan berdasarkan octave (satu

octave setara dengan penggandaan besarnya nilai σ), nilai k ditetapkan di awal

sehingga diperoleh jumlah citra kabur yang sama pada setiap octave serta

diperoleh citra hasil DoG yang sama untuk setiap octave.

Setelah diperoleh citra DoG pada setiap octave, maka langkah selanjutnya

ialah mencari kandidat keypoint. Kandidat keypoint dideteksi sebagai titik

maksimum dan minimum lokal dari citra hasil DoG. Untuk mencari nilai

9

maksimum atau minimum lokal maka masing – masing piksel pada citra hasil

DoG akan dibandingkan dengan 8 piksel disekitarnya yang berada pada skala

yang sama dengan 9 piksel yang bersesuaian dengannya pada skala yang berbeda.

Jika pixel tersebut merupakan maksimum atau minimum lokal, maka pixel

tersebut akan dijadikan sebagai kandidat keypoint.

Gambar 2.2 Ilustrasi pencarian maksimum atau minimum lokal dari citra DoG (Lowe, 2004)

2.1.2. Penentuan Keypoint

Setelah kandidat keypoint ditemukan melalui tahapan pencarian nilai

ekstrim, maka langkah selanjutnya adalah untuk menyeleksi keypoint. Dimana

setiap kandidat keypoint yang dianggap sangat rentan terhadap gangguan(noise)

akan dihilangkan, yaitu kandidat keypoint yang memiliki nilai kontras yang

rendah dan kandidat keypoint yang kurang jelas dan terletak sepanjang tepi.

Untuk menghilangkan keypoint dengan nilai kontras yang rendah, maka

digunakan langkah – langkah sebaga berikut :

10

1. Dengan menggunakan deret taylor pada fungsi skala ruang D(x, y, σ) yang

kemudian digeser sehingga titik asal berada pada titik sample, berikut ini

adalah fungsi deret Tylor (Lowe, 2004):

D(x) = D+��

��x+

�

�x� ��

�� x ........................................................................(2.4)

Dimana D dan penurunannya dilihat dari titik sample, dan x = (�, �, �)�

adalah offset dari titik ini.

2. Lokasi dari nilai ekstrim x� , diambil dengan menurunkan persamaan

sebelumnya terhadap x, sehingga didapatkan fungsi (Lowe, 2004):

x� = −��

��

�� .......................................................................................(2.5)

3. Fungsi nilai ekstrim D(x�), diperoleh dengan men-substitusikan persamaan

2.5 ke persamaan 2.4 sehingga menghasilkan persamaan berikut (Lowe,

2004) :

D(x�) = D+�

� ��

�� x� .....................................................................................(2.6)

Pada SIFT ini, semua nilai ekstrim | D(x�) | yang bernilai kurang dari 0,03 akan

dihilangkan.

Untuk menghilangkan keypoint yang kurang jelas pada tepi makan

digunakan persamaan berikut (Lowe, 2004) :

a��(�)�

��(�) <

(��)�

� ................................................................................... .(2.7)

dimana H merupakan matrix Hessian 2x2 dan r merupakan ambang batas dari

kecekungan inti yang diperbolehkan. Pada SIFT ini, semua keypoint yang

memiliki nilai r lebih besar dari 10 akan dihilangkan.

11

2.1.3. Penentuan Orientasi

Pada tahap ini, masing – masing keypoint yang diperoleh akan diberikan

suatu orientasi yang tetap berdasarkan sifat – sifat lokal pada citra. Dengan adanya

proses ini maka keypoint yang diperoleh dapat direpresentasikan relatif terhadap

orientasi ini sehingga keypoint yang dihasilkan tidak terpengaruh terhadap adanya

rotasi pada citra. Untuk menentukan orientasi dari masing – masing keypoint

maka dilakukan perhitungan terhadap besarnya gradient dan sudut arah orientasi.

Adapun perhitungan terhadap besar nilai gradient, m(x,y), dan arah orientasi

θ(x,y), dilakukan menggunakan persamaan berikut (Lowe, 2004) :

m(x,y) = �(�(� + 1, �) − �(� − 1, �))� + (�(�, � + 1) − �(�, � − 1))� (2.8)

θ(x,y) = ��((�(�, � + 1) − �(�, � − 1)) (�(� + 1, �) − �(� − 1, �)))⁄ (2.9)

2.1.4. Deskriptor Keypoint

Pada proses ini, masing – masing keypoint yang telah diorientasikan akan

diberikan pencirian khusus(descriptor). Proses ini bertujuan untuk mendapatkan

keypoint yang invariant terhadap perubahan itensitas cahaya atau perubahan sudut

padang tiga dimensi.

Descriptor akan diukur sebagai suatu histogram orientasi pada wilayah

pixel dengan ukuran 4x4. Nilai orientasi diperoleh dari citra Gaussian yang

memiliki skala terdekat dengan skala keypoint yang akan dihitung. Keypoint yang

diperoleh invariant terhadap orientasi, maka koordinat dari descriptor dan

gradient orientasi akan di rotasi relatif terhadap orientasi dari keypoint.kemudian

fungsi pembebanan Gaussian, dengan besar nilai σ satu setengah kali dari besar

12

jendela deskriptor, akan digunakan sebagai pembebanan pada setiap besaran nilai

dari titik sample.

Gambar 2.3 Deskriptor dari perhitungan besar gradien dan orientasi serta gambar lingkaran

Gaussian (kiri) dan gambar deskriptor keypoint (kanan) (Lowe, 2004)

Descriptor keypoint pada gambar diatas menunjukan adanya 8 arah pada

masing – masing histogram orientasi dengan panjang masing- masing anak panah

sesuai dengan besar nilai dari histogram asal. Selanjutnya descriptor keypoint

yang telah diperoleh akan dinormalisasi untuk mengatasi pengaruh perubahan

cahayan.

Setelah melalui tahapan – tahapan tersebut, maka pada hasil akhir akan

diperoleh suatu citra dengan keypoint yang invariant terhadap berbagai macam

perubahan, seperti yang ditunjukan pada gambar berikut ini :

13

Gambar 2.4 Keypoint yang diperoleh dari suatu citra menggunakan SIFT (Lowe, 2004)

Keypoint ini yang kemudian menjadi fiture – fiture lokal pada suatu citra dan akan

di cocokan dengan keypoint – keypoint yang terdapat pada citra lain untuk

menyesuaikan dengan objek yang tersedia pada database image.

2.3. Affine Transformation

Transformasi affine adalah semua transformasi yang mempertahankan

collinearity (semua titik yang berada pada letak tertentu tetap pada letaknya meski

telah ditransformasi) dan rasio dari jarak (misalnya, titik tengah pada bagian garis

tetap menjadi titik tengan setelah transformasi). Affine Transformation sering

disebut juga Affinity (Weisstein)

Geometric contraction, expansion, dilation, reflection, rotation, shear,

similarity transformations, spiral similarities, dan translation merupakan Affine

Transformation. Sebuah contoh tertentu menggabungkan rotasi dan ekspansi

transformasi rotasi-pembesaran (Weisstein):

14

��

�� = � ��

−��

� − �0� − �0

�

= � ��(� − �0) + ��(� − �0)

−��(� − �0) + ��(� − �0)�

Persamaan dipisahkan akan menjadi (Weisstein):

�� = (� ��)� + (� ��)� − �(�0 �� + �0 ��)

�� = (−� ��)� + (� ��)� + �(�0 �� − �0 ��)

Persamaan diatas dapat diubah menjadi (Weisstein) :

�� = �� − �� + �

�� = �� + �� + � dimana

� = � �� = −� ��

Faktor skala s didefinisikan sebagai berikut (Weisstein):

� = �� + ��

dan arah rotasi adalah (Weisstein):

� = �� −�

��

2.4. Affine Scale Invariant Feature Transform

Affine Scale Infariant Feature Transform atau yang biasa disebut ASIFT

ini adalah framework yang digunakan untuk mengektraksi fiture dari suatu citra.

ASIFT pertama kali dipublikasikan oleh Guoshen Yu dan Jean-Michel Morel

dalam jurnal yang berjudul ‘ASIFT: An Algorithm for Fully Affine Invariant

Comparison’ pada tahun 2011 (Guoshen & Morel, 2011).

ASIFT mensimulasikan tiga parameter: skala, sudut pandang dari

longitude kamera dan sudut pandang latitude (yang sejajar dengan tilt) dan

menormalkan sisanya (translasi dan rotasi). Skala dan perubahan orientasi sumbu

kamera adalah tiga parameter simulasi. Tiga lainnya, rotasi dan translasi, yang

15

dinormalisasi. Lebih detailnya, ASIFT mensimulasikan dua parameter kamera

sumbu, dan kemudian mengimplementasikan SIFT yang mensimulasikan skala

dan menormalkan rotasi dan translasi. Implementasi dua resolusi ASIFT akan

digunakan, karena memiliki sekitar dua kali kompleksitas rutin SIFT tunggal.

ASIFT menggunakan translation tilt untuk mengevaluasi performa dari

pengenalan affine. Translition tilt mengukur tingkat perubahan sudut pandang dari

satu sudut pandangan ke sudut pandang yang lain.

Gambar. 2.5. Model kamera proyektif u = S1G1Au0. A adalah mengubah sebuah proyektif planar

(Homography). G1 adalah anti-aliasing Gaussian filtering. S1 adalah sampling CCD (Guoshen &

Morel, 2011).

16

2.3.1. Algoritma ASIFT

Proses algoritma ASIFT dilakukan melalui langkah – langkah sebagai

berikut (Guoshen & Morel, 2011):

1. Setiap gambar diubah dengan mensimulasikan semua distorsi

affine mungkin disebabkan oleh perubahan orientasi sumbu optik

kamera dari posisi frontal. Distorsi ini tergantung pada dua

parameter: longitude φ dan laitude θ. Gambar mengalami rotasi

dengan sudut φ dan tilts dengan parameter t = 1 / | cos θ | (tilt dari

paramater t yang mengikuti arah x adalah operasi u (x, y) → u (tx,

y)). Untuk gambar digital, tilts dilakukan oleh directional t-

subsampling. Oleh karena itu dipererlukan sebuah aplikasi filter

antialiasing di arah sumbu x, yaitu konvolusi yang terdapat dalam

Gaussian dengan standar deviasi c√�� − �. Dengan nilai c = 0,8

adalah nilai yang ditunjukkan dalam untuk memastikan kesalahan

aliasing sangat kecil. Rotasi dan tilts ini dilakukan untuk jumlah

yang terbatas dan kecil dari sudut latitude dan longitude, langkah-

langkah sampling parameter ini memastikan bahwa gambar

simulasi tetap sama dengan tampilan lain yang mungkin dihasilkan

oleh nilai-nilai lain dari φ dan θ .

2. Semua gambar simulasi dibandingkan dengan algoritma Scale

Invariant Feature Transform(SIFT). SIFT dapat diganti dengan

metode matching invarian kesamaan lainnya. (Ada banyak varian

seperti SIFT).

17

3. Metode SIFT memiliki kriteria eliminasi perbandingan yang salah.

Oleh karena itu, umumnya meninggalkan perbandingan yang salah,

bahkan dalam pasangan gambar yang tidak memiliki kesamaan

scene. ASIFT, dengan membandingkan banyak

kesamaan(matching), oleh karena itu dapat mengumpulkan banyak

kecocokan(match) yang salah. Hal ini penting untuk menyaring

perbandingan ini. Kriteria yang digunakan adalah bahwa

perbandingan harus sesuai dengan geometri epipolar. Digunakan

metode ORSA dengan tujuan penyesuaian perbandingan(matching)

sesuai dengan geometri epipolar, yang dianggap sebagai metode

yang paling dapat diandalkan, lebih baik dari prosedur RANSAC

klasik. ORSA hanya digunakan untuk menyaring perbandingan

yang diberikan oleh kedua SIFT dan ASIFT. Dengan demikian, hal

itu mungkin terjadi bahwa dua gambar tidak memiliki

perbandingan yang tersisa sama sekali. Ini tidak berarti bahwa

tidak ada perbandingan ASIFT, mungkin semua perbandingan

dihilangkan karena bertentangan dengan geometri epipolar.

2.5. Matlab

Cleve Moler, ketua departemen ilmu komputer di University of New

Mexico, mulai mengembangkan MATLAB pada akhir 1970-an (Cleve, 2004).

(Simarta, 2010) (Kristanto, 2014) (Silajaya, 2014) Ia dirancang untuk memberikan

murid-muridnya akses ke LINPACK dan EISPACK tanpa mereka harus belajar

Fortran. Segera menyebar ke universitas lain dan menemukan audiens yang kuat

18

dalam komunitas matematika yang diterapkan. Jack kecil, seorang insinyur, yang

terkena itu selama kunjungan Moler dibuat untuk Stanford University pada tahun

1983. Menyadari potensi komersialnya, ia bergabung dengan Moler dan Steve

Bangert. Mereka menulis ulang MATLAB di C dan mendirikan MathWorks pada

tahun 1984 untuk melanjutkan perkembangannya. Ini perpustakaan ditulis ulang

dikenal sebagai JACKPAC. Pada tahun 2000, MATLAB ditulis ulang untuk

menggunakan satu set baru dari perpustakaan untuk matriks manipulasi,

LAPACK.

MATLAB pertama kali diadopsi oleh para peneliti dan praktisi di bidang

teknik kontrol, Little khusus, tapi dengan cepat menyebar ke banyak domain

lainnya. Sekarang juga digunakan dalam pendidikan, khususnya pengajaran

aljabar linear, analisis numerik, dan populer di kalangan ilmuwan yang terlibat

dalam pengolahan citra (Cleve, 2004).

MATLAB (matrix laboratory) adalah multi-paradigma lingkungan

komputasi numerik dan bahasa pemrograman generasi keempat. Dikembangkan

oleh MathWorks, MATLAB memungkinkan manipulasi matriks, merencanakan

fungsi dan data, implementasi algoritma, pembuatan antarmuka pengguna, dan

berinteraksi dengan program yang ditulis dalam bahasa lain, termasuk C, C ++,

Java, Fortran dan Python.

Meskipun MATLAB ditujukan terutama untuk komputasi numerik, sebuah

kotak peralatan opsional menggunakan mesin simbolik MuPAD, memungkinkan

akses ke kemampuan komputasi simbolik. Paket tambahan, Simulink,

19

menambahkan simulasi multi-domain grafis dan Desain Model Berbasis untuk

sistem dinamis dan tertanam.

2.6. Metode Prototyping

Prototyping adalah proses pembuatan model sederhana software yang

mengijinkan pengguna memiliki gambaran dasar tentang program serta

melakukan pengujian awal. Prototyping memberikan fasilitas bagi pengembang

dan pemakai untuk saling berinteraksi selama proses pembuatan, sehingga

pengembang dapat dengan mudah memodelkan perangkat lunak yang akan dibuat.

Prototyping merupakan salah satu metode pengembangan perangat lunak yang

banyak digunakan.

Kunci agar model Prototype ini berhasil dengan baik adalah dengan

mendefinisikan aturan-aturan main pada saat awal, yaitu user dan pengembang

harus setuju bahwa Prototype dibangun untuk mendefinisikan kebutuhan.

Gambar 2.6. Model Prototyping

http://3.bp.blogspot.com/-Ukh9IBgDvdY/T0Wr7gGgw4I/AAAAAAAAAAo/KCPmwBJ6jL8/s1600/prot.jpg

20

Proses-proses tersebut dapat dijelaskan sebagai berikut:

1. Pengumpulan kebutuhan: developer dan klien bertemu dan

menentukan tujuan umum, kebutuhan yang diketahui dan

gambaran bagian-bagian yang akan dibutuhkan berikutnya;

2. Perancangan: perancangan dilakukan cepat dan rancangan

mewakili semua aspek software yang diketahui, dan rancangan ini

menjadi dasar pembuatan Prototype;

3. Evaluasi Prototype: klien mengevaluasi Prototype yang dibuat dan

digunakan untuk memperjelas kebutuhan software.

Terdapat tiga pendekatan utama Prototyping, yaitu (Simarta, 2010):

1. THROW-AWAY

Prototype dibuat dan dites. Pengalaman yang diperoleh dari pembuatan

Prototype digunakan untuk membuat produk akhir (final), kemudian

Prototype tersebut dibuang (tak dipakai).

2. EVOLUTIONARY

Pada metode ini, prototype tidak dibuang tetapi digunakan untuk iterasi desain

berikutnya. Dalam hal ini, sistem atau produk yang sebenarnya dipandang

sebagai evolusi dari versi awal yang sangat terbatas menuju produk final atau

produk akhir..

Untuk memodelkan sebuah perangkat lunak, metode Prototyping memiliki

tahapan-tahapan di dalam proses pengembangannya. Tahapan inilah yang

21

menentukan keberhasilan dari sebuah software. Pengembang perangkat lunak

harus memperhatikan tahapan dalam metode Prototyping agar software finalnya

dapat diterima oleh pemakai. Dan tahapan-tahapan dalam Prototyping tersebut

adalah sebagai berikut :

1. Pengumpulan kebutuhan

Pemakai dan pengembang bersama-sama mendefinisikan format

seluruh perangkat lunak, mengidentifikasikan semua kebutuhan, dan

garis besar sistem yang akan dibuat.

2. Membangun Prototyping

Membangun Prototyping dengan membuat perancangan sementara

yang berfokus pada penyajian kepada pemakai (misalnya dengan

membuat input dan format output).

3. Evaluasi Protoptyping

Evaluasi ini dilakukan oleh user apakah Prototyping yang sudah

dibangun sudah sesuai dengan keinginan user. Jika sudah sesuai maka

langkah keempat akan diambil. Jika tidak, maka Prototyping direvisi

dengan mengulang langkah 1, 2 , dan 3.

4. Mengkodekan Sistem

Dalam tahap ini Prototyping yang sudah disepakati diterjemahkan ke

dalam bahasa pemrograman yang sesuai.

5. Menguji system

22

Setelah sistem sudah menjadi suatu perangkat lunak yang siap pakai,

harus dites dahulu sebelum digunakan. Pengujian ini dilakukan dengan

White Box, Black Box, Basis Path, pengujian arsitektur dan lain-lain.

6. Evaluasi Sistem

Pemakai mengevaluasi apakah sistem yang sudah jadi sudah sesuai

dengan yang diharapkan. Jika sudah, maka langkah ketujuh

dilakukan, jika belum maka mengulangi langkah 4 dan 5.

7. Menggunakan Sistem

Perangkat lunak yang telah diuji dan diterima pemakai siap untuk

digunakan.

Keunggulan dan Kelemahan Prototyping adalah sebagai berikut :

A. Keunggulan Prototyping :

1. Adanya komunikasi yang baik antara pengembang dan pemakai.

2. Pengembang dapat bekerja lebih baik dalam menentukan kebutuhan

user.

3. User berperan aktif dalam pengembangan system.

4. Lebih menghemat waktu dalam pengembangan sistem.

5. Penerapan menjadi lebih mudah karena user mengetahui apa yang

diharapkannya

B. Kelemahan Prototyping :

1. User terkadang tidak melihat atau menyadari bahwa perangkat lunak

yang ada belum mencantumkan kualitas perangkat lunak secara

23

keseluruhan dan juga belum memikirkan kemampuan pemeliharaan

untuk jangka waktu lama.

2. Pengembang biasanya ingin cepat menyelesaikan proyek. Sehingga

menggunakan algoritma dan bahasa pemrograman yang sederhana

untuk membuat Prototyping agar lebih cepat selesai tanpa memikirkan

lebih lanjut bahwa program tersebut hanya merupakan cetak biru

sistem .

Hubungan user dengan komputer yang disediakan mungkin tidak

mencerminkan teknik perancangan yang baik.

2.7. Falase Acceptance Rate(FAR), False Rejection Rate(FRR) dan Equal

Erorr Rate(EER)

Sistem biometrik yang baik seharusnya dapat menghasilkan output yang

diharapkan dari input. Namun tidak dapat dipungkiri bahwa sistem yang dibuat

menghasilkan output tidak sesuai dengan yang diharapkan. Ini terjadi karena ada

kesalahan penerimaan kandidat hasil, karena ada data yang bukan seharusnya

menjadi output memiliki nilai kecocokan melebihi threshold. Dalam biometrik

terdapat suatu sistem penilaian untuk mengukur kesalahan penerimaan output

yang dinamakan dengan False Acceptance Rate. Selain itu terkadang sistem justru

menolak data yang seharusnya menjadi output, karena data tersebut memiliki nilai

kecocokan kurang dari threshold. Kesalahan ini diukur dengan False Rejection

Rate . Threshold terbaik dapat didapatkan dari nilai yang dimiliki oleh titik

keseimbangan antara FAR dan FRR, titik ini disebut Equal Erorr Rate(EER)

(Putri, Agung, & Sa'adah, 2014).

24

BAB III

METODOLOGI PENELITIAN

Pada bab ini peneliti akan menejelaskan mengenai metodologi penelitian

yang digunakan beserta tahap – tahap yang akan dilakukan didalam penelitian.

3.1. Metode Pengumpulan Data

Pengumpulan data merupakan langkah yang penting untuk metode ilmiah,

karena pada umumnya data yang dikumpulkan digunakan untuk menguji hipotesis

yang telah dirumuskan. Teknik pengumpulan data yang sering digunakan antara

lain:

3.1.1. Studi Pustaka

Studi pustaka yang dilakukan oleh penulis dengan mencari dan

mempelajari teori-teori yang dapat dijadikan landasan atau kerangka berpikir

bagi penelitian yang akan dilakukan sehingga penyusunan laporan skripsi ini

dapat lebih terarah. Teori-teori tesebut diperoleh dari literatu tertulis, dimana

literatur tersebut perlu dicari sebanyak mungkin agar dapat dibandingkan satu

dengan yang lainnya.

Adapun sumber studi kepustakaan ini adalah buku-buku mengenai

image processing, metode pengembangan sistem, matlab sebagai dasar

bahasa pemprograman, jurnal tentang algoritma Affine Scale Invariant Fiture

Transpose(ASIFT) atau algoritma yang lain tetapi untuk identifikasi sketsa

seperti Scale Invariant Fiture Transpose(SIFT), Multiscale Markov Random

Field (MMRF), Modified Local Binary Patterns(MLBP), dan sumber-sumber

25

lainnya yang berhubungan erat dengan permasalahan yang diambil baik

berupa buku ataupun paper.

3.1.2. Penelitian Sejenis

Penulis mencari penelitian – penelitian yang berkaitan mengenai

identifikasi wajah sebelumnya telah dilakukan oleh peneliti lain. Berikut

ini beberapa penjelasan singkat mengenai literature-literatur yang relevan

dengan topik yang diteliti oleh penulis :

Tabel 3.1. Tabel Perbandingan Studi Literatur Sejenis

Nama Judul Penelitian Kelebihan Kekurangan Yuwono jurusan teknik elektro Universitas Kristen Maranatha

PERBANDINGAN TEKNIK SCALE INVARIANT FEATURE TRANSFORM (SIFT) DAN MULTISCALE LOCAL BINARY PATTERN (MLBP) DALAM PENGENALAN WAJAH DENGAN CITRA MASUKAN BERUPA SKETSA

1. Hasil perbandingan dapat menunjukkan bahwa dengan teknik SIFT sketsa dapat diidentifikasi lebih baik daripada menggunakan MLBP

2. Tingkat keakurasian dalam identifikasi sketsa mencapai 80,3%

1. Algoritma SIFT hanya menemukan sedikit keypoint pada sketsa maupun foto

Alvin Silajaya Jurusan teknik elektro, Universitas Kristen Maranatha

PENGENALAN WAJAH DENGAN CITRA MASUKAN BERUPA CITRA SKETSA WAJAH SEBAGAI HASIL SINTESIS DENGAN TEKNIK

1. Menggunakan algoritma reduksi data Local Discriminant Analysis dan Principal Component Analysis

1. Tingkat keakurasian tertinggi dalam identifikasi sketsa hanya 60% dengan menggunakan metode Principal

26

MULTISCALE MARKOV RANDOM FIELD (MRF)

Component Analysis dalam reduksi datanya.

3.2. Metode Pengembangan Prototyping

Pada metode pengembangan simulasi ini penulis menggunakan metode

prototyping. Adapun alasan kenapa penulis menggunakan metode pengembangan

prototyping ini, sebagai berikut:

1. Sistem yang dibuat bukan berupa aplikasi namun masih berupa

prototype aplikasi untuk membuktikan penggunaan ASIFT dalam

identifikasi sketsa.

2. Ada tekanan untuk implementasi secepatnya, disini karena penulis

menginginkan program simulasi ini bisa jadi secepatnya sehingga tidak

terlalu menghabiskan banyak dana dan waktu.

Adapun langkah-langkah yang digunakan dalam pengembangan

prototyping yang akan dibuat, sebagai berikut:

3.2.1 Pengumpulan Kebutuhan

Tahap awal pengembangan prototyping diawali dengan pengumpulan

kebutuhan. Pada tahap ini penulis melakukan analisis kebutuhan dan

mengidentifikasi segala kebutuhan. Dari analisis tersebut dapat ditetapkan tujuan

27

perancangan, pengajuan usulan solusi yang dapat diterima. Tahapannya adalah

sebagai berikut :

3.2.1.1 Analisa Sistem

Pada tahap ini penulis akan membahas mengenai analisa sistem pada

identifikasi sketsa wajah yang dilukis dengan foto wajah yang telah disimpan

selama ini, yang dilakukan pada lembaga – lembaga terkait.

3.2.1.2 Identifikasi Masalah

Pada tahap ini penulis menjelaskan masalah yang terjadi pada sistem.

3.2.1.3 Usulan Penyelesaian Masalah

Pada tahap ini penulis menjelaskan mengenai usulan penggunaan metode

Affine Scale Invaraiant Feature Transform untuk identifikasi sketsa wajah.

3.2.1.4 Kebutuhan Perangkat Lunak dan Perangkat Keras

Pada tahapan ini penulis membuat spesifikasi dari aplikasi simulasi yang

penulis buat dari kebutuhan hardware dan kebutuhan dari software yang penulis

gunakan untuk membuat prototype. Pembuatan spesifikasi ini bertujuan untuk

memudahkan dalam melakukan analisa kemampuan yang sesuai dengan

kebutuhan.

3.2.2 Membangun Prototype

Didalam prototyping melakukan perancangan sementara yg berupa format

input dan output berikut adalah tahapan yg akan dilakukan:

28

3.2.2.1 Desain Image Processing

Pada tahap ini penulis akan menjelaskan mengenai proses image

processing yang penulis terapkan dalam pengenalan wajah pada sketsa

menggunakan algoritma Affine Scale Invariant Feature Transform. Adapun

tahapan yang penulis lakukan adalah :

1. Image Acquisition

Pada tahap ini penulis akan menjelaskan bagaimana penulis

memperoleh data citra yang di butuhkan dalam proses pengenalan

wajah pada citra sketsa.

2. Feature Extraction

Pada tahap ini penulis akan menjelaskan mengenai proses dalam

mendapatkan ciri ciri khusus pada citra sketsa maupun pada citra

foto menggunakan algoritma Affine Scale Infariant Feature

Transform.

3. Recognition

Pada tahap ini penulis akan menjelaskan mengenai proses dalam

mengenali citra sketsa untuk mendapatkan citra foto yang cocok,

dengan mencocokkan ciri ciri khusus pada citra sketsa dengan ciri

ciri khusus pada citra foto.

29

3.2.2.2 Desain Interface

Pada tahap ini, penulis melakukan perancangan terhadap user interface

dari prototype. Untuk tampilan antar muka, penulis melakukan perancangan GUI

(Graphical User Interface).

3.2.3 Mengkodekan Sistem

Pada tahap ini, semua rancangan yang sudah dirancang diatas akan

dikodekan kedalam program dengan menggunakan tools untuk membangun

simulasi ini. Tools yang dipakai adalah Matlab 8.03 untuk membangun prototype

ini.

3.2.4 Pengujian Prototype

Prototype aplikasi ini diuji apakah protype ini dapat menganalisa

wajah dari citra masukan berupa sketsa. Pada tahap ini akan didapatkan nilai

nilai keypoint dan kecocokan antara citra masukan dengan citra hasil

identifikasi.

30

3.3. Kerangka Berfikir

Gambar 3.1.1 Alur Kerangka Berpikir

31

BAB IV

PEMBAHASAN DAN HASIL

Pada perancangan prototype aplikasi ini penulis melakukan perancangan

dengan menggunakan metode pengembangan Prototyping. Prototyping adalah

proses pembuatan model sederhana software yang mengijinkan pengembang

memiliki gambaran dasar tentang program serta melakukan pengujian awal.

Prototyping memberikan fasilitas bagi pengembang dan pemakai untuk saling

berinteraksi selama proses pembuatan, sehingga pengembang dapat dengan

mudah memodelkan perangkat lunak yang akan dibuat. Prototyping merupakan

salah satu metode pengembangan perangat lunak yang banyak digunakan. Berikut

ini adalah langkah-langkah yang penulis lakukan dalam melakukan prancangan

dengan menggunakan metode prototyping, sebagai berikut :

4.1. Pengumpulan Kebutuhan

Pada tahapan penggumpulan kebutuhan peneliti melakukan dengan

beberapa tahapan seperti berikut ini:

4.1.1. Analisa Sistem

Data yang digunakan dibagi menjadi dua bagian. Pertama adalah

kumpulan citra foto yang telah ada didalam komputer. Kedua adalah citra sketsa

yang dibuat berdasarkan informasi yang didapatkan. Data citra sketsa akan

dicocokkan dengan data citra foto sampai ditemukan wajah yang sama atau

setidaknya mirip pada citra foto dengan wajah pada citra sketsa.

32

4.1.2. Identifikasi Masalah

Setelah melakukan analisa masalah yang ditemukan adalah sebagai

berikut :

1. Sulitnya mengidentifikasi wajah dari citra sketsa yang telah dibuat

untuk mendapatkan wajah yang sama yang ada didalam komputer.

Terutama apabila citra yang akan dibandingkan banyak jumlahnya.

2. Sketsa dan foto memiliki dua perbedaan yang mencolok yaitu,

tekstur dan bentuknya.

4.1.3. Usulan Penyelesaian Masalah

Dibuat sebuah sistem yang akan mengidentifikasi wajah pada citra sketsa

sehingga didapatkan foto yang sesuai dengan citra sketsa yang diidentifikasi.

Menggunakan metode Affine Scale Invariant Feature Transform untuk mengatasi

perbedaan tekstur dan bentuk pada sketsa dan foto.

4.1.4. Kebutuhan Perangkat Lunak dan Perangkat Keras

Perangkat Keras yang akan digunakan untuk membangun

prototype adalah sebagai berikut:

Tabel 4.1. Tabel Spesifikasi Kebutuhan Perangkat Keras

Jenis Laptop atau Komputer Spesifikasi Laptop Samsung 275E4E AMD E2-2000 APU(1,8 GHz),

4GB RAM, 500 GB HDD, Amd Radeon HD 7340 Grapics, Generic PnP Monitor, Synaptic PS/2 Port TouchPad.

33

Kebutuhan untuk perangkat lunak yang akan penulis gunakan

adalah :

Tabel 4.2. Perangkat Lunak Yang Digunakan

Nama Perangkat Lunak

Fungsi

Sistem Operasi Windows 7 Ultimate 32bit

Sebagai interface antara pengguna dan komputer.

Matlab 8.03 Sebagai tools untuk membuat serta menjalankan program simulasi yang dibuat.

Borlan C++ 5.02 Sebagai tools untuk menganalisa algoritma Affine Scale Invariant Feature Transform(ASIFT).

4.2. Membangun Prototype

Pada tahapan ini akan dilakukan desain untuk prototype yang akan dibuat

dengan beberapa tahapan yaitu tahapan desain image processing dan desain

interface. Berikut ini adalah penjelasan tentang desain yang penulis lakukan,

sebagai berikut :

4.2.1. Desain Image Processing

Pada tahapan ini akan dilakukan desain untuk proses image processing

yang dibutuhkan untuk mengenali wajah pada sketsa. Berikut ini adalah tahapan

sampai recognition(pengenalan) beserta penjelasan untuk mempermudah dalam

membangun prototype yang akan dibuat :

1. Image Acquisition

Pada image acquisition ini digunakan sepuluh citra, lima citra foto dan

lima citra sketsa berekstensi .jpeg. Citra digunakan sebagai input dalam proses

34

pengenalan. Citra foto telah ada di dalam komputer, citra sketsa dimasukkan ke

dalam komputer menggunakan scanner.

2. Feature Extraction

Pada feature extraction digunakan metode Affine Scale Invariant Feature

Transform(ASIFT). Tahap ini diawali dengan menentukan citra sketsa yang akan

diidentifikasi yang dipilih oleh user. Citra sketsa yang dipilih dan citra foto yang

pertama akan digandakan, citra yang digandakan akan dikaburkan(blur) dengan

beberapa tingkat pengkaburan(blurring). Pengkaburan ini dilakukan berulang

dengan citra yang ukurannya setengah dari citra sebelumnya.

Citra hasil pengkaburan(blurring) dengan ukuran yang sama tapi berbeda

tingkat pengkaburannya dihitung perbedaan kekaburannya(blur) yang biasa

disebut dengan Different of Gaussian(DoG). Langkah ini dilakukan untuk semua

citra yang dikaburan(blurred) dengan semua ukuran citra dan hasilnya berupa

citra DoG.

Setiap pixel Citra DoG dibandingkan dengan 3x3 pixel tetangga pada citra

tersebut dan 3x3 pixel pada posisi yang sama dengan pixel yang akan

dibandingkan plus 3x3 pixel tetangganya pada citra DoG sebelum dan Citra DoG

setelahnya. Jadi setiap pixel dibandingkan dengan 26 pixel, apabila pixel tersebut

paling besar atau paling kecil pixel tersebut menjadi keypoint.

35

Gambar 4.1 Contoh citra hasil pengkaburan(blurring) 1S.jpg dengan ukuran 828x1164,

414x582, 207x291,103x145

36

Gambar 4.2 Contoh citra hasil pengkaburan(blurring) 1F.jpg dengan ukuran 2048x1536,

1024x768, 512x384, 256x192

37

Gambar 4.3 Contoh citra blurring menjadi citra DoG

Gambar 4.

Keypoint yang terletak pada

tingkat pencahayaan yan rendah akan disingkirkan.

dicari gradient magnitude

dibuat histogram dari

histogram ini, 360 derajat orientasi dipecah menjadi 36 grafik batang (masing

Gambar 4.4 Contoh Mencari Ekstrema dalam citra DoG

yang terletak pada tepi(edge) dan terletak pada wilayah dengan

tingkat pencahayaan yan rendah akan disingkirkan. Keypoint yang tersisa akan

gradient magnitude dan gradient orientasi dari pixel disekitarnya

dibuat histogram dari gradient magnitude dan gradient orientasi tersebut


38

DoG

dan terletak pada wilayah dengan

yang tersisa akan

disekitarnya. Lalu akan

orientasi tersebut. Didalam


39

masing 10 derajat). Misalnya arah gradient pada titik tertentu adalah 15,5 derajat,

maka gradient garis akan masuk ke 10-19 derajat diagram batang. Banyaknya

“jumlah” yang dimasukan pada diagram batang tergantung dari magnitude dari

gradient pada point tersebut. Setelah dilakukan terhadap semua pixel disekitar

keypoint, histogram akan memiliki ketinggian pada angka tertentu.

Gambar 4.5 Contoh Histogram Orientasi

Dari contoh histogram diatas grafik pada nilai gradient 20-29 menjadi

maksimum orientasi yang dimiliki oleh pixel disekitar keypoint. Semu grafik

gradient dari orientasi yang memiliki nilai lebih dari 80% dari maksimum

orientasi dikonversi menjadi keypoint yang baru. Keypoint yang baru ini memiliki

lokasi dan scale yang sama dengan keypoint yang asli. Tapi orientasinya sesuai

dengan ketinggian yang lain.

Selanjutnya pemberian identitas khusus(finger print) pada keypoint, ini

dilakukan dengan membuat 16x16 kotak disekitar keypoint. 16x16 kotak ini

dikelompokkan menjadi kotak 4x4.

40

Gambar 4.6 Contoh pemberian finger print pada keypoint

Setiap kotak 4x4, dihitung gradient magnitudes dan orientasinya. Orientasi ini

diletakkan pada grafik lingkaran yang dibagi menjadi 8.

Gambar 4.7 Memasukkan orientasi pada hitogram lingkaran

Gradient Orientasi yang berada pada range 0-44 derajat dimasukkan dalam

wilayah(bin) pertama, 45-89 dimasukkan ke dalam wilayah(bin) selanjutnya dan

selanjutnya. Banyaknya jumlah yang dimasukkan kedalam wilayah(bin)

tergantung dari magnitude dari gradient dan jaraknya dari keypoint. Jadi gradient

yang jaraknya jauh dari keypoint akan menambahkan bobot yang kecil kedalam

41

histogram. Ini dilakukan dengan menggunakan fungsi pembobotan gaussian,

fungsi ini menghasilkan sebuah gradient yang akan dikalikan dengan magnitude

dari orientasi, sehingga didapatkan magnitude yang telah mendapatkan bobot.

Semakin jauh, smakin kecil nilai bobot dari magnitude.

Gambar 4.8 gradient orientasi yang mengalami pembobotan gaussian

3. Recognition

Pada recognition ini keypoint pada sketsa dan foto yang akan dihitung

perbedaannya, keypoint yang memiliki perbedaan terkecil dianggap cocok. Hasil

pencocokkan keypoint yang memiki pasangan lebih dari satu baik dari satu ke

banyak maupun dari banyak ke satu akan dihapus.Hasil pencocokkan keypoint

yang memiliki letak pixel yang berbeda (proses matching yang salah) akan

dihapus. Maka akan didapatkan keypoint yang cocok antara sketsa dan Foto. Citra

foto yang memiliki kecocokkan keypoint yang terbanyak dan memiliki jumlah

kecocokkan diatas treeshold dianggap sebagai citra foto yang memiliki kemiripan

wajah paling besar dengan citra sketsa. Citra foto tersebut akan ditampilkan

sebagai citra hasil identifikasi citra sketsa.

42

Tabel 4.3 Hasil Matching Keypoint

Nama Sketsa

Sketsa Nama Foto

Foto Jumlah

Keypoint Match

1S.jpg

1F.jpg

56 keypoint

4.2.2. Desain Interface

Pada tahap ini, penulis melakukan perancangan terhadap user interface

dari aplikasi protype ini. Untuk tampilan antar muka penulis melakukan

perancangan GUI (Graphical User Interface). Berikut ini rancangan interface

yang akan dibangun :

1. Halaman Utama

Ini adalah halaman awal dari sumulasi dan juga merupakan halaman

navigasi utama. Berikut ini adalah desain dari halaman utama:

43

Gambar 4.9 Desain Interface Halaman Utama

2. Halaman Inisialisasi

Halaman ini berisi kebutuhan informasi awal untuk menjalankan program

simulasi. Berikut ini adalah desain dari halaman inisialisasi :

Gambar 4.10 Desain Interface Inisialisasi

44

3. Halaman Identifikasi Sketsa

Pada halaman ini akan dilakukan identifikasi sketsa sehingga didapatkan

citra foto yang seharusnya memiliki wajah yang sama dengan sketsa. Berikut ini

adalah desain untuk halaman Identifikasi :

Gambar 4.11 Desain Interface Identifikasi Sketsa

4.3. Mengkodekan Sistem

Pada tahap ini, semua rancangan simulasi yang telah disepakati dikodekan

kedalam program dengan menggunakan tools untuk mebuat simulasinya. Tools

yang dipakai adalah Matlab 8.03 untuk mebuat simulasi identikasi sketsa.

Sedangkan algoritma ASIFT yang peneliti pakai telah dibuat sebelumnya oleh

Jean-Michel Morel dan Guoshen Yu menggunakan bahasa C, jadi pada tahap ini

peneliti akan menganalisa kode bahasa C yang telah mereka buat. Berikut ini

adalah tahapan identifikasi sketsa yang telah dikodekan :

45

1. Penerapan Pengkodean Matlab untuk Inisialisasi

Proses inisialisasi dilakukan untuk menentukan kebutuhan awal sistem

simulasi. Proses ini sangatlah penting apabila ada kesalahan pada proses ini maka

sistem simulasi tidak akan berjalan dengan semestinya.Berikut ini adalah kode

Matlab untuk inisialisasi :

Potongan program diatas digunakan untuk mengambil pathfolder yang

berisi lima citra sketsa, lalu diletakkan pada edit box di dalam interface inisialisasi.

function FotoPath_Callback(hObject, eventdata, handles) function FotoPath_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function FotoPathBtn_Callback(hObject, eventdata, handles) FotPath = uigetdir; if ischar(FotPath) set(handles.FotoPath,'String',FotPath); end handles.FotPath = FotPath; guidata(hObject, handles);

function SketsaPath_Callback(hObject, eventdata, handles) function SketsaPath_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function SketsaPathBtn_Callback(hObject, eventdata, handles) SketPath = uigetdir; if ischar(SketPath) set(handles.SketsaPath,'String',SketPath); end handles.SketPath = SketPath; guidata(hObject, handles);

46

Potongan program diatas digunakan untuk mengambil path folder yang

berisi lima citra foto, lalu diletakkan pada edit box di dalam interface inisialisai.

Potongan program diatas digunakan untuk menyimpan hasil konfigurasi

pada tahap inisialisai kedalam file requirement.mat, lalu menutup intarface

inisialisasi.

Potongan program diatas digunakan untuk membatalkan konfigurasi pada

inisialisasi, lalu menutup interface inisialisasi.

2. Proses Pengkodean Identifikasi Sketsa

Prose identifikasi sketsa dilakukan melalui beberpa tahapan, yaitu:

1. Penerapan Pengkodean Matlab untuk Input Citra Sketsa

Pada proses ini user akan memasukkan nama citra sketsa dan sistem

akan mencari citra yang sesuai dengan input. Berikut ini adalah kode

Matlab Input Sketsa :

function pushbutton4_Callback(hObject, eventdata, handles)

close(gcf);

function pushbutton3_Callback(hObject, eventdata, handles) HasilMatcPath = handles.HasilMatcPath; SketPath = handles.SketPath; FotPath = handles.FotPath; ImageFiles = dir(FotPath); Train_Number = 0; for i = 1:size(ImageFiles,1) if not(strcmp(ImageFiles(i).name,'.')|strcmp(ImageFiles(i).name,'..')|strcmp(ImageFiles(i).name,'Thumbs.db')) Train_Number = Train_Number + 1; % Number of all images in the training database end end save requirement.mat SketPath FotPath Train_Number HasilMatcPath close(gcf);

47

Potongan program diatas digunakan untuk mengambil masukkan

nama citra sketsa. Lalu citra sketsa dan citra foto akan diambil dari

folder database citra sketsa maupun database citra foto.

2. Penerapan Pengkodean C++ untuk Algoritma ASIFT

Algoritma ASIFT memiliki beberapa tahapan yang dilakukan, berikut

ini adalah kode dari tahapan – tahapan dari algoritma ASIFT beserta

analisa dari kode tersebut:

load requirement.mat axes(handles.axes2); clear gca; %sket = strcat(SketPath); [FileName,PathName,FilterIndex] = uigetfile({'*.jpg'},'Select Sketsa',SketPath); handles.NamaFile=FileName; handles.PathName=PathName; guidata(hObject,handles); if isequal(FileName,0) disp('User selected Cancel') else axes(handles.axes2); clear gca; set(gca,'ytick',[]); set(gca,'xtick',[]); axes(handles.axes2); handles.Citra.RGB = imread([PathName FileName]); image(handles.Citra.RGB), set(gca,'ytick',[]); set(gca,'xtick',[]); guidata(hObject,handles);

48

Potongan coding diatas digunakan untuk membentuk citra pada skala

ruang dengan menggunakan Different of Gaussian.

void OctaveKeypoints(flimage & image,float octSize, keypointslist& keys,siftPar &par) { int size_blur = par.Scales+3; int size_dogs = par.Scales+2; flimage *blur =new flimage[size_blur]; flimage *dogs =new flimage[size_dogs]; float sigmaRatio =(float) pow(2.0,1.0/(double) par.Scales); blur[0]= flimage(image); float prevSigma = par.InitSigma; for(int i =1; i < par.Scales +3; i++){ if(DEBUG) printf("Convolving scale: %d \n", i); blur[i]= flimage(blur[i-1]); float increase = prevSigma*(float)sqrt((double)(sigmaRatio*sigmaRatio-1.0)); gaussian_convolution( blur[i].getPlane(), blur[i].getPlane(), blur[i].nwidth(), blur[i].nheight(), increase); prevSigma *= sigmaRatio; } for(int i =0; i < par.Scales +2; i++){ dogs[i]= flimage(blur[i]); combine(dogs[i].getPlane(),1.0f, blur[i+1].getPlane(),-1.0f, dogs[i].getPlane(), dogs[i].nwidth()* dogs[i].nheight()); } image = blur[par.Scales]; if(DEBUG) printf("Looking for local maxima \n"); FindMaxMin(dogs, blur, octSize, keys,par); delete[] blur; delete[] dogs; }

49

voidFindMaxMin( flimage* dogs, flimage* blur, float octSize, keypointslist& keys,siftPar &par) { int width = dogs[0].nwidth(), height = dogs[0].nheight(); flimage map(width,height,0.0f); flimage grad(width,height,0.0f); flimage ori(width,height,0.0f); for(int s =1; s < par.Scales+1; s++){ if(DEBUG) printf("************************scale: %d\n", s); compute_gradient_orientation(blur[s].getPlane(), grad.getPlane(), ori.getPlane(), blur[s].nwidth(), blur[s].nheight()); assert(par.BorderDist >=2); float val; int partialcounter =0; for(int r = par.BorderDist; r < height - par.BorderDist; r++) for(int c = par.BorderDist; c < width - par.BorderDist; c++){ val = dogs[s](c,r); if(fabs(val)>0.8* par.PeakThresh) { if(LocalMaxMin(val, dogs[s-1], r, c)&& LocalMaxMin(val, dogs[s], r, c)&& LocalMaxMin(val, dogs[s+1], r, c)&& NotOnEdge(dogs[s], r, c, octSize,par)) { partialcounter++; if(DEBUG) printf("%d: (%d,%d,%d) val: %f\n",partialcounter, s,r,c,val); InterpKeyPoint( dogs, s, r, c, grad, ori, map, octSize, keys,5,par); } } } } }

50

Potongan coding diatas digunakan untuk menentukan kandidat

keypoint yang merupakan hasil dari pencarian nilai maksimum lokal

pada citra hasil Different of Gaussian.

Potongan coding diatas digunakan untuk menghilangkan keypoint

yang memiliki nilai kontras yang rendah.

Potongan coding diatas digunakan untuk menghilangkan keypoint

yang kurang jelas pada tepi.

intNotOnEdge(flimage& dog,int r,int c,float octSize,siftPar &par) { float H00 = dog(c,r-1)-2.0* dog(c,r)+ dog(c,r+1), H11 = dog(c-1,r)-2.0* dog(c,r)+ dog(c+1,r), H01 =((dog(c+1,r+1)- dog(c-1,r+1))-(dog(c+1,r-1)- dog(c-1,r-1)))/4.0; float det = H00 * H11 - H01 * H01, trace = H00 + H11; if(octSize <=1) return(det > par.EdgeThresh1 * trace * trace); else return(det > par.EdgeThresh * trace * trace); }

if( fabs(offset[0])>1.5|| fabs(offset[1])>1.5|| fabs(offset[2])>1.5|| fabs(peakval)< par.PeakThresh) { if(DEBUG) printf("Point not well localized by FitQuadratic\n"); par.noncorrectlylocalized++; return; }

51

voidAssignOriHist( const flimage& grad,const flimage& ori,float octSize, float octScale,float octRow,float octCol,keypointslist& keys,siftPar &par) { int bin, prev, next; float distsq, dif, gval, weight, angle, interp; int tmp_size = par.OriBins; float*hist =newfloat[tmp_size]; float radius2, sigma2; int row =(int)(octRow+0.5), col =(int)(octCol+0.5), rows = grad.nheight(), cols = grad.nwidth(); for(int i =0; i < par.OriBins; i++) hist[i]=0.0; float sigma = par.OriSigma * octScale; int radius =(int)(sigma *3.0); int rmin = MAX(0,row-radius); int cmin = MAX(0,col-radius); int rmax = MIN(row+radius,rows-2); int cmax = MIN(col+radius,cols-2); radius2 =(float)(radius * radius);

sigma2 =2.0*sigma*sigma;

52

for(int r = rmin; r <= rmax; r++){ for(int c = cmin; c <= cmax; c++){ gval = grad(c,r); dif =(r - octRow); distsq = dif*dif; dif =(c - octCol); distsq += dif*dif; if(gval >0.0&& distsq < radius2 +0.5){ weight = exp(- distsq / sigma2); /* Ori is in range of -PI to PI. */ angle = ori(c,r); bin =(int)(par.OriBins *(angle + PI +0.001)/(2.0* PI)); assert(bin >=0&& bin <= par.OriBins); bin = MIN(bin, par.OriBins -1); hist[bin]+= weight * gval; } }

} for(int i =0; i <6; i++) SmoothHistogram(hist, par.OriBins); float maxval =0.0; for(int i =0; i < par.OriBins; i++) if(hist[i]> maxval) maxval = hist[i]; for(int i =0; i < par.OriBins; i++){ prev =(i ==0? par.OriBins -1: i -1); next =(i == par.OriBins -1?0: i +1); if( hist[i]> hist[prev]&& hist[i]> hist[next]&& hist[i]>= par.OriHistThresh * maxval ){ interp = InterpPeak(hist[prev], hist[i], hist[next]); angle =2.0* PI *(i +0.5+ interp)/ par.OriBins - PI; assert(angle >=-PI && angle <= PI); if(DEBUG) printf("angle selected: %f \t location: (%f,%f)\n", angle, octRow, octCol); ; } } delete[] hist; }

53

Potongan program diatas digunakan untuk menentukan orientasi pada

masing – masing keypoint yang telah mengalami penyaringan

sebelumnya.

voidKeySample( float index[IndexSize][IndexSize][OriSize], keypoint& key, const flimage& grad,const flimage& ori,float scale,float row,float col,siftPar &par) { float rpos, cpos, rx, cx; int irow =(int)(row +0.5), icol =(int)(col +0.5); float sine =(float) sin(key.angle), cosine =(float) cos(key.angle); float spacing = scale * par.MagFactor; float radius =1.414* spacing *(IndexSize +1)/2.0; int iradius =(int)(radius +0.5); for(int i =-iradius; i <= iradius; i++){ for(int j =-iradius; j <= iradius; j++){ rpos =((cosine * i - sine * j)-(row - irow))/ spacing; cpos =((sine * i + cosine * j)-(col - icol))/ spacing; rx = rpos + IndexSize /2.0-0.5; cx = cpos + IndexSize /2.0-0.5; if( rx >-1.0&& rx <(float) IndexSize && cx >-1.0&& cx <(float) IndexSize ) AddSample( index, key, grad, ori, irow + i, icol + j, rpos, cpos, rx, cx,par); } } }

void AddSample( float index[IndexSize][IndexSize][OriSize], keypoint& key, const flimage& grad,const flimage& orim, float r,float c,float rpos,float cpos,float rx,float cx,siftPar &par) {

54

if(r <0|| r >= grad.nheight()|| c <0|| c >= grad.nwidth()) return; float sigma = par.IndexSigma *0.5* IndexSize, weight = exp(-(rpos * rpos + cpos * cpos)/(2.0* sigma * sigma)), mag = weight * grad((int)c,(int)r float ori = orim((int)c,(int)r)- key.angle; if(par.IgnoreGradSign){ while(ori > PI ) ori -= PI; while(ori <0.0) ori += PI; }else{ while(ori >2.0*PI) ori -=2.0*PI; while(ori <0.0) ori +=2.0*PI; } PlaceInIndex(index, mag, ori, rx, cx,par); } void PlaceInIndex( float index[IndexSize][IndexSize][OriSize], float mag,float ori,float rx,float cx,siftPar &par) { int orr, rindex, cindex, oindex; float rweight, cweight, oweight; float*ivec; float oval = OriSize * ori /(par.IgnoreGradSign ? PI :2.0*PI);

int ri =(int)((rx >=0.0)? rx : rx -1.0), ci =(int)((cx >=0.0)? cx : cx -1.0), oi =(int)((oval >=0.0)? oval : oval -1.0);

float rfrac = rx - ri, cfrac = cx - ci, ofrac = oval - oi; assert( ri >=-1&& ri < IndexSize && oi >=0&& oi <= OriSize && rfrac >=0.0&& rfrac <=1.0);

55

Pototngan program diatas digunakan untuk memberikan ciri khusus

untuk keypoint yang telah melalui proses orientasi.

3. Penerapan Pengkodean C++ untuk Algoritma Matching

Proses matching dilakukan untuk menyamakan nilai – nilai keypoint

yang terdapat pada citra foto dengan keypoint pada citra foto. Berikut

ini adalah pengkodean proses Matching :

Potongan coding dibawah ini digunakan untuk menentukan jumlah

keypoint yang memiliki kecocokan antara citra satu dengan citra

kedua

for(int r =0; r <2; r++){ rindex = ri + r; if(rindex >=0&& rindex < IndexSize){ rweight = mag *((r ==0)?1.0- rfrac : rfrac); for(int c =0; c <2; c++){ cindex = ci + c; if(cindex >=0&& cindex < IndexSize){ cweight = rweight *((c ==0)?1.0- cfrac : cfrac); ivec = index[rindex][cindex]; for(orr =0; orr <2; orr++){ oindex = oi + orr; if(oindex >= OriSize) oindex =0; oweight = cweight *((orr ==0)?1.0- ofrac : ofrac); ivec[oindex]+= oweight; } } } } }

56

#pragma omp parallel for private(tt) for(int tt =1; tt <= num_tilt1; tt++) { float t = t_min * pow(t_k, tt-1); float t1 = t; float t2 =1; int num_rot1; if( tt ==1) { num_rot1 =1; } else { num_rot1 = round(num_rot_t2*t/2); if( num_rot1%2==1) { num_rot1 = num_rot1 +1; } num_rot1 = num_rot1 /2; } float delta_theta = PI/num_rot1; #pragma omp parallel for private(rr) for(int rr =1; rr <= num_rot1; rr++) { float theta = delta_theta *(rr-1); theta = theta *180/ PI; keypointslist keypoints1 = keys1[tt-1][rr-1]; #pragma omp parallel for private(tt2) for(int tt2 =1; tt2 <= num_tilt2; tt2++) { float t_im2 = t_min * pow(t_k, tt2-1); float t_im2_1 = t_im2; float t_im2_2 =1; int num_rot1_2; if( tt2 ==1) { num_rot1_2 =1; } num_rot1_2 = num_rot1_2 +1; } num_rot1_2 = num_rot1_2 /2; }

57

else { num_rot1_2 = round(num_rot_t2*t_im2/2); if( num_rot1_2%2==1) { num_rot1_2 = num_rot1_2 +1; } num_rot1_2 = num_rot1_2 /2; } float delta_theta2 = PI/num_rot1_2; #pragma omp parallel for private(rr2) for(int rr2 =1; rr2 <= num_rot1_2; rr2++) { float theta2 = delta_theta2 *(rr2-1); theta2 = theta2 *180/ PI; keypointslist keypoints2 = keys2[tt2-1][rr2-1]; matchingslist matchings1; compute_sift_matches(keypoints1,keypoints2,matchings1,siftparameters); if( verb ) { printf("t1=%.2f, theta1=%.2f, num keys1 = %d, t2=%.2f, theta2=%.2f, num keys2 = %d, num matches=%d\n", t, theta,(int) keypoints1.size(), t_im2, theta2,(int) keypoints2.size(),(int) matchings1.size()); } if( matchings1.size()>0) { matchings_vec[tt-1][rr-1][tt2-1][rr2-1]= matchingslist(matchings1.size()); Minfoall_vec[tt-1][rr-1][tt2-1][rr2-1].resize(matchings1.size()); for(int cc =0; cc <(int) matchings1.size(); cc++) { matchings_vec[tt-1][rr-1][tt2-1][rr2-1][cc]= matchings1[cc]; vector<float> Minfo_1match(6); Minfo_1match[0]= t1; Minfo_1match[1]= t2; Minfo_1match[2]= theta; Minfo_1match[3]= t_im2_1; Minfo_1match[4]= t_im2_2; Minfo_1match[5]= theta2; Minfoall_vec[tt-1][rr-1][tt2-1][rr2-1][cc]= Minfo_1match; } }}}}

58

Potongan coding diatas digunakan untuk memasukkan hasil keypoint

yang cocok kedalam vektor satu dimensi.

for(tt =1; tt <= num_tilt1; tt++) { t = t_min * pow(t_k, tt-1); if( t ==1) { num_rot1 =1; } else { num_rot1 = round(num_rot_t2*t/2); if( num_rot1%2==1) { num_rot1 = num_rot1 +1; } num_rot1 = num_rot1 /2; } for( rr =1; rr <= num_rot1; rr++) { for(tt2 =1; tt2 <= num_tilt2; tt2++) { t_im2 = t_min * pow(t_k, tt2-1); if( t_im2 ==1) { num_rot1_2 =1; } else { num_rot1_2 = round(num_rot_t2*t_im2/2); if( num_rot1_2%2==1) { num_rot1_2 = num_rot1_2 +1; } num_rot1_2 = num_rot1_2 /2; } for( rr2 =1; rr2 <= num_rot1_2; rr2++) { for( cc=0; cc <(int) matchings_vec[tt-1][rr-1][tt2-1][rr2-1].size(); cc++) { matchings.push_back(matchings_vec[tt-1][rr-1][tt2-1][rr2-1][cc]); Minfoall.push_back(Minfoall_vec[tt-1][rr-1][tt2-1][rr2-1][cc]); } }}}}

59

Potongan coding diatas digunakan untuk menghapus hasil match yang

dilakukan berulang saat simulasi berlangsung, menghapus hasil match

dimana satu keypoint pada citra satu memiliki lebih dari satu keypoint

yang cocok pada citra kedua atau sebaliknya.

if( matchings.size()>0) { matchingslist matchings_unique; vector< vector<float>> Minfoall_unique; unique_match1(matchings, matchings_unique, Minfoall, Minfoall_unique); matchings = matchings_unique; Minfoall = Minfoall_unique; if( verb ) { printf("The number of unique matches is %d \n",(int) matchings.size()); } matchings_unique.clear(); Minfoall_unique.clear(); clean_match2(matchings, matchings_unique, Minfoall, Minfoall_unique); matchings = matchings_unique; Minfoall = Minfoall_unique; matchings_unique.clear(); Minfoall_unique.clear(); clean_match1(matchings, matchings_unique, Minfoall, Minfoall_unique); matchings = matchings_unique; Minfoall = Minfoall_unique;

60

Potongan coding diatas digunakan untuk menghapus pencocokan

keypoint yang salah menggunakan epipolar geomertric filtering.

for( cc =0; cc <(int) matchings.size(); cc++) { Match match1_coor; match1_coor.x1 = matchings[cc].first.x; match1_coor.y1 = matchings[cc].first.y; match1_coor.x2 = matchings[cc].second.x; match1_coor.y2 = matchings[cc].second.y; match_coor.push_back(match1_coor); } std::vector<float> index; int t_value_orsa=10000; int verb_value_orsa=0; int n_flag_value_orsa=0; int mode_value_orsa=2; int stop_value_orsa=0; float nfa = orsa((w1+w2)/2,(h1+h2)/2, match_coor, index, t_value_orsa, verb_value_orsa, n_flag_value_orsa, mode_value_orsa, stop_value_orsa); if( nfa < nfa_max ) { matchings_unique.clear(); Minfoall_unique.clear(); for( cc =0; cc <(int) index.size(); cc++) { matchings_unique.push_back(matchings[(int)index[cc]]); Minfoall_unique.push_back(Minfoall[(int)index[cc]]); } matchings = matchings_unique; Minfoall = Minfoall_unique; cout <<"The two images match! "<< matchings.size()<<" matchings are identified. log(nfa)="<< nfa <<"."<< endl; } else { matchings.clear(); Minfoall.clear(); cout <<"The two images do not match. The matching is not significant: log(nfa)="<< nfa <<"."<< endl; }

61

4. Penerapan Pengkodean Matlab untuk Seleksi dan Hasil

Proses ini dilakukan untuk menseleksi hasil dari keypoint matching

nilai matching terbesar dan memiliki nilai lebih dari treeshold akan

menjadi citra wajah hasil identifikasi. Berikut ini adalah kode proses

seleksi dan hasil :

Proses diawali dengan pembacaan matching.txt yang berisi nilai –

nilai match dari keypoint antara sketsa dan foto. Diambil nilai jumlah

keypoint match dari file tersebut lalu dilakukan perbandingan dengan

nilai jumlah matching sebelumnya. Setelah mendapat nilai jumlah

fid = fopen('matchings.txt','r'); i =1; tline = fgetl(fid); A{i}= tline; while ischar(tline) i = i+1; tline = fgetl(fid); A{i}= tline; end fclose(fid); matchK = str2num(A{1}); if (matchK>matchTst&&matchK>TreesHold) matchTst = matchK; ImgRsltNm = ImgName;

End

if(matchTst>0) image = strcat(TrainDatabasePath,'\',ImgRsltNm,'.jpg'); images = imread(image); figure,imshow(images); title('Equivalent Image'); disp(strcat('Matched image is : ',ImgRsltNm)) fprintf('Found %d matches.\n', matchTst); else fprintf('Image not found.\n');

62

match terbesar dan memiliki treeshold lebih dari 50 maka foto akan

ditampilkan dan menjadi hasil identifikasi sketsa.

4.4. Pengujian Prototype

Selanjutnya penulis menguji prototype aplikasi identifikasi wajah

pada citra sketsa menggunakan metode ASIFT dapat menghasilkan hasil

identifikasi ciri dari sketsa dan foto. Hasil pengenalan wajah pada sketsa

dapat menunjukkan foto yang sama atau setidaknya mirip dengan sketsa.

1. Daftar Jumlah Keypoint yang Ditemukan Pada Sketsa Mengggunakan

Metode ASIFT

Tabel 4.4 Jumlah Keypoint Citra Sketsa

Nama Sketsa Sketsa Jumlah Keypoint

yang Terdeteksi

1S.jpg

8078

2S.jpg

8663

63

3S.jpg

7539

4S.jpg

8614

5S.jpg

7836

64

2. Daftar Jumlah Keypoint yang Ditemukan Pada Foto Mengggunakan

Metode ASIFT

Tabel 4.5 Jumlah Keypoint Citra Foto

Nama Foto Foto Jumlah Keypoint

yang Terdeteksi

1F.jpg

7991

2F.jpg

10445

3F.jpg

8845

4F.jpg

11599

65

5F.jpg

8621

3. Hasil Pengujian False Acceptance Rate(FAR) dan False Rejection

Rate(FRR)

Tabel 4.6 Hasil Pengujian FER dan FRR

Threshold yang Digunakan FAR FRR

30 0,12 0

40 0,04 0

50 0 0

60 0 0,2

70 0 0,6

Berdasarkan hasil pengujian FER dan FRR yang telah penulis lakukan

maka akan didapatkan titik Equal Eror Rate(EER) berada pada threshold 50.

Maka threshold yang penulis gunakan untuk prototype ini adalah 50.

66

4. Hasil Pengenalan Sketsa Menggunakan Metode ASIFT

Tabel 4.7 Jumlah Match Keypoint Citra Sketsa dan Foto

Nama

Sketsa

Foto yang

dikenali

Jumlah Keypoint

Match Benar/Salah

1S.jpg 1F.jpg 56 keypoint Benar





67

BAB V

PENUTUP

5.1. Kesimpulan

Berdasarkan penelitian yang telah penulis lakukan metode Affine Scale

Invariant Feature Transform (SIFT) dapat mengidentifikasi ciri khusus (feature)

dari citra sketsa dan foto dengan baik, ini terlihat dari banyaknya feature yang

dihasilkan. Dari lima sample citra sketsa yang diidentifikasi hasil foto yang di

dapatkan merupakan wajah dari sketsa.

5.2. Saran

1. Untuk memaksimalkan kinerja proses perlu dicari algoritma yang dapat

memepercepat analisa wajah menggunakan ASIFT.

2. Gunakan fariasi algoritma SIFT lain yang dapat digunakan untuk

menganalisa wajah dari citra sketsa.

Daftar Pustaka

Cleve, M. (2004, December). "The Origins of MATLAB". Dipetik Juli 1, 2015,

dari Mathwoks:

http://www.mathworks.com/company/newsletters/articles/the-origins-of-

matlab.html

Guoshen, Y., & Morel, J. M. (2011). ASIFT: An Algorithm for Fully Affine

Invariant Comparison. Image Processing On Line .

Kristanto, Y. (2014). Perbandingan Teknik Scale Invariant Feature Transform

(SIFT) dan Multiscale Local Binary Pattern (MLBP) dalam Pengenalan

Wajah dengan Citra Masukan Berupa Citra Sketsa Wajah.

Lowe, D. G. (2004). Distinctive Image Features from Scale-Invariant Keypoints.

5-15.

Prasetyo, E. (2011). Pengolahan Citra Digital dan Aplikasinya mengggunakan

Matlab. Yogyakarta: Andi.

Putri, G., Agung, T., & Sa'adah, S. (2014). Analisis dan Implementasi Scale

Invariant Feature Transform (SIFT) pada Sistem Autentikasi

Menggunakan Pembuluh Vena.

Rachman, A., & Romi. (2010). Analisis Penggunaan Scale Invariant Feature

Transform Sebagai Metode Ekstraksi Fitur Pada Pengenalan Jenis

Kendaraan.

Silajaya, A. (2014). Pengenalan Wajah Dengan Citra Masukan Berupa Citra

Sketsa Wajah Sebagai Hasil Sintesis Dengan Teknik Multiscale Markov

Random Field (MRF).

Simarta, J. (2010). Rekayasa Perangkat Lunak. Yogyakarta: Andi.

Weisstein, E. W. (t.thn.). "Affine Transformation.". Dipetik July 05, 2015, dari

MathWorld--A Wolfram Web Resource:

http://mathworld.wolfram.com/AffineTransformation.html

Lampiran – Lampiran

Lampiran 1. SK Dosen Pembimbing

Lampiran 2. Tampilan Prototype Aplikasi Pengenalan

Wajah Pada Citra Sketsa

1. Tampilan Halamna Utama 2. Tampilan Identifikasi Sketsa

3. Tampilan Inisialisasi 4. Tampilan Help 5. Tampilan About

Lampiran 3. Source Code Prototype Aplikasi Pengenalan

Wajah Pada Citra Sketsa

Source Code Home.m function varargout = Home(varargin) gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @Home_OpeningFcn, ... 'gui_OutputFcn', @Home_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT % --- Executes just before Home is made visible. function Home_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to Home (see VARARGIN) % Choose default command line output for Home handles.output = hObject; CitraLogo = imread('C:\Users\Mukhlis L\Documents\MATLAB\Hasil Match\logo.png'); imshow(CitraLogo); % Update handles structure guidata(hObject, handles); % UIWAIT makes Home wait for user response (see UIRESUME) % uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line. function varargout = Home_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structure varargout{1} = handles.output; % --- Executes on button press in pushbutton1. function pushbutton1_Callback(hObject, eventdata, handles) % hObject handle to pushbutton1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) SelectReq; % --- Executes on button press in pushbutton2. function pushbutton2_Callback(hObject, eventdata, handles) % hObject handle to pushbutton2 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) IdenSketsa; % --- Executes on button press in pushbutton3. function pushbutton3_Callback(hObject, eventdata, handles) % hObject handle to pushbutton3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) Help; % --- Executes on button press in pushbutton4. function pushbutton4_Callback(hObject, eventdata, handles) % hObject handle to pushbutton4 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) About; % --- Executes on button press in pushbutton5. function pushbutton5_Callback(hObject, eventdata, handles) % hObject handle to pushbutton5 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) close(gcf);

function varargout = SelectReq(varargin) % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @SelectReq_OpeningFcn, ... 'gui_OutputFcn', @SelectReq_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT % --- Executes just before SelectReq is made visible. function SelectReq_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to SelectReq (see VARARGIN) % Choose default command line output for SelectReq handles.output = hObject; % Update handles structure guidata(hObject, handles); % UIWAIT makes SelectReq wait for user response (see UIRESUME) % uiwait(handles.figure1); % --- Outputs from this function are returned to the command line. function varargout = SelectReq_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structure varargout{1} = handles.output;

Source Code SelectReq.m function SketsaPath_Callback(hObject, eventdata, handles) % --- Executes during object creation, after setting all properties. function SketsaPath_CreateFcn(hObject, eventdata, handles) % hObject handle to SketsaPath (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in SketsaPathBtn. function SketsaPathBtn_Callback(hObject, eventdata, handles) % hObject handle to SketsaPathBtn (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) SketPath = uigetdir; if ischar(SketPath) set(handles.SketsaPath,'String',SketPath); end handles.SketPath = SketPath; guidata(hObject, handles); function FotoPath_Callback(hObject, eventdata, handles) % hObject handle to FotoPath (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of FotoPath as text % str2double(get(hObject,'String')) returns contents of FotoPath as a double % --- Executes during object creation, after setting all properties. function FotoPath_CreateFcn(hObject, eventdata, handles) % hObject handle to FotoPath (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in FotoPathBtn. function FotoPathBtn_Callback(hObject, eventdata, handles) % hObject handle to FotoPathBtn (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) FotPath = uigetdir; if ischar(FotPath) set(handles.FotoPath,'String',FotPath); end handles.FotPath = FotPath; guidata(hObject, handles); % --- Executes on button press in pushbutton3. function pushbutton3_Callback(hObject, eventdata, handles) % hObject handle to pushbutton3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) SketPath = handles.SketPath; FotPath = handles.FotPath; ImageFiles = dir(FotPath); Train_Number = 0; for i = 1:size(ImageFiles,1) if not(strcmp(ImageFiles(i).name,'.')|strcmp(ImageFiles(i).name,'..')|strcmp(ImageFiles(i).name,'Thumbs.db')) Train_Number = Train_Number + 1; % Number of all images in the training database end end save requirement.mat SketPath FotPath Train_Number close(gcf); % --- Executes on button press in pushbutton4. function pushbutton4_Callback(hObject, eventdata, handles) close(gcf);

Source Code IdenSketsa.m function varargout = IdenSketsa(varargin) % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @IdenSketsa_OpeningFcn, ... 'gui_OutputFcn', @IdenSketsa_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT % --- Executes just before IdenSketsa is made visible. function IdenSketsa_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to IdenSketsa (see VARARGIN) % Choose default command line output for IdenSketsa handles.output = hObject; % Update handles structure guidata(hObject, handles); axes(handles.axes2); clear gca; set(gca,'ytick',[]); set(gca,'xtick',[]); axes(handles.axes3); clear gca; set(gca,'ytick',[]); set(gca,'xtick',[]); % UIWAIT makes IdenSketsa wait for user response (see UIRESUME) % uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line. function varargout = IdenSketsa_OutputFcn(hObject, eventdata, handles) varargout{1} = handles.output; % --- Executes on button press in SketBtn. function SketBtn_Callback(hObject, eventdata, handles) load requirement.mat axes(handles.axes2); clear gca; %sket = strcat(SketPath); [FileName,PathName,FilterIndex] = uigetfile({'*.jpg'},'Select Sketsa',SketPath); handles.NamaFile=FileName; handles.PathName=PathName; guidata(hObject,handles); if isequal(FileName,0) disp('User selected Cancel') else axes(handles.axes2); clear gca; set(gca,'ytick',[]); set(gca,'xtick',[]); axes(handles.axes2); handles.Citra.RGB = imread([PathName FileName]); image(handles.Citra.RGB), set(gca,'ytick',[]); set(gca,'xtick',[]); guidata(hObject,handles); %disp(['User selected', fullfile(PathName, FileName)]) end % --- Executes on button press in pushbutton2. function pushbutton2_Callback(hObject, eventdata, handles) % hObject handle to pushbutton2 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) matchTst = 0; load requirement.mat ImageName = handles.NamaFile; file_img1 = strcat(SketPath,'\',ImageName); for i=1:5 ImgName = int2str(i); %file_img1 = strcat(SketPath,'\',ImgName,'.jpg'); file_img2 = strcat(FotPath,'\',ImgName,'.jpg'); imgOutVert = 'imgOutVert.png';

imgOutHori = 'imgOutHori.png'; matchings = 'matchings.txt'; keys1 = 'keys1.txt'; keys2 = 'keys2.txt'; flag_resize = 0; demo_ASIFT(file_img1, file_img2, imgOutVert, imgOutHori, matchings, keys1, keys2, flag_resize); fid = fopen('matchings.txt','r'); i = 1; tline = fgetl(fid); A{i} = tline; while ischar(tline) i = i+1; tline = fgetl(fid); A{i} = tline; end fclose(fid); matchK = str2num(A{1}); if matchK>matchTst matchTst = matchTst+matchK; ImgRsltNm = ImgName; end end if (matchTst>0) images = strcat(FotPath,'\',ImgRsltNm,'.jpg'); axes(handles.axes3); image(imread(images)); grid off; axis off; %figure,imshow(images); %title('Equivalent Image'); disp(strcat('Matched image is : ',ImgRsltNm)) fprintf('Found %d matches.\n', matchTst); else fprintf('Image not found.\n'); end % --- Executes on button press in pushbutton3. function pushbutton3_Callback(hObject, eventdata, handles) close (gcf);

IMPLEMENTASI ALGORITMA AFFINE SCALE...

Documents

Transcript of IMPLEMENTASI ALGORITMA AFFINE SCALE...