PERANCANGAN DAN ANALISIS OPTICAL CHARACTER

RECOGNITION (OCR) UNTUK MENDETEKSI PELAT

KENDARAAN BERMOTOR PADA PT TIRTA GEMAH RIPAH

TUGAS AKHIR

Karya tulis ilmiah sebagai salah satu syarat untuk memperoleh

gelar Sarjana Teknik dari Program Studi Teknik Elektro
Universitas Jenderal Achmad Yani

Oleh

ALAN SURYAWINATA
NIM 2212151065

JURUSAN TEKNIK ELEKTRO

FAKULTAS TEKNIK
UNIVERSITAS JENDERAL ACHMAD YANI
2019
 LEMBAR PENGESAHAN

PERANCANGAN DAN ANALISIS OPTICAL CHARACTER

RECOGNITION (OCR) UNTUK MENDETEKSI PELAT
KENDARAAN BERMOTOR PADA PT TIRTA GEMAH RIPAH

Oleh

ALAN SURYAWINATA
NIM 2212151065
Konsentrasi Teknik Instrumentasi dan Kendali

Draft Penelitian sudah disetujui untuk diuji dalam Sidang Penelitian

Cimahi, 24 Juli 2019

Menyetujui,

Pembimbing

Dr. EMPU TANTULAR, S.T., M.T.

NID 412133580
 LEMBAR PENGESAHAN

PERANCANGAN DAN ANALISIS OPTICAL CHARACTER

RECOGNITION (OCR) UNTUK MENDETEKSI PELAT
KENDARAAN BERMOTOR PADA PT TIRTA GEMAH RIPAH

Oleh

ALAN SURYAWINATA
NIM 2212151065
Konsentrasi Teknik Instrumentasi dan Kendali

Penelitian sudah diuji dan disetujui

Cimahi, 24 Juli 2019

Menyetujui,

Pembimbing

Dr. EMPU TANTULAR, S.T., M.T.

NID 412133580

Mengetahui,

Ketua Jurusan Teknik Elektro

YUDA BAKTI ZAINAL, ST., MT., IPM.

NID 412148369
 LEMBAR PERNYATAAN

Yang bertanda tangan di bawah ini

Nama : Alan Suryawinata
Tempat, tgl lagir : Bandung, 8 April 1996
NIM : 2212151065
Fakultas/Jurusan : Fakultas Teknik/ Teknik Elektro
dengan ini menyatakan bahwa Penelitian dengan judul “PERANCANGAN DAN
ANALISIS OPTICAL CHARACTER RECOGNITION (OCR) UNTUK
MENDETEKSI PELAT KENDARAAN BERMOTOR PADA PT TIRTA
GEMAH RIPAH” beserta seluruh isinya adalah karya saya sendiri dan bukan
merupakan karya tulis orang lain, baik sebagian maupun seluruhnya, kecuali
bentuk kutipan yang telah disebutkan sumbernya.

Saya menyetujui untuk memberikan buku Penelitian kepada Universitas Jenderal

Achmad Yani demi pengembangan ilmu pengetahuan. Pihak Universitas berhak
menyimpan, mengalihmediakan, mengelola dalam bentuk pangkalan data,
merawat, dan mempublikasikan Penelitian saya selama tetap mencantumkan nama
saya sebagai penulis.

Demikian surat pernyataan ini saya buat dengan sebenar-benarnya. Apabila

dikemudian hari ditemukan adanya pelanggaran terhadap etika keilmuan dalam
karya saya atau ada klaim dari pihak lain terhadap keaslian karaya saya, maka
saya siap menanggung segala bentuk resiko/sanksi yang berlaku.

Cimahi, 24 Juli 2019

Yang Membuat Pernyataan

(materai 6000)

(Alan Suryawinata)
 ABSTRAK

Pelat nomor polisi kendaraan adalah salah satu bagian penting dari kendaraan
bermotor atau bisa disebut Tanda Nomor Kendaraan Bermotor (TNKB). TNKB
merupakan identitas utama dari sebuah kendaraan bermotor yang layak
jalan/beroperasi di jalan raya, sehingga pelat nomor polisi umumnya diletakkan
pada posisi yang mudah dilihat. Berdasarkan data badan pusat statistik Jawa
Barat, jumlah kendaraan non public pada tahun 2016 mencapai angka 15.924.034
kendaraan.

Optical Character Recognition (OCR) adalah proses pengalihan dokumen teks

menjadi file komputer tanpa harus pengeditan ulang, setiap karakter baik huruf,
kata, kalimat dapat dikenali secara tepat dan dibaca oleh perangkat lunak yang
lain. OCR dapat diterapkan pada sistem pendeteksi pelat nomor polisi kendaraan
untuk membaca karakter pelat dari sumber gambar atau video. Pada penelitian ini
dibuatlah aplikasi yang menggunakan algoritma K-Nearest Neighbor yang akan
membaca karakter pada pelat dengan menggunakan training dataset sebanyak 500
karakter.

Hasil pembacaan karakter pada pelat memiliki hasil yang cukup baik dan faktor
yang berpengaruh dalam hasil output sistem antara lain bentuk pelat, intensitas
cahaya, kualitas citra, metode pembacaan pelat serta training dataset yang kurang
banyak.

Kata kunci: pelat,kendaraan,OCR,knn,citra

i
 ABSTRACT

The police vehicle number plate is one of the important parts of a motorized
vehicle or it can be called a vehicle registration plate. Vehicle registration plate is
the main identity of a vehicle that is suitable to be used / operated on the highway,
so police license plates mounted above are easily seen. Based on West Java
statistical center data, the number of non-public vehicles in 2016 reached
15,924,034 vehicles.

Optical Character Recognition (OCR) is the process of transferring text

documents into computer files without having to edit them again, each character
both letters, words, sentences can be recognized correctly and read by other
software. OCR can be applied to the vehicle police license plate detection system
to read plate characters from image or video sources. In this study an application
was made using the K-Nearest Neighbor algorithm that would read characters on
the plate using a training dataset of 500 characters.

The results of the character reading on the plate have quite good results and the
factors that influence the output system between the shape plate, light intensity,
image quality, plate reading method and training dataset are less numerous.

Keywords: Plate Recognition, OCR, KNN, image, vehicle

ii
 KATA PENGANTAR

Dengan mengucap puji dan syukur kehadirat Allah SWT, karena atas ridho dan
hidayahNya, sehingga penulis dapat menyelesaikan Penelitian ini.
Maksud dan tujuan dari penulisan Penelitian ini adalah untuk memenuhi
persyaratan kelulusan program Studi Strata I pada Jurusan Teknik Elektro di
Universitas Jendral Ahmad Yani Cimahi. Selain itu penulis juga dapat mencoba
menerapkan dan membandingkan pengetahuan dan keterampilan yang diperoleh
dibangku kuliah untuk melakukan pembuatan aplikasi penelitian.

Penulis merasa bahwa dalam menyusun penelitian ini masih menemui beberapa
kesulitan dan hambatan, disamping itu juga menyadari bahwa penulisan penelitian
ini masih jauh dari sempurna dan masih banyak kekurangan-kekurangan lainnya,
maka dari itu penulis mengharapkan saran dan kritik yang membangun dari semua
pihak.

Menyadari penyusunan penelitian ini tidak lepas dari bantuan berbagai pihak,
maka pada kesempatan ini penulis menyampaikan ucapan terima kasih yang
setulus-tulusnya kepada:
1) Bapak Dede Masukan nama lengkap disini dan gelar, S.Kom, M.T.
sebagai dosen pembimbing pertama yang telah bersedia untuk
meluangkan waktu untuk membimbing, memeriksa, serta memberikan
petunjuk-petunjuk serta saran dalam penyusunan penelitian ini.
2) Bapak Masukan kepala jurusan dan gelar disini. Selaku ketua kompetensi
keahlian Teknik Elektro di Universitas Jendral Ahmad Yani kota Cimahi.
3) Ade Abdul Gofur, S.T. selaku Supervisor SDM di PT Tirta Gemah Ripah
yang telah mempermudah penulis dalam pengambilan data dilingkungan
perusahaan.
4) Seketaris Jurusan Teknik Informatika Universitas Jendral Ahmad Yani
yang telah membantu penulis dalam mengurus proposal penelitian.

iii
5) Seluruh staf pengajar Universitas Jendral Ahmad Yani yang telah
membimbing dan memberikan materi perkuliahan kepada penulis.
6) Seluruh staf Perpustakaan Universitas Jendral Ahmad Yani yang telah
membantu penulis dalam peminjaman buku.
7) Papa, mama dan anggota keluarga yang tercinta atas curahan kasih
sayang, doa dan dorongan baik moril maupun materil kepada penulis.
8) Hardiyan Ichsan Gunawan dan Irwan Shofwan sebagai teman yang ahli
dalam Bahasa pemprograman Pyrhon, yang banyak memberikan ide-ide
baru untuk penelitian ini.
9) Teman kerja seperusahaanku Iman Holik, Purwana, Fikri, Kodam, Herry
Indriana, Dede Yunus serta rekan kerja lain yang tidak dapat penulis
sebutkan satu persatu, karena meringankan dan mempermudah saya dalam
mengerjakan penelitian di lingkungan perusahaan.
10) Seluruh rekan -rekan di U nivers itas J endral Ahmad Yani Bandung,
khus us nya Jurusan Elektro Angkatan ’15 yang telah memberikan saran
dan kritikan kepada penulis.
11) Seluruh pihak yang tidak dapat disebutkan satu persatu, yang telah
banyak membantu selama ini.

Akhir kata, semoga Allah SWT senantiasa melimpahkan karunia-Nya dan

membalas segala amal budi serta kebaikan pihak-pihak yang telah membantu
penulis dalam penyusunan penelitian ini dan semoga tulisan ini dapat memberikan
manfaat bagi pihak-pihak yang membutuhkan.

Cimahi, 24 Juli 2019

Alan Suryawinata

iv
 DAFTAR ISI

ABSTRAK................................................................................................................i
ABSTRACT.............................................................................................................ii
KATA PENGANTAR............................................................................................iii
DAFTAR ISI............................................................................................................v
DAFTAR LAMPIRAN..........................................................................................vii
DAFTAR GAMBAR............................................................................................viii
DAFTAR TABEL....................................................................................................x
DAFTAR SINGKATAN........................................................................................xi
BAB I PENDAHULUAN........................................................................................1
1.1. Latar Belakang................................................................................................1
1.2. Rumusan Masalah...........................................................................................2
1.3. Tujuan Penelitian............................................................................................2
1.4. Batasan Masalah.............................................................................................3
BAB II TEORI PENUNJANG................................................................................4
2.1. Tinjauan Pustaka.............................................................................................4
2.2. Dasar Teori.....................................................................................................4
2.2.1. Pelat Nomor Kendaraan.............................................................................4
2.2.2. Citra Digital (Image)..................................................................................6
2.2.3. Pengolahan Citra Digital............................................................................8
2.2.4. Video........................................................................................................14
2.2.5. Optical Character Recognition (OCR).....................................................15
2.2.6. Open CV (Computer Vision)...................................................................17
2.2.7. Haar-Like Feature...................................................................................18
2.2.8. Haar Classifier........................................................................................20
2.2.9. Cascade Classifier...................................................................................21
2.2.10. Gaussian Noise........................................................................................22
2.2.11. Contour....................................................................................................23
2.2.12. K-Nearest Neighbor.................................................................................24
BAB III METODE PENELITIAN........................................................................26

v
3.1. Analisis Sistem................................................................................................26
3.1.1. Analisis Kebutuhan Perangkat Keras (Hardware).......................................26
3.1.2. Analisis Kebutuhan Perangkat Lunak (Software)........................................26
3.2. Prosedur Penelitian.........................................................................................27
3.2.1. Waktu dan Lokasi Penelitian.......................................................................27
3.2.2. Teknik Pengambilan Data............................................................................28
3.2.3. Desain dan Perancangan Sistem..................................................................29
3.2.4. Analisis Kinerja Sistem................................................................................42
BAB IV HASIL PENGUJIAN DAN ANALISIS..................................................43
4.1. Hasil Penelitian.............................................................................................43
4.2. Pembahasan..................................................................................................47
4.2.1. Posisi Pelat...............................................................................................47
4.2.2. Warna pelat..............................................................................................49
4.2.3. Intensitas Cahaya.....................................................................................49
4.2.4. Training dataset........................................................................................49
BAB V KESIMPULAN DAN SARAN.................................................................50
5.1. Kesimpulan.....................................................................................................50
5.2. Saran.............................................................................................................50
DAFTAR PUSTAKA............................................................................................52

vi
 DAFTAR LAMPIRAN

LAMPIRAN A CODING PYTHON MAIN.PY.................................................A-1

LAMPIRAN B CODING PYTHON SINGLE-CAP.PY.....................................B-1
LAMPIRAN C CODING PYTHON CHARDETECT.PY..................................C-1

vii
 DAFTAR GAMBAR

Gambar 2.1 Pelat Nomor Kendaraan Indonesia.......................................................5

Gambar 2.2. Gambar Citra BITMAP (.bmp)...........................................................7
Gambar 2.3. Gambar Citra PNG (.png)...................................................................8
Gambar 2.4. Gambar Citra JPG...............................................................................8
Gambar 2.5. Proses Pengolahan Citra......................................................................9
Gambar 2.6. Kontras Rendah.................................................................................11
Gambar 2.7. Kontras Tinggi..................................................................................11
Gambar 2.8. Kontras Normal.................................................................................12
Gambar 2.9. Contoh Perhitungan Kontras.............................................................12
Gambar 2.10. Contoh Thresholding.......................................................................13
Gambar 2.11. Blok Diagram Kerja OCR (Trilaksono, 2008)................................16
Gambar 2.12. Haar-Like Feature..........................................................................19
Gambar 2.13. Perbedaan Supervised, Unsupervised dan Semi Supervised...........20
Gambar 2.14. Model Cascade Classifier...............................................................22
Gambar 2.15. Citra yang terkena Gaussian Noise.................................................23
Gambar 2.16. Penerapan Contour..........................................................................24
Gambar 3.1. Diagram Alir (Flowchart) Tahapan Penelitian.................................27
Gambar 3.2. Area Pengambilan data.....................................................................28
Gambar 3.3. Diagram Blok Sistem Keseluruhan...................................................29
Gambar 3.4. Illustrasi Sistem Keseluruhan............................................................30
Gambar 3.5. Diagram Alir (Flowchart) Perancangan Sistem................................31
Gambar 3.6. Tampilan Video Masukan.................................................................32
Gambar 3.7. Diagram Alir (Flowchart) Proses Deteksi Pelat Kendaraan.............35
Gambar 3.8. Hasil pemotongan gambar.................................................................37
Gambar 3.9. Diagram Alir (Flowchart) Preprocessing.........................................37
Gambar 3.10. Hasil Konversi Gambar RGB ke Grayscale....................................38
Gambar 3.11. Hasil Meningkatkan Kontras...........................................................38
Gambar 3.12. Hasil Blur........................................................................................39
Gambar 3.13. Hasil Thresholding..........................................................................39

viii
Gambar 3.14. Diagram Alir (Flowchart) Proses Deteksi Karakter.......................40
Gambar 3.15. Diagram Alir (Flowchart) Pembacaan Karakter.............................41
Gambar 4.skian. Contoh Posisi Pelat Miring.........................................................47
Gambar 4.sekian. Hasil Contoh Pelat Miring........................................................48
Gambar 4.sekian. Pembanding Contoh Pelat Miring.............................................48
Gambar 4.sekian. Hasil Pembanding Contoh Pelat Miring...................................48

ix
 DAFTAR TABEL

Tabel 3.1. Training Dataset Karakter 0-H.............................................................27

Tabel 3.1. Training Dataset Karakter I-Z..............................................................28
Tabel 4.1. Hasil Pendeteksi Karakter Setiap Pelat.................................................39
Tabel 4.2. Hasil Pengukuran Akurasi Setiap Karakter dari Semua Pelat..............40

x
 DAFTAR SINGKATAN

Singkatan Arti Pemakaian

pertama kali
pada halaman

xi
 BAB I PENDAHULUAN

1.1. Latar Belakang

Berdasarkan data badan pusat statistik Jawa Barat, jumlah kendaraan roda empat
non public pada tahun 2018 mencapai angka 15.924.034 kendaraan. Di mana
jumlah terbanyak adalah pengguna sepeda motor yakni 13.725.590 sepeda motor.
Hal ini tentu memberi gambaran betapa tingginya kebutuhan masyarakat terhadap
sarana tranportasi.[1] Pelat nomor polisi kendaraan adalah salah satu bagian
penting dari kendaraan bermotor atau disebut Tanda Nomor Kendaraan Bermotor.
TNKB merupakan identitas utama dari sebuah kendaraan bermotor yang layak
jalan/beroperasi di jalan raya, sehingga pelat nomor polisi umumnya diletakkan
pada posisi yang mudah dilihat.[2]

Metode pembacaan karakter pada pelat menggunakan metode connected

componen dan SVM (Aris Budianto, Teguh harata Adji, dan Rudy Hartanto tahun
2015), edge detection (Erwin Dwika Putra dan Dedy Abdullah tahun 2018), dan
metode transformasi hough dan hit or miss (Yuda Puspito, F. X. Arinto Setyawan,
Helmy Fitriawan tahun 2018) memiliki tujuan untuk mendeteksi pelat nomor pada
kendaraan namun belum mendeteksi setiap karakter yang terdapat pada pelat.
Maka dari itu diperlukan metode yang berfungsi untuk membaca karakter pada
pelat seperti OCR.

Dalam penelitian ini penulis akan menggunakan metode Optical Character

Recognition (OCR) sebagai pendeteksi pelat nomor yang terdapat pada kendaraan
bermotor. Optical Character Recognition (OCR) adalah algoritma yang berfungsi
untuk menscan citra dan dijadikan teks, dan algoritma ini juga bisa menjadi
support /algoritma tambahan untuk scanner. Dari penelitian sebelumnya yaitu
Aplikasi Pendeteksi Plat Nomor Negara Indonesia Menggunakan OpenCV dan
Tesseract OCR pada Android Studio (Sangsaka Wira Utama, dan Apriani Kusuma
wardhani tahun 2017) dan Analisis Performansi Metode Knn (K-Nearest
Neighbor) Untuk Pengenalan Karakter Pada Plat Nomor Kendaraan di Raspberry

1
Pi (Noor Azlin Tauchid, R Rumani, dan Budhi Irawan, S.Si., M.T. tahun 2015)
memiliki hasil yang cukup baik dalam pendeteksian karakter pada pelat
khususnya pada metode K-Nearest Neighbor memiliki akurasi 77,98%.

Dalam penelitian ini penulis akan menggunakan metode OCR dengan

menggunakan algoritma K-Nearest Neighbor dan algoritma Haar Casce
Classification untuk mendeteksi gambar pelat untuk menyelesaikan permasalaah
di PT Tirta Gemah Ripah. Permasalahan di PT Tirta Gemah Ripah dapat menjadi
contoh kasus yang digunakan untuk mengimplementasikan program pendeteksi
pelat nomor kendaraan bermotor dengan metode Optical Character Recognition
(OCR). Kendaraan di PT TGR terbagi menjadi dua yaitu kendaraan perusahaan
dan kendaraan karyawan dan jumlah personil security yang terbatas dalam
penjagaan. Hal ini menyebabkan beberapa masalah diantaranya sulitnya
mengindentifikasi kendaraan mana yang keluar dan masuk perusahaan,
kemungkinan pencurian motor meningkat dan karyawan dapat keluar – masuk
perusahaan tanpa izin tanpa pengawasan.

1.2. Rumusan Masalah

Permasalahan yang dibahas dalam penelitian ini adalah:
1) Bagaimana membuat sistem yang dapat mengenali nomor pelat kendaraan
format font Indonesia.
2) Bagaimana sistem dapat mengenali identitas pemilik kendaraan.
3) Bagaimana akurasi sistem pendeteksian pelat kendaraan serta karakter
yang terdapat pada pelat.

1.3. Tujuan Penelitian

Berdasarkan rumusan masalah yang diuraikan, maka tujuan dari penelitian ini
yaitu:
a. Merancang sistem yang dapat mendeteksi pelat nomor kendaraan bermotor
dengan metode OCR.

2
 b. Merancang dan mengsimulasikan aplikasi yang mampu mendeteksi dan
mengkonstruksi karakter pelat kendaraan yang akan parkir dalam area
parkiran PT Tirta Gemah Ripah.
c. Menganalisis akurasi dari pembacaan keseluruhan karakter pada setiap
pelat dan akurasi pembacaan setiap karakter.

1.4. Batasan Masalah

Berdasarkan rumusan yang diuraikan pada latar belakang, maka masalah
difokuskan pada perancangan, pembuatan Sistem Pendeteksian dan Rekognisi
Teks Pelat Kendaraan bermotor di Tempat Parkir PT Tirta Gemah ripah dengan
ketentuan bahwa:
a. Aplikasi ini dibuat dengan menggunakan Bahasa pemprograman python 3
dan aplikasi pengolah Bahasa pemprogrammannya Pycharm Community.
b. Sistem diproses menggunakan komputer, tidak menggunakan
mikrokomputer seperti arduino atau raspberry.
c. Aplikasi dikhususkan untuk membaca pelat kendaraan yang keluar/masuk
dalam area perusahaan.
d. Resolusi video diambil menggunakan camera dengan resolusi 1280x720
pixel.
e. Pelat kendaraan yang dideteksi adalah pelat kendaraan non modifikasi
dengan font pelat Indonesia.
f. Aplikasi untuk membuat Training Dataset algoritma K-Nearest Neighbor
didapatkan dari internet.
g. Training dataset untuk Haar Cascale Classification berbentuk file .xml
didapatkan dari internet.
h. Data input gambar didapatkan dari lingkungan PT Tirta Gemah Ripah
sebanyak 25 buah dan 100 dari internet.

3
 BAB II TEORI PENUNJANG

2.1. Tinjauan Pustaka

Terdapat proyek akhir, penelitian/skripsi, serta artikel jurnal yang berkenaan
dengan penelitian ini antara lain:
1. Muhammad Syuhada (2015), dalam skripsinya di Fakultas Teknik,
Universitas Lampung melakukan penelitian "Realisasi Pengenalan Pelat
Nomor Kendaraan Dengan Metode Histogram Citra dan Jaringan Syarat
Tiruan Backpropogation".
2. Dendi Triyandi dan John Adler (2014), dalam skripsinya di Teknik
Komputer, Universitas Komputer Indonesia melakukan penelitian "Sistem
Otomatisasi Gerbang Dengan Pengolahan Citra Membaca Nomor Pelat
Kendaraan".
3. Noor Azlin Tauchid, R Rumani, dan Budhi Irawan, S.Si. M.T. (2015),
dalam skripsinya di Teknik Elektro, Universitas Telkom melakukan
penelitian “Analisis Performansi Metode Knn (K-Nearest Neighbor)
Untuk Pengenalan Karakter Pada Plat Nomor Kendaraan Di Raspberry
Pi”.
4. Agus Bahtiar (2016), dalam skripsinya di Teknik Informatika, Sekolah
Tinggi Informatika & Komputer Indonesia Malang melakukan penelitian
“Sistem Deteksi Nomor Polisi Mobil dengan Menggunakan Metode Haar
Classifier dan OCR guna Mempermudah Administrasi Pembayaran
Parkir”.

2.2. Dasar Teori

2.2.1. Pelat Nomor Kendaraan
Pelat nomor kendaraan adalah salah satu jenis identifikasi kendaraan bermotor
yang terbuat dari alumunium yang telah terdaftar di kantor Sistem Administrasi
Manunggal Satu Atap (SAMSAT)[2]. Pelat nomor memiliki nomor seri yaitu
susunan huruf dan angka yang dikhususkan untuk kendaraan tersebut. Pelat

4
nomor atau Tanda Nomor Kendaraan Bermotor (TNKB) mempunyai aturan
pembuatan yang terdiri dari tulisan dua baris, antara lain:
a. Baris pertama menunjukkan: kode wilayah (huruf), nomor polisi (angka), dan
kode/seri akhir wilayah(huruf).
b. Baris kedua menunjukkan bulan dan tahun masa berlaku pelat.

Bahan baku TNKB adalah aluminium dengan ketebalan 1 mm. Ukuran TNKB
untuk kendaraan bermotor roda 2 dan roda 3 adalah 250×105 mm, sedangkan
untuk kendaraan bermotor roda 4 atau lebih adalah 395×135 mm. Korps Lantas
Mabes Polri terhitung mulai April 2011 mengganti desain pelat nomor kendaraan.
Ukurannya lebih panjang 5 sentimeter daripada pelat nomor sebelumnya.[2]

Selain itu, perbedaan lainnya terdapat pada tampilan. Pelat TNKB baru memiliki
lis putih disekeliling pelat. Antara nomor TNKB dengan masa berlaku dak diberi
pembatas lis putih. Namun seperti pelat nomor lama, pada pelat ada dua bariss
yakni baris pertama yang menunjukkan kode wilayah kendaraan, nomor polisi dan
kode seri akhir wilayah. Baris kedua menunjukkan masa berlaku pelat nomor.

Gambar 2.1 Pelat Nomor Kendaraan Indonesia

Ukuran TNKB untuk kendaraan roda 2 dan 3 sekarang menjadi 275 mm dengan
lebar 110 mm, sedangkan untuk kendaraan roda 4 atau lebih adalah panjang 430
mm dengan lebar 135 mm. Sementara ini, pelat resmi yang lama masih berlaku
(apalagi terkadang sejumlah Samsat diberbagai daerah sering memanfaatkan pelat
jenis lama untuk kendaraan yang pelat nomornya diperpanjang setelah tahun
2011). Selain itu, pada spesifikasi teknis baru ini pelat nomor menggunakan rupa

5
huruf (font) yang sama. Gambar 2.1 merupakan contoh terbaru dari pelat
kendaraan bermotor.

2.2.2. Citra Digital (Image)

Citra adalah suatu representasi (gambaran), kemiripan, atau imitasi dari suatu
objek. Citra terbagi 2 yaitu ada citra yang bersifat analog dan ada citra yang
bersifat digital. Citra analog adalah citra yang bersifat kontinu seperti gambar
pada monitor televisi, foto sinar X, hasil CT Scan dll. Sedangkan pada citra digital
adalah citra yang dapat diolah oleh komputer [3]

Sebuah citra digital dapat mewakili oleh sebuah matriks yang terdiri dari M kolom
N baris, dimana perpotongan antara kolom dan baris disebut piksel (piksel =
picture element), yaitu elemen terkecil dari sebuah citra. Piksel mempunyai dua
parameter, yaitu koordinat dan intensitas atau warna. Nilai yang terdapat pada
koordinat (x, y) adalah f(x, y), yaitu besar intensitas atau warna dari piksel di titik
itu [3].Oleh sebab itu, sebuah citra digital dapat ditulis dalam bentuk matriks
berikut.

Berdasarkan gambaran tersebut, secara matematis citra digital dapat dituliskan

sebagai fungsi intensitas f (x,y), dimana harga x (baris) dan y (kolom) merupakan
koordinat posisi dan f(x,y) adalah nilai fungsi pada setiap titik (x,y) yang
menyatakan besar intensitas citra atau tingkat keabuan atau warna dari piksel di
titik tersebut. Pada proses digitalisasi (sampling dan kuantitas) diperoleh besar
baris M dan kolom N hingga citra membentuk matriks M x N dan jumlah tingkat
keabuan piksel G [3].
A. Format Citra
File citra berfungsi untuk menyimpan sebuah citra yang dapat ditampilkan di
layar kedalam suatu media penyimpanan data. Untuk penyimpanan tersebut
digunakan format citra. Setiap format citra memiliki karakteristik masing-masing.

6
Beberapa format umum saat ini, yaitu bitmap (.bmp), tagged image format (.tif,
tiff), portable network graphics (.png), graphics interchange format (.gif), jpeg
(.jpg), mpeg (.mpg), dll [4].
a. Format Citra Bitmap
File format BMP bisa disebut juga bitmap atau format file DIB (untuk perangkat
independen bitmap), adalah sebuah file citra format yang digunakan untuk
menyimpan citra digital bitmap. Meskipun format BMP tidak bagus dari segi
ukuran berkas, namun format BMP memiliki kualitas citra yang lebih baik dari
format JPG maupun GIF. Karena citra dalam format BMP umumnya tidak
dimampatkan atau dikompresi sehingga tidak ada informasi yang hilang.

Gambar 2.2. Gambar Citra BITMAP (.bmp)

(Sumber: google)

b. Format Citra PNG

PNG (Portable Network Graphic) adalah format data berupa citra yang sangat
cocok untuk grafis internet karena mendukung transparansi di dalam browser.
PNG bias disebut sebagai gabungan dari JPG Image dan GIF. Karena sifat
transparansinya itu, PNG cocok untuk screenshot citra. File PNG juga lebih
banyak memiliki gradasi warna dan teknik kompres yang lebih baik dibandingkan
GIF, tetapi ukuran format citra PNG lebih besar dibandingkan tipe lain.

7
 Gambar 2.3. Gambar Citra PNG (.png)
(Sumber: https://www.kisspng.com)

c. Format Citra JPG / JPEG

JPG (Joint Photographic) adalah format data berupa citra yang dikembangkan
oleh
JPEG (Joint Photographic Expert Assemble) yang menggunakan sistem kompres,
yaitu dengan mengurangi bagian-bagian citra untuk memblok pixelnya. JPG
menjadi standar citra internet karena bisa di kompres sehingga ukurannya
diperkecil, tetapi teknik ini justru akan mengakibatkan kualitas citranya menurun
(lossy compression) dan sifatnya permanen (tidak bisa dikembalikan lagi).

Gambar 2.4. Gambar Citra JPG

(Sumber: https://upload.wikimedia.org)

d. Format Citra GIF

GIF (Graphic Interchange Format) adalah format data berupa citra yang sering
digunakan dalam desain web yang mendukung penggunaan multiple-bitmap
sehingga dapat menghasilkan citra animasi bergerak. GIF menggunakan metode

8
lossless compression, yaitu teknik untuk mengurangi ukuran file citra tanpa
merusak kualitas citranya tetapi dapat mengakibatkan degradasi warna. File GIF
hanya cocok untuk citra dengan jumlah warna yang sedikit misalnya animasi
sederhana, banner iklan, header, dan sebagainya.

2.2.3. Pengolahan Citra Digital

Pengolahan citra digital merupakan proses mengolah piksel-piksel di dalam citra
digital untuk tujuan tertentu. Pada awalnya pengolahan citra ini dilakukan untuk
memperbaiki kualitas citra, namun dengan berkembangnya dunia komputasi yang
ditandai dengan semakin meningkatnya kapasitas dan kecepatan proses komputer
serta munculnya ilmu-ilmu komputasi yang memungkinkan manusia dapat
mengambil informasi dari suatu citra.[5]

Proses pengolahan citra secara diagram proses dimulai dari pengambilan citra,
perbaikan kualitas citra, sampai dengan pernyataan representatif citra yang
dicitrakan sebagai berikut:

Gambar 2.5. Proses Pengolahan Citra

Dalam perkembangan lebih lanjut, Image Processing dan Computer Vision
digunakan sebagai mata manusia, dengan perangkat input image capture seperti
kamera dan scanner dijadikan sebagai mata dan mesin komputer (dengan program
komputasinya) dijadikan sebagai otak yang mengolah informasi. Sehingga
muncul beberapa pecahan bidang yang menjadi penting dalam Computer Vision,
antara lain: pattern recognition (pengenalan pola), biometric pengenalan
identifikasi manusia berdasarkan ciri-ciri biologis yang tampak pada badan
manusia), content-based image and video retrieval (mendapatkan kembali citra
atau video dengan informasi tertentu), video editing. [4]

9
Nilai suatu pixel memiliki nilai dalam rentang tertentu, dari nilai minimum sampai
nilai maksimum. Jangkauan yang digunakan berbeda-beda tergantung dari jenis
warna yang digunakan. Secara umum jangkauannya adalah 0-255. Citra dengan
penggambaran seperti ini digolongkan ke dalam citra integer.

A. Konversi Citra ke Grayscale

Dasar dari pengolahan citra adalah pengolahan warna RGB pada posisi tertentu.
Bila membaca citra RGB dengan ukuran tinggi x lebar, akan menghasilkan
matriks tiga dimensi dengan jumlah baris adalah tinggi dan jumlah adalah kolom
sejumlah tiga keping. Citra grayscale atau citra keabuan adalah citra yang hanya
menggunakan warna pada tingkatan warna abu-abu. Warna abu-abu adalah satu-
satunya warna pada ruang RGB dengan komponen merah, hijau, dan biru
mempunyai intensitas yang sama. Pada citra beraras keabuan hanya perlu
menyatakan nilai intensitas untuk tiap piksel sebagai nilai tunggal, sedangkan
pada citra berwarna perlu tiga nilai intensitas untuk setiap pikselnya. Berbeda
dengan citra biner, citra grayscale disebut juga dengan citra 8-bit karena memiliki
28(256) kemungkinan nilai pada masing-masing pikselnya. Nilai tersebut dimulai
dari nol untuk warna hitam dan 255 untuk warna putih.[6]

Wijaya dan Tjiharjadi menjelaskan Proses awal yang sering dilakukan pada
Image Processing adalah mengubah citra berwarna menjadi citra grayscale. Hal
ini dilakukan untuk menyederhanakan model citra. Di dalam suatu gambar true
color (RGB) terdapat tiga layer matriks, yaitu R-layer, G- layer, dan B-layer. Pada
Image Processing dilakukan proses-proses terhadap ketiga layer tersebut, berarti
dilakukan perhitungan yang sama pada setiap layer. Dengan demikian konsep
grayscale adalah mengubah tiga layer tersebut menjadi satu layer matriks
grayscale, yang menghasilkan satu citra grayscale.

Dalam melakukan konversi citra dengan mengubah nilai piksel yang semula
mempunyai 3 nilai yaitu R, G, B menjadi satu nilai keabuan atau biner. Untuk
operasi konversi citra digunakan persamaan berikut:

10
 R+G+B
k O=
3
Bisa juga dengan memberi bobot (w) pada RGB dikarenakan mata manusia lebih
sensitif pada warna hijau, merah dan biru. Operasi tersebut dapat digunakan
persamaan sebagai berikut [6]:
k 0=w r R i+ wg G i+ wb Bi
Di mana:
Ko: nilai keabuan pada pixel ke 0
wr: bobot untuk elemen warna merah
wg: bobot untuk elemen warna hijau wb: bobot untuk elemen warna biru
Ri: nilai intensitas elemen warna merah
Bi: nilai intensitas elemen warna biru
Gi: nilai intensitas elemen warna hijau

B. Memaksimalkan Kontras
Kontras adalah tingkat penyebaran piksel-piksel kedalam intensitas warna. Ada 3
macam kontras, yaitu Rendah, Tinggi dan Normal. [7]
a. Rendah, citra yang memiliki kontras rendah dapat terjadi karena kurangnya
pencahayaan, citra ini memiliki kurva histogram yang sempit (tingkat
penyebaran warna tidak sampai ke hitam pekat dan putih terang).

Gambar 2.6. Kontras Rendah

b. Tinggi, Kurva histogram terlalu besar, sebaran intensitas terang dan gelap
merata keseluruh skala intensitas.

11
 Gambar 2.7. Kontras Tinggi
c. Normal, Kurva histogram tidak terlalu besar dan tidak sempit.

 
Gambar 2.8. Kontras Normal
Ada beberapa cara untuk melakukan perhitungan kontras, namun yang saya
tampilkan sekarang adalah dengan rumus berikut:
f 0 ( x , y )=G ( fi ( x , y ) −P ) + P

Dimana:
G= koefisien penguatan kontras
P= Nilai grayscale yang dipakai sebagai pusat pengkontrasan
Contoh perhitungan:

12
 Gambar 2.9. Contoh Perhitungan Kontras

C. Konversi Citra ke Threshold

Dalam banyak aplikasi penglihatan, akan berguna untuk dapat memisahkan
wilayah gambar yang sesuai dengan objek yang kita minati, dari wilayah gambar
yang sesuai dengan latar belakang. Ambang batas sering memberikan cara yang
mudah dan nyaman untuk melakukan segmentasi ini berdasarkan intensitas atau
warna yang berbeda di latar depan dan latar belakang suatu gambar. Selain itu,
sering kali berguna untuk dapat melihat area gambar mana yang terdiri dari piksel
yang nilainya berada dalam rentang tertentu, atau pita intensitas (atau warna).
Ambang batas dapat digunakan untuk ini juga.[8]

Gambar 2.10. Contoh Thresholding

Input untuk operasi thresholding biasanya berupa skala abu-abu atau gambar
berwarna. Dalam implementasi paling sederhana, output adalah gambar biner
yang mewakili segmentasi. Piksel hitam sesuai dengan latar belakang dan piksel
putih sesuai dengan latar depan (atau sebaliknya). Dalam implementasi sederhana,

13
segmentasi ditentukan oleh parameter tunggal yang dikenal sebagai ambang
intensitas. Dalam satu lintasan, setiap piksel dalam gambar dibandingkan dengan
ambang ini. Jika intensitas piksel lebih tinggi dari ambang, piksel diatur ke,
katakanlah, putih pada output. Jika kurang dari ambang, itu diatur ke hitam.

Dalam implementasi yang lebih canggih, beberapa ambang batas dapat

ditentukan, sehingga band nilai intensitas dapat diatur ke putih sementara yang
lainnya diatur ke hitam. Untuk gambar warna atau multi-spektral, dimungkinkan
untuk menetapkan ambang yang berbeda untuk setiap saluran warna, dan
karenanya pilih hanya piksel-piksel tersebut dalam kuboid yang ditentukan dalam
ruang RGB. Varian umum lainnya adalah untuk mengatur agar hitam semua
piksel yang sesuai dengan latar belakang, tetapi biarkan piksel latar depan pada
warna / intensitas aslinya (sebagai lawan dari memaksa mereka menjadi putih),
sehingga informasi tersebut tidak hilang.[8]

D. Blur (Gaussian Filter)

Gaussian Blur adalah Filter blur yang menempatkan warna transisi yang
signifikan dalam sebuah image, kemudian membuat warna-warna pertengahan
untuk menciptakan efek lembut pada sisi-sisi sebuah image. Gaussian blur adalah
salah satu filter blur yang menggunakan rumus matematika untuk menciptakan
efek autofocus untuk mengurangi detail dan menciptakan efek berkabut. Gaussian
adalah istilah matematika yang diambil dari nama seorang matematikawan
Jerman, Karl Friedrich Gauss. [9]

Untuk menghitung atau menentukan nilai-nilai setiap elemen dalam filter gaussian
yang akan dibentuk berlaku persamaan berikut :
h(x , y ) x 2+ y 2
=ⅇ
c 2 σ2
σ = Lebar dari fungsi gaussian
c = konstanta normalisasi
g (x, y)= citra hasil konvolusi

14
2.2.4. Video
Video adalah teknologi untuk menangkap, merekam, memproses,
mentransmisikan dan menata ulang gambar bergerak. Biasanya nenggunakan film
seluloid, sinyal elektronik atau media digital. Video Digital adalah berkas
computer yang digunakan untuk menyimpan kumpulan berkas digital seperti
video, audio, metadata, informasi, pembagian chapter, dan judul sekaligus, yang
dapat dimainkan atau digunakan melalui perangkat lunak tertentu pada komputer.
[10]

Video Digital terdiri dari urutan frame. Jika frame yang ditampilkan pada layar
cukup cepat, maka akan mendapatkan kesan gambar yang bergerak. Alasannya
adalah mata manusia tidak dapat membedakan frame-frame yang bergerak dengan
sangat cepat sebagai frame-frame yang terpisah. Belum ada jumlah standar frame
per detik; di Amerika Utara jumlah frame yang umum adalah 25 frame per detik.
Namun, untuk menghindari kondisi yang dikenal sebagai berkedip, frame perlu di
refresh. Sebuah video digital terdiri dari frame-frame yang mana frame-frame
tersebut dikompres menjadi sebuah file komputer yang hanya dapat dijalankan
menggunakan sebuah perangkat lunak multimedia player.

2.2.5. Optical Character Recognition (OCR)

Optical character recognition (OCR) adalah sebuah sistem komputer yang dapat
membaca huruf, baik yang berasal dari sebuah pencetak (printer atau mesin ketik)
maupun yang berasal dari tulisan tangan. OCR adalah aplikasi yang
menerjemahkan gambar karakter (image character) menjadi bentuk teks dengan
cara menyesuaikan pola karakter per baris dengan pola yang telah tersimpan
dalam aplikasi. Hasil dari proses OCR adalah berupa teks sesuai dengan gambar
output scanner di mana tingkat keakuratan penerjemahan karakter tergantung dari
tingkat kejelasan gambar dan metode yang digunakan.

15
Secara umum blok diagram kerja OCR dapat dilihat pada Gambar 2.6 berikut.

Gambar 2.11. Blok Diagram Kerja OCR (Trilaksono, 2008).

OCR dapat dipandang sebagai bagian dari pengenal otomatis yang lebih luas
yakni pengenal pola otomatis (automatic pattern recognition). Dalam pengenal
pola otomatis, sistem pengenal pola mencoba mengenali apakah citra masukan
yang diterima cocok dengan salah satu citra yang telah ditentukan. Sistem ini
misalnya dipakai untuk mendeteksi sidik jari, tanda tangan, bahkan wajah
seseorang. Ada banyak pendekatan yang dapat dipakai untuk mengembangkan
pembuatan pola otomatis antara lain memakai pendekatan numerik, statistik,
neural dan, aturan produksi (rule-based).[11]

Secara umum metode-metode tersebut dapat digolongkan menjadi dua kelompok

metode yakni metode berbasis statistik dan metode berbasis struktur. Dalam
metode yang berbasis statistik, setiap pola ditransformasi ke dalam vektor yang
memakai ukuran dan karakteristik tertentu. Karakteristik ini seringkali lebih
bersifat statistik misalnya distribusi pixel ataupun jarak pixel. Sedang dalam
metode yang berbasis struktur, setiap pola yang diproses dinyatakan sebagai
gabungan beberapa struktur elementer. Pengenalan selanjutnya dilakukan dengan

16
mencocokkan komposisi struktur elementer dengan struktur yang sudah disimpan
memakai aturan tertentu misalnya memakai pendekatan teori bahasa formal dan
automata.[12]

2.2.6. Open CV (Computer Vision)

OpenCV (Open Computer Vision) adalah sebuah API (Application Programming
Interface) library yang sudah sangat familiar pada pengolahan citra Computer
Vision. Computer Vision itu sendiri adalah salah satu cabang dari bidang ilmu
pengolahan citra (Image Processing) yang memungkinkan computer dapat
melihat seperti manusia. Dengan Computer Vision tersebut komputer dapat
mengambil keputusan, melakukan aksi, dan mengenali terhadap suatu objek.
Beberapa pengimplementasian dari Computer Vision adalah face recognition, face
detection, face/pbject tracking, road tracking, dll. OpenCV adalah library open
source untukComputer Vision untuk C/C++, OpenCV didesain untuk aplikasi real-
time, memiliki fungsi-fungsi akuisisi yang baik untuk gambar/video. OpenCV
juga menyediakan interface ke Integrated Performance Primitives (IPP) Intel
sehingga jika anda bisa mengoptimasi aplikasi Computer Vision anda jika
menggunakan prosesor Intel. [13]
Fitur yang dimiliki OpenCV antara lain:
a. Manipulasi data citra (alocation, copying, setting, convert).
b. Citra dan video I/O (file dan kamera based input, image/video file output).
c. Manipulasi Matriks dan Vektor beserta rutin-rutin aljabar linear (products,
solvers, eigenvalues, SVD).
d. Data struktur dinamis (lists, queues, sets, trees, graphs).
e. Pemroses citra fundamental (filtering, edge detection, corner detection,
sampling and interpolation, color conversion, morphological operations,
histograms, image pyramids).
f. Analisis struktur (connected components, contour processing, distance
transform, various moments, template matching, hough transform, polygonal
approximation, line fitting, ellipse fitting, delaunay triangulation).

17
g. Kalibrasi kamera (calibration patterns, estimasi fundamental matrix, estimasi
homography, stereo correspondence).
h. Analisis gerakan (optical flow, segmentation, tracking).
i. Pengenalan obyek (eigen-methods, HMM).

2.2.7. Haar-Like Feature

Secara umum, Haar-Like Feature atau yang dikenal sebagai Haar Cascade
Classifier digunakan dalam mendeteksi objek pada image digital. Nama Haar
merujuk pada suatu fungsi matematika (Haar Wavelet) yang berbentuk kotak,
prinsipnya sama seperti pada fungsi Fourier. Awalnya pengolahan gambar hanya
dengan melihat dari nilai RGB setiap pixel, namun metoda ini ternyata tidaklah
efektif. Viola dan Jones kemudian mengembangkannya sehingga terbentuk Haar-
like feature.

Haar-Like Feature merupakan rectangular features (fungsi persegi), yang

memberikan indikasi secara spesifik pada sebuah gambar atau image. Prinsip
Haar-Like Feature adalah mengenali objek berdasarkan nilai sederhana dari fitur
tetapi bukan merupakan nilai pixel dari image objek tersebut. Metode ini memiliki
kelebihan yaitu komputasinya sangat cepat, karena hanya bergantung pada jumlah
pixel dalam persegi bukan setiap nilai pixel dari sebuah image.[14]

Haar-Like Feature memproses gambar dalam kotak-kotak dengan ukuran

tertentu, dimana dalam satu kotak terdapat beberapa pixel. Per kotak itu pun
kemudian di-proses dan didapatkan perbedaan nilai (threshold) yang menandakan
daerah gelap dan terang. Sehinggan metode ini memerlukan Training dataset
yang berupa gambar berikut:

18
 Gambar 2.12. Haar-Like Feature
Tiga tipe kotak fitur:
a. Tipe two-rectangle feature
b. Tipe three-rectangle feature
c. Tipe four-rectangel feature
Pada gambar 2.7 terdapat 3 tipe kotak, dimana tipe pertama adalah tworectangle
feature yang terdiri dari 2 persegi, tipe kedua adalah three-rectangle feature yang
terdiri dari 3 persegi dimana bagian tengah terdapat persegi berwarna hitam dan
tipe yang terakhir four-rectangle feature yang terdiri dari 2 persegi dengan persegi
berwarna hitam terdapat di dalam persegi putih. Tiap kotak-kotak digambar 2.7
mempunya nilai masing-masing yang diberi nama nilai Haar-Like Feature, yaitu
perbedaan antara jumlah nilai-nilai pixel gray level dalam daerah kotak hitam dan
daerah kotak putih. Nilai Haar-Like Feature diperoleh dari selisih jumlah nilai
piksel daerah gelap dengan jumlah nilai piksel daerah terang:

Kotak rectangular Haar-Like Feature dapat dihitung secara cepat dengan

menggunakan Integral Image. Lalu untuk gambar bergerak (video), perhitungan

19
dan penjumlahan pixel terjadi secara terus menerus dan membutuhkan waktu yang
lama. Oleh karena itu, penjumlahan diganti dengan integral sehingga didapatkan
hasil lebih cepat. Hasil deteksi dari Haar-Like kurang akurat jika hanya
menggunakan satu fungsi saja sehingga biasanya digunakan beberapa fungsi
sekaligus. Semakin banyak fungsi yang digunakan maka hasilnya akan semakin
akurat. Pemrosesan Haar-Like feature yang banyak tersebut diorganisir atau diatur
di dalam classifier cascade. [15]

2.2.8. Haar Classifier

Dari metode Haar-Like Feature dapat disebut sebagai metode yaitu meode Haar
Classifier yaitu metode object detection yang membangun sebuah boosted
rejection cascade, yang akan membuang Training dataset negatif sehingga didapat
suatu keputusan untuk menentukan data positif.
Haar Classifier merupakan metode supervised learning, yaitu membutuhkan data
trainning untuk dapat mendeteksi objek-objek tertentu. Untuk itu Haar Classifier
membutuhkan data postif (objek yang akan di deteksi) dan data negatif (bukan
object yang di deteksi).[16]

Gambar 2.13. Perbedaan Supervised, Unsupervised dan Semi Supervised

Supervised:
 input data (training set) memiliki label
 belajar berdasarkan contoh
Unsupervised:
 input data tidak memiliki label
 belajar bedasarkan struktur data

20
Semi-unsupervised:
 input data terdiri dari data berlabel dan tidak
 belajar bedasarkan contoh dan struktur data
Metode ini memerlukan 2 tipe gambar objek dalam proses training yang
dilakukan [17], yaitu:
1. Positive Samples
Berisi gambar objek yang ingin di deteksi, apabila ingin mendeteksi mata maka
positive samples ini berisi gambar mata, begitu juga objek lain yang ingin
dikenali.
2. Negative samples
Berisi gambar objek selain objek yang ingin dikenali, umumnya berupa gambar
background (tembok, pemandangan, lantai, dan gambar lainnya). Resolusi untuk
sampel negatif disarankan untuk memiliki resolusi yang sama dengan resolusi
kamera.
Training dari Haar menggunakan dua tipe sampel diatas. Informasi dari hasil
training ini lalu dikonversi menjadi sebuah parameter model statistik.

Sistem Kerja Algoritma Haar Cascade Classifier.

Algoritma Haar menggunakan metode statistical dalam melakukan pendeteksian
pelat. Metode ini menggunakan sample haarlike fetures. Classifier ini
menggunakan gambar berukuran tetap (umumnya berukuran 24x24). Cara kerja
dari haar dalam mendeteksi pelat adalah dengan menggunakan teknik sliding
window berukuran 24x24 pada keseluruhan gambar dan mencari apakah terdapat
bagian dari gambar yang berbentuk seperti pelat atau tidak. Haar juga memiliki
kemampuan untuk melakukan scaling sehingga dapat mendeteksi adanya pelat
yang berukuran lebih besar ataupun lebih kecil dari ganbar pada classifier [17].
Tiap feature dari haar-like feature didefinisikan pada bentuk dari feature,
diantaranya koordinat dari feature dan juga ukuran dari feature tersebut.

21
2.2.9. Cascade Classifier
Cascade classifier adalah sebuah rantai stage classifier, dimana setiap stage
classifier digunakan untuk mendeteksi apakah di dalam image sub-window
terdapat objek yang diinginkan (object of interest). Untuk mendapatkan nilai
cascade, perlu dilakukan training cascade. Classifier dengan banyak fitur akan
mendapat tingkat pendeteksian yang lebih tinggi serta error yang dibutuhkan
untuk penghitungannya [16]. Adapun atribu-atribut yang perlu diubah dan dicari
nilai optimalnya adalah sebagai berikut:
a. Jumlah stage,
b. Jumlah feature, dan
c. Nilai threshold.
Tiap stage mengurangi tingkat false positif serta meningkatkan tingkat
pendeteksian. Sedangkan jumlah stage akan terus ditambahkan hingga target
pendeteksian dan tingkat false positifnya ditemukan.

Gambar 2.14. Model Cascade Classifier

Pada gambar diatas, dapat kita lihat bahwa tiap sub-window yang bernilai negatif
(bukan objek yang dicari) akan langsung disisihkan dan secara otomatis tidak
akan melanjutkan proses pencarian pada sub-window tersebut. sedangkan untuk
sub-window image yang bernilai positif akan selalu dicek lagi dan lagi pada stage
berikutnya hingga ditemukan objek yang dimaksud.[16]

22
2.2.10. Gaussian Noise
Gaussian Noise merupakan titik-titik berwarna pada citra yang jumahnya sama
dengan persentase noise. Noise Gaussian dapat dibangkitkan dengan cara
membangkitkan bilangan acak [0,1]. [18] Kemudian titik-titik yang terkena noise,
nilai fungsi citra ditambahkan dengan noise yang ada atau dapat dirumuskan
sebagai berikut.
f (i, j)=g( i, j)+ p . a

Keterangan:
a = nilai bilangan acak berdistribusi gaussian
p = presentase noise
f(i,j) = nilai citra terkena noise
g(i,j) = nilai citra sebelum terkena noise

Untuk mengenali bagaimana jenis noise gaussian maka Gambar 2.3 berikut ini
adalah contoh gambar yang terkena Noise Gausssian.

Gambar 2.15. Citra yang terkena Gaussian Noise

2.2.11. Contour
Kontur (Contours) dapat dijelaskan secara simple seperti lengkungan yang
menggabungkan point-point yang berkelanjutan (disepanjang batas), yang

23
memilik warna dan intensitas yang sama. Kontur merupakan alat yang sangat
berguna untuk melakukan analisa bentuk, pendeteksi dan pengenalan objek.[19]
 Untuk meningkatkan akurasi, gunakan gambar binary. Jadi sebelum mencari
kontur, gunakan fungsi threshold atau canny edge detection.
 Fungsi findContours merubah gambar dari sumber. Jadi apabila pengguna
ingin gambar sumber tetap sama setelah mencari kontur, simpan gambar
dengan variable lain.
 Dalam OpenCV, mencari kontur itu seperti mencari objek warna putih dalam
background hitam. Jadi jangan lupa bahwa objek yang akan dicari harusnya
berwarna putih dan background berwarna hitam.

Gambar 2.16. Penerapan Contour

2.2.12. K-Nearest Neighbor

Algoritma k-nearest neighbor (KNN) adalah sebuah metode untuk melakukan
klasifikasi terhadap objek berdasarkan data pembelajaran yang jaraknya paling
dekat dengan objek tersebut. KNN termasuk algoritma supervised learning
dimana hasil dari query instance yang baru diklasifikan berdasarkan mayoritas
dari kategori pada KNN.[20] Kelas yang paling banyak muncul yang akan
menjadi kelas hasil klasifikasi. Tujuan dari algoritma ini adalah
mengklasifikasikan obyek baru bedasarkan atribut dan training sample. Classifier
tidak menggunakan model apapun untuk dicocokkan dan hanya berdasarkan pada
memori. Diberikan titik query, akan ditemukan sejumlah k obyek atau (titik
training) yang paling dekat dengan titik query. Klasifikasi menggunakan voting
terbanyak diantara klasifikasi dari k obyek. algoritma k-nearest neighbor (KNN)

24
menggunakan klasifikasi ketetanggaan sebagai nilai prediksi dari query instance
yang baru.

Algoritma metode K-Nearest Neighbor (KNN) sangatlah sederhana, bekerja

berdasarkan jarak terpendek dari query instance ke training sample untuk
menentukan KNN-nya. Training sample diproyeksikan ke ruang berdimensi
banyak, dimana masing-masing dimensi merepresentasikan fitur dari data. Ruang
ini dibagi menjadi bagian-bagian berdasarkan klasifikasi training sample. Sebuah
titik pada ruang ini ditandai kelas c jika kelas c merupakan klasifikasi yang paling
banyak ditemui pada k buah tetangga terdekat dari titik tersebut. [21]

Nilai k yang terbaik untuk algoritma ini tergantung pada data. Secara umum, nilai
k yang tinggi akan mengurangi efek noise pada klasifikasi, tetapi membuat
batasan antara setiap klasifikasi menjadi semakin kabur. Nilai k yang bagus dapat
dipilih dengan optimasi parameter, misalnya dengan menggunakan cross-
validation. Kasus khusus dimana klasifikasi diprediksikan berdasarkan training
data yang paling dekat (dengan kata lain, k = 1) disebut algoritma nearest
neighbor.

Ketepatan algoritma KNN sangat dipengaruhi oleh ada atau tidaknya fitur-fitur
yang tidak relevan atau jika bobot fitur tersebut tidak setara dengan relevansinya
terhadap klasifikasi. Riset terhadap algoritma ini sebagian besar membahas
bagaimana memilih dan memberi bobot terhadap fitur agar performa klasifikasi
menjadi lebih baik.[21]

Langkah-langkah untuk menghitung metode K-Nearest Neighbor:

a. Menentukan parameter K (jumlah tetangga paling dekat).
b. Menghitung kuadrat jarak (query instance) masing-masing obyek terhadap
data sampel yang diberikan.
c. Kemudian mengurutkan objek-objek tersebut kedalam kelompok yang
mempunyai jarak terkecil.

25
d. Mengumpulkan kategori Y (Klasifikasi nearestneighbor)
e. Dengan menggunakan kategori nearest neighbor yang paling mayoritas maka
dapat dipredisikan nilai query instance yang telah dihitung.

26
 BAB III METODE PENELITIAN

3.1. Analisis Sistem

3.1.1. Analisis Kebutuhan Perangkat Keras (Hardware)
Untuk membuat aplikasi pendeteksi pelat kendaraan di PT Tirta Gemah Ripah ini
dibutuhkan beberapa peralatan yang akan menunjang dalam pembuatan aplikasi,
yaitu:
1. Laptop/Komputer
Laptop yang digunakan merupakan ASUS ZenBook UX303U dengan spesifikasi
Processor Intel Core i7-6500U CPU@2.50 GHz (4 CPUs), memory 8192 MB
RAM, VGA Nvidia GeForce 940M, dan sistem operasi Windows 10 64bit.
2. Kamera
Kamera Canon EOS M2 Mirrorless dengan tipe camera compact beresolusi 18
MP yang memeliki tipe sensor CMOS, ukuran layar 3 inch, maksimum resolusi
video sebesar 1980 x 1080 pixel dengan format MOV atau mp4, memory card
support dan frame rate sebesar 30 fps.

3.1.2. Analisis Kebutuhan Perangkat Lunak (Software)

Perangkat yang dibutuhkan untuk membangun aplikasi yang memiliki
kemampuan untuk memproses citra digital, yaitu:
1. Sistem operasi windows 10 64bit
2. Anaconda Python 3
3. Spyder 3.3.5
4. PyCharm Community
5. Paint

27
3.2. Prosedur Penelitian
Tahapan pada penelitian ini sebagaimana ditunjukan pada gambar 3.1.

Mulai A

Pengumpulan Data Analisa Kinerja

dan Studi Literatur Sistem

Buku, Jurnal, Tugas Data Akurasi

Akhir, Data Video Pembacaan
dan Data Gambar Karakter
Sistem

Desain dan
Pembuatan Laporan
Perancangan Sistem

Laporan Tugas Akhir

Aplikasi OCR

A Selesai

Gambar 3.1. Diagram Alir (Flowchart) Tahapan Penelitian

Tahapan secara detail akan dijelaskan sebagai berikut.
3.2.1. Waktu dan Lokasi Penelitian
Waktu penelitian dilakukan selama empat bulan, dimulai sejak disetujuinya
proposal penelitian ini pada bulan April 2019 hingga pelaporan hasil penelitian
pada akhir bulan Juli 2019. Pengambilan data video merupakan tahapan awal di
mana pengambilan data video kendaraan pada lokasi yang telah ditetapkan. Video
yang telah diambil akan digunakan sebagai data uji pada sistem yang akan dibuat.
Pengambilan data video dilakukan di area masuk gerbang PT Tirta Gemah Ripah.

28
 Gambar 3.2. Area Pengambilan data
Waktu pengambilan data dilakukan pada jam masuk kerja yaitu pagi hari dengan
rentang waktu mulai pukul 07.30 sampai pukul 09.00 dan jam pulang kerja yaitu
sore hari dengan rentang waktu mulai pukul 17.00 sampai pukul 18.00. data yang
dikumpulkan akan digunakan untuk pengujian dari sistem yang dibuat.

3.2.2. Teknik Pengambilan Data

Pengambilan data dilakukan dengan menggunakan tangga, tripod kamera ataupun
bangku sebagai penyangga untuk mendapatkan data dengan posisi kamera
setinggi 1,5-meter dengan sudut 90 derajat. Sudut ini diambil berdasarkan
observasi lapangan yang telah dilakukan dalam area pintu masuk Perusahaan.
Sistem akan mendeteksi objek berupa pelat nomor dan karakter pada gambar
objek dideteksi oleh OCR dalam setiap frame video. Dikarenakan kendaraan yang
terdapat diperusahaan hanya sedikit yaitu 25 kendaraan, maka penulis
menambahkan 100 data tambahan berupa gambar dari internet.

29
3.2.3. Desain dan Perancangan Sistem

Akuisisi Data

Deteksi Pelat

Preprocessing

Deteksi Karakter

OCR dengan
K-Nearest Neighbor

Penyamaan Hasil
Text dengan
Database

Hasil

Gambar 3.3. Diagram Blok Sistem Keseluruhan

Input dari sistem merupakan data berbentuk video yang didapatkan dari camera
dan frame video akan dijadiin gambar mentah untuk system. Setelah proses
pengambilan data, data tersebut akan dibaca oleh sistem dalam bentuk frame-
frame yang telah diekstraksi yang selanjutnya akan diimplementasikan pada
metode yang diterapkan. Terdapat 3 algoritma khusus yang digunakan dengan
fungsi yang berbeda dalam sistem seperti algoritma haar cascade classification,
gaussian filter dan K-Nearest Neighbor menggunakan bahasa pemprograman
python 3. Metode Haar Cascade Classifier berfungsi untuk mencari kandidat
pelat nomor pada seluruh gambar, Gaussian Filter berfungsi untuk menghapus
objek kecil yang menggangu pada gambar (noise) dan metode K-Nearest
Neighbor berfungsi untuk sebagai OCR atau recognisi karakter huruf pada setiap
pelat.

30
Dengan illustrasi system seperti berikut :

Text

Camera

Database
Gambar
Mentah Sistem OCR Pengguna
Kendaraan

Komputer Proses Komputerisasi

Gambar 3.4. Illustrasi Sistem Keseluruhan

31
Berikut diagram perancangan sistem yang digunakan:

Mulai A B C

Video
Preprocessing Hasil text Error Message
Masukan

Gambar
Pelat Nomer
Inisiasi Frame Membaca Database
dengan
Contour

Apakah data p elat

Gambar RAW Deteksi Karakter terd ap at pada
database?

Ya

Deteksi Region of Apakah terdapat Identitas

Interest Pelat Nomer Tidak karakter pada Pengguna Tidak
gambar?
dengan Haar Kendaraan
Cascade Classifier
C
Ya

Daftar
Penyimpanan Log
Karakter
Apakah Pelat N omer Pelat yang
C Tidak yang
tedeteksi? Terdeteksi
tedeteksi

Selesai
Pengenalan Karakter
Gambar (OCR)
Pelat Nomer

B
A

Gambar 3.5. Diagram Alir (Flowchart) Perancangan Sistem

32
A. Video Masukan
Proses input merupakan langkah awal dan utama dalam percangan sistem. Berikut
spesifikasi video yang akan digunakan:
Resolusi : 1280 x 720 Pixel (720p)
Laju Frame (framerate) : 30 fps
Durasi : 1 – 5 menit (selama ada kendaraan dalam
video)
Video masukan sistem merupakan hasil pengambilan video dengan menggunakan
kamera statis yang disimpan dengan format file video .MOV resolusi 1280x720
dengan jenis RGB. Video yang telah diambil akan ditampilkan menggunakan fitur
video capture dari OpenCV namun apabila terjadi error, sistem akan mengirimkan
error message pada user. Video yang telah terbaca akan ditampilkan dan siap
untuk dijalankan seperti gambar 3.8.

Gambar 3.6. Tampilan Video Masukan

E. Training Dataset K-Nearest Neighbor

Training Dataset merupakan data sample yang akan digunakan untuk
menyamakan model output (objek). Training dataset merupakan kumpulan
gambar dari berbagai variasi karakter yang akan digunakan dalam sistem
OCR. Gambar yang digunakan dalam training data set merupakan 50 dari
100 gambar yang diambil di internet dengan rincian total karakter 521 yang
memiliki jumlah setiap karakter berbeda-beda.

33
 Gambar ouput akan disamakan dengan Training Dataset menggunakan algoritma
K-Nearest Neighbor dengan rincian sebagai berikut :
Tabel 3.1. Training Dataset Karakter 0-H
Karakte Gambar Jumlah Karakte Gambar Jumlah
r r
0 24 9 20

1 24 A 16

2 24 B 24

3 24 C 10

4 24 D 16

5 24 E 9

6 24 F 12

7 13 G 11

8 24 H 10

34
 Tabel 3.1. Training Dataset Karakter I-Z
Karakte Gambar Jumlah Karakte Gambar Jumlah
r r
I 17 R 8

J 9 S 10

K 10 T 9

L 9 U 9

M 9 V 9

N 12 W 13

O 20 X 6

P 16 Y 10

Q 6 Z 6

35
F. Deteksi Pelat Kendaraan

Mulai A

Gambar Gambar
Angka dan dengan
Huruf Font tanda pelat
Pelat berbentuk
Indonesia persegi

Pembuatan Data Pemotongan

Training Gambar Pelat

Data Training
berbentuk Gambar
.xml Pelat

Deteksi Region Of
RAW Image Selesai
Interest

Gambar 3.7. Diagram Alir (Flowchart) Proses Deteksi Pelat Kendaraan

Untuk menjalankan sebuah video, diperukan kode untuk menginisiasi setiap frame
yang ada dalam video. Hasil output dari inisiasi frame merupakan gambar raw
yang siap diolah oleh sistem. Video yang ditampilkan akan memiliki kotak merah
pada setiap framenya yang menandakan bahwa adanya potensi pelat pada frame
tersebut yang didefinisikan oleh Region Of Interest (ROI) yang dalam
pendeteksiannya menggunakan metode cascade classification dan haar classifier.
Algroritma haar feature-based clascade classifier yang digunakan untuk
mendeteksi objek adalah detect multiscale. DetectMultiScale berfungsi untuk
mendeteksi objek yang memiliki ukuran yang berbeda dengan data yang telah

36
ditraining dalam classifier. Objek yang terdeteksi akan ditampilkan dalam
beberapa persegi dalam gambar. Dalam melakukan proses deteksi, ada beberapa
tahapan yang harus dilakukan untuk mendapatkan gambar yang hanya berisi
gambar pelat nomor.

a. Training dan Membaca Data Classifier

Sebelum melakukan proses mendeteksi wilayah pelat dengan cascade classifier¸
sistem memerlukan data pembanding untuk mencari pelat agar sistem tidak
meleset dalam pemotongan gambarnya. Masukan training data classfier yang
berbentuk file .xml, data tersebut akan menjadi pembanding untuk semua gambar
yang memiliki ciri-ciri yang sesuai.

b. Deteksi Region Of Interest

Deteksi Region Of Interest (ROI) merupakan proses dimana pelat nomor
terdeteksi dari sekian banyak object pada gambar dengan menggunakan fungsi
detect multiscale yang tedapat pada OpenCV. Terdapat beberapa parameter yang
digunakan dalam algoritma tersebut antara lain scalefactor, minNeighbor, dan
minSize. scaleFactor merupakan parameter yang menentukan seberapa banyak
gambar akan diperkecil setiap perskala gambar. minNeighbor merupakan
parameter yang menentukan sebarapa banyak tetangga pada setiap persegi dalam
penyimpanannya. minSize merupakan parameter yang menetapkan ukuran
minimum pada objek yang akan dideteksi, objek dengan ukuran dibawah value
akan diabaikan.

c. Pemotongan Gambar
Setelah region of interest (ROI) gambar telah ditemukan, maka akan
dicrop/dipotong objeknya saja untuk mempercepat dan meningkatkan akurasi
dalam pembacaan angka pada pelat. Apabila pelat tidak dicrop, sistem akan
membaca seluruh gambar dan hasil output akan banyak yang tidak sesuai. Metode
pemotongan pelat yang digunakan adalah numpy arrays (slicing). Numpy Arrays
(Slicing) merupakan metode pemotongan berdasarkan data array yang terdapat

37
pada objek, objek dalam sistem ini ialah kotak merah hasil Region of Interest
(ROI).

Gambar 3.8. Hasil pemotongan gambar

G. Preprocessing
Preprocessing memiliki beberapa tahapan dalam pengolahan gambarnya untuk
mencari output berupa gambar grayscale dan gambar yang telah dithresholding
yang diperlukan untuk proses K-Nearest Neighbor.

38
 Mulai A B

Gambar
Grayscale Gambar yang
Gambar
dengan telah di
Pelat
Maksimum Threshold
Kontras

Perubahan warna Selesai

Mengaburkan
RGB pelat menjadi
Gambar (Bluring)
grayscale

Gambar Blurred
Pelat Gambar
Grayscale Pelat

Memaksimalkan Memisahkan Objek

kontras dengan background

A B

Gambar 3.9. Diagram Alir (Flowchart) Preprocessing

Berikut adalah beberapa tahapan yang harus dilakukan dalam proses pre-
processing:
a. Konversi gambar pelat nomor ke gambar grayscale. Dalam tahap ini citra
input berwarna dalam RGB diubah menjadi citra grayscale. Tujuan dari tahap
ini adalah untuk mereduksi ukuran data. Dalam metode ini data yang akan
digunakan dalam proses pengenalan adalah intensitas cahaya dari sebuah citra
sehingga kombinasi warna Red, Green, dan Blue tidak dibutuhkan.

39
 Gambar 3.10. Hasil Konversi Gambar RGB ke Grayscale
b. Meningkatkan kontras pada gambar grayscale. Kontras yang rendah dapat
menyebabkan hasil OCR yang buruk. Tingkat kontras dan kepadatan gambar
harus ditingkatkan sebelum melakukan proses OCR. Hal tersebut dapat
membuat text dan backgroundnya terlihat lebih jelas dalam gambar output.

Gambar 3.11. Hasil Meningkatkan Kontras

c. Menghilangkan noise gambar dengan mengaburkan (blur) gambar. Metode

pengaburan (blur) yang digunakan yaitu gausianblur. Dengan gausianblur,
wilayah yang akan dikaburkan hanya wilayah pinggir dari gambar dan noise-
noise pada gambar akan dikaburkan seperti background.

40
 Gambar 3.12. Hasil Blur

d. Thresholding merupakan salah satu metode segmentasi citra di mana

prosesnya didasarkan pada perbedaan derajat keabuan citra untuk memisahkan
antara objek dan background. Dalam proses ini dibutuhkan suatu nilai batas
yang disebut dengan nilai threshold. Nilai intensitas citra yang lebih dari atau
sama dengan nilai threshold akan diubah menjadi 1 (berwarna putih)
sedangkan nilai intensitas citra yang kurang dari nilai threshold akan diubah
menjadi 0 (berwana hitam). Sehingga citra keluaran dari hasil thresholding
adalah berupa citra biner.

Gambar 3.13. Hasil Thresholding

H. Deteksi Karakter

41
Proses deteksi karakter merupakan proses yang akan memisahkan setiap digit
darikarakter pada gambar menjadi gambar yang terpisah. Metode yang digunakan
untuk mendeteksi karakter ialah mencari contour dari hasil thresholding.

Mulai A

Pengelompokan
Gambar
Daftar
grayscale
Objek(Karakter)
dan thresh
dalam Gambar

Objek
Konversi gambar ke
(Karakter)
binary
pada Gambar

Membuang objek
Gambar
(karakter) yang
grayscale
saling timpang
dan thresh
tindih

Objek
Mencari potensi
(Karakter)
objek dalam gambar
pada Gambar

Daftar objek Selesai

dalam
gambar

Gambar 3.14. Diagram Alir (Flowchart) Proses Deteksi Karakter

42
I. Pembacaan Karakter
Pada proses ini dilakukan pengenalan terhadap karakter pelat nomor yang sudah
terdeteksi melalui proses deteksi karakter. List karakter yang telah terdeteksi akan
dicocokan dengan Training dataset yang telah dibuat dengan metode K-Nearest
Neighbor, yaitu metode yang menggunakan algoritma supervised dimana hasil
dari query instance yang baru diklasifikan berdasarkan mayoritas dari kategori
KNN. Training dataset yang digunakan adalah 521 pasang pola mewakili karakter
alfanumerik (A sampai Z dan 0 sampai 9).

Start A B C

Gambar
Gambar yang Pelat dengan
Resized
telah Karakter Data KNN
Image
diThreshold Yang
ditandai

Membuat gambar
Mengambil data
yang telat di Crop Gambar Meratakan Image
karakter dari hasil
threshold versi Karakter Menjadi 1D
KNN
berwarna

Gambar
Gambar
Threshold Gambar 1D Karakter
Karakter
Berwarna

Menyamakan Selesai
Menandai Karakter Merubah Ukuran Gambar Karakter
Pada Pelat Gambar Dengan Data
Training

A B C

Gambar 3.15. Diagram Alir (Flowchart) Pembacaan Karakter

J. Database
Tahap akhir dari sistem ini adalah identifikasi pemilik kendaraan yang terdeteksi
dalam video. Penyimpanan database sistem menggunakan sqllite. Sistem akan

43
menghubungkan data pelat yang terbaca dengan data yang ada dalam database.
Apabila terdapat data output yang sama, maka sistem akan menampilkan data
penggunanya berupa NIK (Nomor Induk Karyawan), nama, jabatan, dan bagian.
Semua pelat nomor yang terdeteksi pada sistem akan tersimpan berupa log dengan
bentuk file .csv yang dimana didalamnya terdapat pelat nomor yang terbaca dan
waktu kendaraan tersebut dicapture.

3.2.4. Analisis Kinerja Sistem

Rekognisi atau pengenalan karakter teks pada pelat merupakan salah satu bentuk
pengujian yang ada pada sistem. Ketepatan pengenalan karakter teks pada pelat
dapat dilihat dari output video hasil implementasi masing- masing algoritma.
Persentase akurasi sistem akan diukur dengan 2 cara yaitu membandingkan
karakter yang terdeteksi benar pada pelat dengan karakter yang ada pada pelat dan
membandingkan jumlah setiap karakter yang terdeteksi dengan total jumlah setiap
karakter. Membandingkan karakter yang terdeteksi pada pelat berfungsi untuk
melihat bentuk pelat seperti apa yang dapat mendeteksi karakter dengan baik. Dan
membandingkan jumlah karakter berfungsi untuk melihat karakter seperti apa
yang dapat terdeteksi pada sistem dengan Training dataset yang telah disediakan.
Berikut cara menghitung akurasi perbandingan antara karakter pada pelat:
JDB
Akurasi = ×100 %
JDK
Dimana: JPB = Jumlah Digit Benar
JPK = Jumlah Digit Keseluruhan

44
 BAB IV HASIL PENGUJIAN DAN ANALISIS

4.1. Hasil Penelitian

Dalam bab ini disajikan hasil kinerja sistem pendeteksian dan pengenalan teks
karakter pada pelat kendaraan baik mobil maupun motor, serta keberhasilan
dalam menampilkan identitas pemilik kendaraan yang lewat. Pengambilan data
dilakukan dengan menggunakan kamera statis yang dipasang pada tripod kamera
yang bertempat di dalam area pintu masuk gerbang PT Tirta Gemah Ripah.
Pada penyajian berikut disajikan data jumlah pelat kendaraan sesuai dengan
jumlah pelat yang memenuhi syarat dalam video uji, jumlah pelat kendaraan yang
berhasil direkognisi oleh sistem serta berhasil tampil pada tabel identitas pemilik
kendaraan dan jumlah pelat kendaraan yang tidak berhasil direkognisi oleh
sistem. Hasil rekognisi oleh sistem akan digunakan untuk mengetahui persentase
akurasi sistem dalam merekognisi/membaca karakter-karakter (A sampai Z dan 0
sampai 9) pada pelat nomor dengan bentuk yang bervariasi, apabila pelat
kendaraan yang terdeteksi dapat disamakan dengan database dan setiap pelat yang
terdeteksi tersimpan pada sistem maka dapat dikatakan bahwa sistem berjalan
dengan baik.
Adapun hasil pengujian dan pengukuran tingkat akurasi teks dapat dilihat pada
table dibawah ini :
Tabel 4.1. Hasil Pendeteksi Karakter Setiap Pelat
Pelat Dari Internet
Hasil Karakter Jumlah
No Original Terdeteksi Akurasi
Deteksi Sama Digit
1 D5624KB D5624KB Berhasil 7 7 100.00%
2 B9320VUA 9320VU Gagal 6 8 75.00%
3 AB2015HF B2015HF Gagal 7 8 87.50%
4 AG5140VAA 5140VA Gagal 6 9 66.67%
5 BP1309GD 19 Gagal 2 8 25.00%
6 B9747BDA B9747B Gagal 6 8 75.00%
7 BM6408QO MG89 Gagal 2 8 25.00%
8 AB1411QD A04T0 Gagal 1 8 12.50%
9 H8701NA   Gagal 0 7 0.00%
10 B3131EEK 833EEK Gagal 5 8 62.50%
11 R1307KK   Gagal 0 7 0.00%

45
12 B9690UCG 4DD Gagal 0 8 0.00%
13 F1554EV FIVJ Gagal 2 7 28.57%
14 B1396NOI B1396N0I Gagal 7 8 87.50%
15 B713NAA 373NAA Gagal 5 7 71.43%
16 Z1445DZ Z445DZ Gagal 6 7 85.71%
17 B63NIT 863NIT Gagal 5 6 83.33%
18 DR1717SN   Gagal 0 8 0.00%
19 D1224AAN   Gagal 0 8 0.00%
20 B1966RFR   Gagal 0 8 0.00%
21 B805WYN 6805WYN Gagal 6 7 85.71%
22 DK935BO   Gagal 0 7 0.00%
23 D1866IX 018661X Gagal 6 7 85.71%
24 D1732ACL   Gagal 0 8 0.00%
25 D777CR 07Z7CR Gagal 4 6 66.67%
26 D1511V 01511V Gagal 5 6 83.33%
27 B1425ZFY   Gagal 0 8 0.00%
28 Z6758LN 6758LN Gagal 6 7 85.71%
29 Z2422MD Z2422 Gagal 5 7 71.43%
30 B6308VOT DJZTF Gagal 0 8 0.00%
31 D6437IE 06437IE Gagal 6 7 85.71%
32 H2173AY 6IA1 Gagal 1 7 14.29%
33 D2512SX S1SX Gagal 3 7 42.86%
34 F3244TJ 341 Gagal 2 7 28.57%
35 B4855KBN SAS55WYV Gagal 3 8 37.50%
36 B4552TRA INSST1YV Gagal 1 8 12.50%
37 E5047QAB E50470A8 Gagal 6 8 75.00%
38 D3381SX L338SX Gagal 5 7 71.43%
39 B3241TUC 830C Gagal 2 8 25.00%
40 B6257BFR 0I2570FT Gagal 3 8 37.50%
41 B6631ZIS 883IS Gagal 3 8 37.50%
42 B1755UZS B1155UZS Gagal 7 8 87.50%
43 H1751LG U75I Gagal 3 7 42.86%
44 B1920SSO I920AS8 Gagal 4 8 50.00%
45 DM3190AS III Gagal 0 8 0.00%
46 B1242RTO ADF Gagal 0 8 0.00%
47 B102PHT   Gagal 0 7 0.00%
48 BM1153SC   Gagal 0 8 0.00%
49 B2500TKW I100T Gagal 3 8 37.50%
50 BK96WH   Gagal 0 6 0.00%
Pelat Dari Perusahaan
51 D1031AEU 1AEU Gagal 4 8 50.00%
52 6060R 6060R Berhasil 5 5 100.00%

46
 53 D1213AGN YVJ Gagal 0 8 0.00%
54 B1549IG IIV Gagal 0 7 0.00%
55 D1162ADH 162ADHX Gagal 6 8 75.00%
56 D1849AHK IIA1 Gagal 0 8 0.00%
57 D2566TP VXVI Gagal 0 7 0.00%
58 B4707THE 7AZZ1 Gagal 0 8 0.00%
59 D3268JX QS31 Gagal 1 7 14.29%
60 D3572SAC DD50DZHED Gagal 2 8 25.00%
61 D6302ABW KX7 Gagal 0 8 0.00%
62 D5757RD 575Z20 Gagal 3 7 42.86%
63 R2464BF 47Y Gagal 0 7 0.00%
64 R5944SS S944SS Gagal 5 7 71.43%
65 D6065JM 1222 Gagal 0 7 0.00%
66 D4508MW AZV Gagal 0 7 0.00%
67 D2426SA C747CS Gagal 2 7 28.57%
68 D5882VEB XAX Gagal 0 8 0.00%
69 D3904ZTO Z4T Gagal 2 8 25.00%
70 D3298GO 3298G0 Gagal 6 7 85.71%
71 D3693WY ALKYT Gagal 0 7 0.00%
72 D2808MO 70YA Gagal 0 7 0.00%
73 D3007OK Z1JV Gagal 0 7 0.00%
74 D1549IG 01549TG Gagal 5 7 71.43%
75 D1371SQ 01371S Gagal 5 7 71.43%

Dari tabel 4.1, terdepat 125 pelat kendaraan dengan rincian 100 pelat dari internet
dan 25 pelat kendaraan yang terdapat di PT Tirta Gemah Ripah. Jumlah hasil
karakter yang terdeteksi dalam pelat kendaraan perusahaan masih sangat sedikit
jadi sebagai tambahan data untuk menguji akurasi sistem telah disiapkan 100
gambar pelat nomor kendaraan yang didapatkan di Internet. 50 Pelat yang
didapatkan dari internet digunakan sebagai Training dataset, maka hanya terdapat
75 data yang dapat digunakan untk menghitung akurasi karakter. Hasil dari
pengolahan pelat kendaraan di PT Tirta Gemah Ripah selain sebagai data untuk
menghitung akurasi pendeteksian karakter, berfungsi juga sebagai tolak ukur
pengenalan sistem terhadap database yang tersimpan. Jumlah keseluruhan pelat
kendaraan yang terdeteksi dan memenuhi syarat untuk direkognisi akan dihitung
dengan menggunakan persamaan (3) sebagaimana yang dicantumkan pada bab III
sebelumnya.

47
Dan berikut hasil dari pengukuran karakter yang terdeteksi dari semua pelat :
Original Terdeteksi Akurasi
Angka Huruf Angka Huruf Angka Huruf
1 27 A 16 1 13 A 7 48.15% 43.75%
2 15 B 22 2 6 B 5 40.00% 22.73%
3 16 C 3 3 11 C 1 68.75% 33.33%
4 17 D 16 4 11 D 5 64.71% 31.25%
5 17 E 5 5 10 E 4 58.82% 80.00%
6 12 F 5 6 9 F 3 75.00% 60.00%
7 15 G 3 7 8 G 1 53.33% 33.33%
8 8 H 3 8 8 H 1 100.00% 33.33%
9 8 J 1 9 5 J 2 62.50% 200.00%
0 11 I 4 0 13 I 6 118.18% 150.00%
K 6 K 2 33.33%
L 2 L 2 100.00%
M 2 M 1 50.00%
N 9 N 6 66.67%
O 4 O 0 0.00%
P 1 P 0 0.00%
Q 3 Q 0 0.00%
R 6 R 1 16.67%
S 3 S 7 233.33%
T 4 T 4 100.00%
U 2 U 1 50.00%
V 5 V 6 120.00%
W 1 W 2 200.00%
X 3 X 3 100.00%
Y 3 Y 3 100.00%
Z 5 Z 5 100.00%
Tabel 4.2. Hasil Pengukuran Akurasi Setiap Karakter dari Semua Pelat
Dari tabel 4.2 terdapat 137 karakter huruf dan 146 karakter angka yang terdapat
pada pelat yang akan dibandingkan dengan Training dataset pada sistem. Dari
hasil perbandingan didapatkan 78 karakter huruf dan 94 karakter angka yang
jumlahnya lebih sedikit dari total karakter pada pelat. Jumlah setiap karakter yang
terdeteksi pun ada yang jumlahnya melebihi data sebenarnya dari karakter karena
terdapat objek yang salah dalam pendeteksiannya lalu objek tersebut memiliki
pixel yang sama dengan karakter pada Training dataset. Karakter yang
seharusnya tidak ada namun terdeteksi oleh sistem membuat akurasi dari
pendeteksian bertambah dari yang seharusnya.

48
MASUKAN PLOT/GRAFIK DISINI

4.2. Pembahasan
Hasil yang diperoleh setelah menerapkan Haar-like Cascade Classifier dan K-
Nearest Neighbor dalam melakukan Optical Character Recognition, diperoleh
tingkat akurasi yang beragam dari setiap digit karakter pelat (A sampai Z dan 0
sampai 9) yang terdeteksi. Presentase keberhasilan pendeteksian karakter pada
pelat terpengaruhi oleh beberapa faktor antara lain posisi (kemiringan dan jarak)
dari pelat, warna pelat, intensitas cahaya pada pelat dan Training dataset yang
menjadi pembanding karakter pada pelat.
4.2.1. Posisi Pelat
Posisi pelat yang miring dapat mempengaruhi hasil output apabila karakter miring
tersebut belum dimasukan kedalam Training Dataset seperti contoh berikut :

Gambar 4.1. Contoh Posisi Pelat Miring

Gambar 4.sekian. diambil menggunakan webcam posisi yang miring, proses
mendeteksi masih mengenali gambar pelat dan proses pemotongan gambar
berjalan dengan baik, namun pada saat proses pendeteksian karakter pada gambar,
gambar yang terdeteksi bukanlah karakter namun objek lain. Hal tersebut terjadi
dikarenakan pada saat sistem menyamakan semua objek yang terdeteksi dengan
training dataset, karakter F6913IB yang miring tidak terdapat pada training data
set dan yang terbaca adalah 7LC.

49
 Gambar 4.2. Hasil Contoh Pelat Miring
Dan sebagai pembanding berikut gambar pelat yang sama namun dengan posisi
yang tidak miring seperti gambar sebelumnya seperti berikut:

Gambar 4.3. Pembanding Contoh Pelat Miring

Gambar 4.sekian. tersebut memiliki posisi yang cukup lurus dibandingkan dengan
yang sebelumnya dan semua proses pendeteksi berjalanan dengan baik namun
masih terdapat error karena 1 angka tidak terbaca jadi hasilnya F693IB.

Gambar 4.4. Hasil Pembanding Contoh Pelat Miring

4.2.2. Warna pelat

Warna putih pada karakter pelat dan garis putih yang mengelilingi pelat sangat
berpengaruh terhadap output dari OCR. Warna karakter pada pelat berpengaruh
karena warna putih pada karakter merupakan kunci utama dalam pembacaan

50
kontur atau pola dari gambar, apabila warna putih mulai pudar dan sudah tidak
berbentuk karakter yang seharusnya maka system pun akan salah dalam
pembacaannya. Seperti contoh berikut :

Gambar 4.5. Warna Karakter Pudar dalam Pelat

Warna yang terdapat pada pelat sudah pudar dan pada saat system mengkonversi
gambar menjadi thresholding, karakter pada pelat banyak yang terpotong dan
membaca gambar menjadi karakter yang tidak seharusnya. Seperti angka 2 yang
terpotong menjadi angka 7 dan huruf A yang terpotong menjadi huruf K.

Gambar 4.6. Thresholding Warna Karakter Pudar

Sehingga hasil output yang terbaca oleh system adalah D276SK.
Cari hasil no plate detected tapi sebenernya ada pelat
4.2.3. Intensitas Cahaya
Intensitas cahaya merupakan faktor yang cukup berpengaruh dalam OCR karena
gambar yang memiliki intensitas cahaya buruk maka saat system melakukan
konversi gambar ke threshold, karakter yang terdapat pada gambar atau gambar
pelat bisa hilang. Seperti contoh berikut :

51
 Gambar 4.7. Pelat dengan Intensitas Cahaya Belang
Gambar 4.7 menunjukan disisi kiri pada gambar pelat memiliki intensitas cahaya
yang lebih gelap daripada sisi kanan dan karakternya pun lebih gelap. Hal tersebut
dapat membuat system tidak mengenali karakter yang terdapat pada sisi gelap
karena system mengira karakter tersebut berwarna hitam.

Gambar 4.8. Hasil Grayscale dan Max Contrast pada Pelat

4.2.4. Training dataset

*Masukan gambar dimana warna bagus, posisi bagus, intensitas cahaya bagus tapi
miss seperti huruf I menjadi T atau R menjadi P dll dan jelaskan pengaruhnya
bagaimana dan dari proses mana hasilnya sudah berbeda*.

52
 BAB V KESIMPULAN DAN SARAN

5.1. Kesimpulan
Berdasarkan hasil pengujian yang dilakukan pada sistem deteksi pelat kendaraan
di PT Tirta Gemah Ripah, maka dapat disimpulkan bahwa:
1. Banyak faktor yang mempengaruhi ketepatan akurasi sistem dalam
mendeteksi karakter pada pelat nomor diantaranya intensitas cahaya pada
pelat, kualitas gambar masukan, Training dataset yang digunakan sebagai
pembanding, metode pemprosesan gambar masukan sebelum dilakukan OCR,
dan bentuk pelat kendaraan.
2. Diperlukan banyak Training dataset karena kondisi pelat kendaraan tidak
mungkin semuanya mulus jadi karakter pada Training dataset diperlukan
bervariasi sebanyak mungkin.
3. Deteksi yang tersulit adalah deteksi karakter “O” dan B, dikarenakan pada
format plat nomor di Indonesia, karakter “O” dan “0” memiliki bentuk
karakter yang sama. Sementara itu, huruf B pada plat nomor test seringkali
dalam keadaan buruk dan juga seringkali menempel dengan objek lain seperti
tepi pembatas sehingga tidak dapat di contour.
4. Algoritma K-Nearest Neighbor dapat digunakan sebagai metode OCR dengan
hasil yang cukup baik.
5. Sistem mampu menampilkan data pada database sesuai dengan output dari
sistem serta mencatat log output ke file teks dokumen.

5.2. Saran
Dalam pengembangan program pendeteksian pelat kendaraan mobil dan motor
pada PT Tirta Gemah Ripah masih banyak terdapat kekurangan, oleh karena itu
penulis mengharapkan lebih banyak perbaikan dan pengembangan pada penelitian
selanjutnya. Berikut ini beberapa saran dari penulis untuk pengembangan pada
penelitian selanjutnya:
1. Perbanyak Training dataset dari setiap karakter pada pelat karena Training
dataset merupakan kunci dari penyamaan karakter sistem.

53
2. Apabila ingin mengambil data pada malam hari, pastikan intensitas yang
menerangi pelat nomor kendaraan cukup terang karena jika pelat gelap
ditakutkan sistem tidak akan menganggap karakter tersebut objek yang akan
dideteksi.
3. Penempatan kamera perlu disimpan didepan pelat nomor dan terfokus ke pelat
nomor, apabila terlalu banyak objek selain pelat nomor akan berdampak pada
pendeteksian ROI objek.
4. Pastikan penandaan ROI untuk melakukan potongan pelat tidak melenceng ke
objek yang lain karena apabila pemotongan ke objek yang lain maka karakter
yang terdeteksi pasti berbeda dengan yang seharusnya.
5. Diperlukan pengujian dengan metode lain untuk mengetahui perbandingan
tingkat akurasi dan kecepatan proses dari tiap-tiap metode guna meningkatkan
akurasi dan efisiensi waktu proses dari program yang dijalankan.

54
 DAFTAR PUSTAKA

[1]BPS Jawa Barat. 2018. Jumlah Kendaraan Bermotor Umum dan Bukan
Umum Untuk BPKB Menurut Cabang Pelayanan di Jawa Barat, 2018.
Tersedia: https://jabar.bps.go.id/statictable/2018 [diakses1 Agustus 2019]

[2]Mansyur, Yusran. 2018. Optical Character Recognition Untuk Deteksi Pelat

Mobil Dan Motor Kendaraan Pada Kampus Teknik Gowa. Teknik
Informatika, Universitas Hasanuddin.

[3]Sutoyo, T, dkk. 2009, “Teori Pengolahan Citra Digital”, Penerbit Andi,

Yogyakarta hal 9 - 27.
[4]Putra, Darma. 2010. Pengolahan Citra Digital. Yogyakarta : Penerbit Andi
[5]Wahyudi, Ario. Pengantar Pengolahan Citra Digital. Tersedia: http://ario-
wahyubudi-fst13.web.unair.ac.id [diakses 5 Agustus 2019]
[6]Wijaya, M. V. dan Tjiharjadi, S. 2009. Mencari Nilai Threshold yang Tepat
untuk Perancangan Pendeteksi Kanker Trofoblas. Seminar Nasional
Aplikasi Teknologi Informasi 2009. Yogyakarta, 20 Juni 2009.
[7]Rahman, Sayuti. 2013. Kontras (Contrast). Tersedia: http://sayutirahman.stth-
medan.ac.id/2013/12/kontras-contrast.html [diakses 2 Agustus 2019]
[8] R. Fisher, S. Perkins, A. Walker and E. Wolfart. 2003. Thresholding. Tersedia:
https://homepages.inf.ed.ac.uk/rbf/HIPR2/threshld.htm [diakses 2 Agustus
2019.]
[9]Gonzales, RC, Richard E. Wood.2008.Digital Image Processing
ThirdEdition.Pearson Prentice Hall.
[10]Firdaus, Afrizal dkk. 2016. Klasifikasi Kendaraan di Jalan Tol dengan
Menerapkan Metode Local Binary Pattern dan Linear Discriminant
Analysis. Fakultas Informatika. Bandung: Universitas Telkom.
[11]Maula, Akhmad Robit dkk. 2013. Optical Character Recognition Dengan
Metode Naive Bayes. Malang: Universitas Brawijaya
[12]Sasotya, Angga Kurnia. 2017. Implementasi Metode Sobel Edge dan
Template Matching Menggunakan Raspberry-pi Sebagai Sistem
Pengenalan Pelat Otomatis. Bandung: Universitas Telkom.
[13]Leksono, Devri Kurniawan. 2017. Piranti Cerdas Simulasi Tembak
Menggunakan Laser Pointer. Malang: Universitas Muhammadiyah Malang.
[14]Lienhart, Rainer and Jochen Maydt. 2002. An extended set of haar-like
features for rapid object detection. In: IEEE ICIP 2002, Vol.1, pp 900-903.

55
[15]Shulur, Sandy Permata. 2015. Perancangan Aplikasi Deteksi Wajah
Menggunakan Algoritma Viola-Jones. Bandung: Universitas Pasundan.
[16]Papilaya, Ryvalldo Anugrah. 2018. Implementasi Gesture Recognition
Dengan Metode Fingertip Tracking pada Aplikasi Simulasi Controlling
Dance Touch Berbasis Desktop. Bandung: Universitas Komputer.
[17]Kuswara, Randy. 2013. Aplikasi Pendeteksi Mata Mengantuk Berbasis Citra
Digital Menggunakan Metode Haar Classifier Secara Real Time. Bandung:
Universitas Komputer.
[18]Sastia Hendri Wibowo, dan Firman Susanto. 2016. Penerapan Metode
Gaussian Smoothing Untuk Mereduksi Noise Pada Citra Digital. Bengkulu:
Universitas Muhammadiyah.
[19]Official OpenCV (Open Source Computer Vision) website. Contours : Getting
Started.
[Online].Tersedia:https://docs.opencv.org/3.4/d4/d73/tutorial_py_contours
_begin.html [diakses 30 Juli 2019]
[21]Teknomo K., 2010. K-Nearest Neighbours Tutorial, K-Tetangga Terdekat
Tutorial, (Online). Tersedia:
http://people.revoledu.com/kardi/tutorial/KNN/ [diakses 30 Juli 2019]
[22]Official OpenCV (Open Source Computer Vision) website. Understanding k-
Nearest.Neighbour.[Online]. Tersedia: https://docs.opencv.org/3.0-
beta/doc/py_tutorials/py_ml/py_knn/py_knn_understanding/py_knn_under
standing.html [diakses 30 Juli 2019]

56
 LAMPIRAN A
CODING PYTHON KESELURUHAN

import sys
from contextlib import contextmanager
from os import path, mkdir, listdir
from typing import Optional
import RPi.GPIO as GPIO
import time

import cv2
import numpy as np
from PyQt5.QtCore import QSize, QTimer, QStringListModel, Qt, \
    QItemSelectionModel
from PyQt5.QtGui import QImage, QPixmap, QKeySequence
from PyQt5.QtWidgets import QWidget, QLabel, QApplication, QHBoxLayout, \
    QShortcut, QVBoxLayout, QListView, QPushButton, QLineEdit, QGroupBox, \
    QStyledItemDelegate

import data_provider
from model import PCALDAClassifier

class NoFacesError(Exception):
    pass

class MultipleFacesError(Exception):
    pass

class CapitalizeDelegate(QStyledItemDelegate):
    def displayText(self, value, locale):
        string = super().displayText(value, locale)
        return string.capitalize()

class MainApp(QWidget):
    STRANGER_DANGER = 350
    IMAGE_SIZE = (100, 100)

    stranger_color = (179, 20, 20)

    recognized_color = (59, 235, 62)

    def __init__(self, fps=30, parent=None):

A-1
        # type: (int, Optional[QWidget]) -> None
        super().__init__(parent=parent)

        self.pkg_path = path.dirname(path.dirname(path.abspath(__file__)))
        self.training_data_dir = path.join(self.pkg_path, 'train')
        self.models_dir = path.join(self.pkg_path, 'models')
        self.model_fname = 'fisherfaces.p'

        try:
            self.model = data_provider.load_model(
                path.join(self.models_dir, self.model_fname))
        except AssertionError:
            self.model = None

        self.existing_labels = QStringListModel(self.get_existing_labels())

        self.fps = fps
        self.video_size = QSize(640, 480)

        self.gray_image = None
        self.detected_faces = []

        # Setup the UI
        self.main_layout = QHBoxLayout()
        self.setLayout(self.main_layout)

        self.control_layout = QVBoxLayout()
        self.control_layout.setSpacing(8)
        self.main_layout.addItem(self.control_layout)

        # Setup the existing label view

        self.labels_view = QListView(parent=self)
        self.labels_view.setModel(self.existing_labels)
        self.labels_view.setSelectionMode(QListView.SingleSelection)
        self.labels_view.setItemDelegate(CapitalizeDelegate(self))
        self.control_layout.addWidget(self.labels_view)

        self.new_label_txt = QLineEdit(self)
        self.new_label_txt.returnPressed.connect(self.add_new_label)
        self.new_label_txt.returnPressed.connect(self.new_label_txt.clear)
        self.control_layout.addWidget(self.new_label_txt)

        self.add_button = QPushButton('Add Label', self)

        self.add_button.clicked.connect(self.add_new_label)
        self.control_layout.addWidget(self.add_button)

A-2
        # Setup the training area
        train_box = QGroupBox('Train', self)
        train_box_layout = QVBoxLayout()
        train_box.setLayout(train_box_layout)
        self.control_layout.addWidget(train_box)
        self.train_btn = QPushButton('Train', self)
        self.train_btn.clicked.connect(self.train)
        train_box_layout.addWidget(self.train_btn)

        self.control_layout.addStretch(0)

        # Add take picture shortcut

        self.take_picture_btn = QPushButton('Take picture', self)
        self.take_picture_btn.clicked.connect(self.take_picture)
        self.control_layout.addWidget(self.take_picture_btn)
        shortcut = QShortcut(QKeySequence('Space'), self, self.take_picture)
        shortcut.setWhatsThis('Take picture and add to training data.')

        # Add quit shortcut

        shortcut = QShortcut(QKeySequence('Esc'), self, self.close)
        shortcut.setWhatsThis('Quit')

        # Setup the main camera area

        self.image_label = QLabel(self)
        self.image_label.setFixedSize(self.video_size)
        self.main_layout.addWidget(self.image_label)

        # Setup the camera

        self.capture = cv2.VideoCapture(0)
        self.capture.set(cv2.CAP_PROP_FRAME_WIDTH, self.video_size.width())
        self.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, self.video_size.height())

        self.timer = QTimer()
        self.timer.timeout.connect(self.display_video_stream)
        self.timer.start(int(1000 / self.fps))

    def classify_face(self, image):

        if self.model is None:
            return

        label_idx, distances = self.model.predict(image.ravel(), True)

        label_idx, distance = label_idx[0], distances[0][label_idx]

        labels = self.existing_labels.stringList()
        return labels[label_idx], distance

A-3
    def get_training_data(self):
        """Read the images from disk into an n*(w*h) matrix."""
        return data_provider.get_image_data_from_directory(
            self.training_data_dir)

    def train(self):
        X, y, mapping = self.get_training_data()
        # Inspect scree plot to determine appropriate number of PCA components
        classifier = PCALDAClassifier(
            n_components=2, pca_components=200, metric='euclidean',
        ).fit(X, y)

        # Replace the existing running model

        self.model = classifier

        # Save the classifier to file

        data_provider.save_model(
            classifier, path.join(self.models_dir, self.model_fname))

    def add_new_label(self):
        new_label = self.new_label_txt.text()
        new_label = new_label.lower()

        # Prevent empty entries

        if len(new_label) < 3:
            return

        string_list = self.existing_labels.stringList()

        if new_label not in string_list:

            string_list.append(new_label)
            string_list.sort()
            self.existing_labels.setStringList(string_list)

            # Automatically select the added label

            selection_model = self.labels_view.selectionModel()
            index = self.existing_labels.index(string_list.index(new_label))
            selection_model.setCurrentIndex(index, QItemSelectionModel.Select)

    def display_video_stream(self):
        """Read frame from camera and repaint QLabel widget."""
        _, frame = self.capture.read()
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        frame = cv2.flip(frame, 1)

A-4
        # Use the Viola-Jones face detector to detect faces to classify
        face_cascade = cv2.CascadeClassifier(path.join(
            self.pkg_path, 'resources', 'haarcascade_frontalface_default.xml'))
        self.gray_image = gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        self.detected_faces = face_cascade.detectMultiScale(gray, 1.3, 5)

        for x, y, w, h in self.detected_faces:
            # Label the detected face as per the model
            face = gray[y:y + h, x:x + w]
            face = cv2.resize(face, self.IMAGE_SIZE)

            result = self.classify_face(face)
            # If a model is loaded, we can predict
            if result:
                predicted, distance = self.classify_face(face)

                if distance > self.STRANGER_DANGER:

                    predicted = 'Stranger danger!'
                    color = self.stranger_color
                else:
                    predicted = predicted.capitalize()
                    color = self.recognized_color

                if predicted.lower() == "zenzen":
                    print("Zenzen Detect")
                    GPIO.setmode(GPIO.BOARD)
                    GPIO.setwarnings(False)
                    GPIO.setup(12,GPIO.OUT)
                    time.sleep(5)
                    GPIO.cleanup()

                elif predicted.lower() == "admin":

                    print("Admin Detect")
                    GPIO.setmode(GPIO.BOARD)
                    GPIO.setwarnings(False)
                    GPIO.setup(12,GPIO.OUT)
                    time.sleep(5)
                    GPIO.cleanup()
                    
                # Draw a rectangle around the detected face
                cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
                text = '%s (%.1f)' % (predicted, distance)
                cv2.putText(frame, text, (x, y + h + 15),
                            cv2.FONT_HERSHEY_TRIPLEX, 0.5, color)
            else:
                # Draw a rectangle around the detected face

A-5
                cv2.rectangle(frame, (x, y), (x + w, y + h),
                              self.stranger_color, 2)
                cv2.putText(frame, 'Stranger danger!', (x, y + h + 15),
                            cv2.FONT_HERSHEY_TRIPLEX, 0.5, self.stranger_color)

        # Display the image in the image area

        image = QImage(frame, frame.shape[1], frame.shape[0],
                       frame.strides[0], QImage.Format_RGB888)
        self.image_label.setPixmap(QPixmap.fromImage(image))

    @contextmanager
    def stop_camera_feed(self):
        """Temporarly stop the feed and face detection."""
        try:
            self.timer.stop()
            yield
        finally:
            self.timer.start(int(1000 / self.fps))

    def take_picture(self):
        # Notify the user there were no faces detected
        if self.detected_faces is None or len(self.detected_faces) < 1:
            return
            raise NoFacesError()

        if len(self.detected_faces) > 1:
            return
            raise MultipleFacesError()

        with self.stop_camera_feed():
            x, y, w, h = self.detected_faces[0]

            face = self.gray_image[y:y + h, x:x + w]

            face = cv2.resize(face, self.IMAGE_SIZE)
            denoised_image = cv2.fastNlMeansDenoising(face)

            if not self.selected_label:
                return

            self.save_image(denoised_image, self.selected_label)

    @property
    def selected_label(self):
        index = self.labels_view.selectedIndexes()
        if len(index) < 1:
            return None

A-6
        label = self.existing_labels.data(index[0], Qt.DisplayRole)

        return label

    def get_existing_labels(self):
        """Get a list of the currently existing labels"""
        return data_provider.get_folder_names(self.training_data_dir)

    def save_image(self, image: np.ndarray, label: str) -> None:

        """Save an image to disk in the appropriate directory."""
        if not path.exists(self.training_data_dir):
            mkdir(self.training_data_dir)

        label_path = path.join(self.training_data_dir, label)

        if not path.exists(label_path):
            mkdir(label_path)

        existing_files = listdir(label_path)
        existing_files = map(lambda p: path.splitext(p)[0], existing_files)
        existing_files = list(map(int, existing_files))
        last_fname = sorted(existing_files)[-1] if len(existing_files) else 0

        fname = path.join(label_path, '%03d.png' % (last_fname + 1))

        cv2.imwrite(fname, image)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    win = MainApp()
    win.show()
    sys.exit(app.exec_())

A-7
 LAMPIRAN B
SAMPEL FOTO DATABASE

ADMIN 1 ANDI

imgNum=0
# Our operations on the frame come here
if k % 256 == 27:
# ESC pressed
print("Escape hit, closing...")
break
elif k % 256 == 32:
# SPACE pressed
path = 'input/ ' + timeformat +'.jpg'
cv2.imwrite(path, imagecopy)
print("{} written!".format(path))
# Display the resulting frame
cv2.imshow('frame',gray)

# When everything done, release the capture

path = 'input/ ' + timeformat +'.jpg'
cap.release()

A-8
cv2.destroyAllWindows()
print ('time')
#cv2.imshow('capture' + first + "-" + end, gray)
main.main(path)
cv2.waitKey(0)

A-9
 LAMPIRAN C
CODING PYTHON CHARDETECT.PY
import Preprocess
import cv2
import PossibleChar
import math
import numpy as np
import main
import os
import time
from datetime import datetime

kNearest = cv2.ml.KNearest_create()

MIN_PIXEL_WIDTH = 2
MIN_PIXEL_HEIGHT = 8

MIN_ASPECT_RATIO = 0.25
MAX_ASPECT_RATIO = 1.0

MIN_PIXEL_AREA = 80

# constants for comparing two chars

MIN_DIAG_SIZE_MULTIPLE_AWAY = 0.3
MAX_DIAG_SIZE_MULTIPLE_AWAY = 5.0

MAX_CHANGE_IN_AREA = 0.5

MAX_CHANGE_IN_WIDTH = 0.8 # lebih besar karena memperhatikan kontur

huruf i
MAX_CHANGE_IN_HEIGHT = 0.2

C-1
MAX_ANGLE_BETWEEN_CHARS = 12.0

# other constants
MIN_NUMBER_OF_MATCHING_CHARS = 3

RESIZED_CHAR_IMAGE_WIDTH = 20
RESIZED_CHAR_IMAGE_HEIGHT = 30

MIN_CONTOUR_AREA = 100

# For renaming folder

ts=time.time()
timeformat = datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H-%M-%S')
time=str(datetime.now())

######################## Load data klasifikasi KNN

def loadKNNDataAndTrainKNN():
allContoursWithData = []
validContoursWithData = []

try:
npaClassifications = np.loadtxt("data/classifications.txt", np.float32)
except:
print ("error, unable to open classifications.txt, exiting program\n")

return False

try:
npaFlattenedImages = np.loadtxt("data/knn2.txt", np.float32)

C-2
 except:
print ("error, unable to open flattened_images.txt, exiting program\n")

return False

npaClassifications = npaClassifications.reshape((npaClassifications.size, 1))

kNearest.setDefaultK(1)

kNearest.train(npaFlattenedImages, cv2.ml.ROW_SAMPLE, npaClassifications)

return True

def recognizeCharsInPlate(imgThresh, listOfMatchingChars, filename):

strChars = "" # this will be the return value, the chars in the lic plate

height, width = imgThresh.shape

imgThreshColor = np.zeros((height, width, 3), np.uint8)

listOfMatchingChars.sort(key = lambda matchingChar:

matchingChar.intCenterX) # sort chars from left to right

cv2.cvtColor(imgThresh, cv2.COLOR_GRAY2BGR, imgThreshColor) #

make color version of threshold image so we can draw contours in color on it
i=0
for currentChar in listOfMatchingChars: # for each char in plate
pt1 = (currentChar.intBoundingRectX, currentChar.intBoundingRectY)

C-3
 pt2 = ((currentChar.intBoundingRectX + currentChar.intBoundingRectWidth),
(currentChar.intBoundingRectY + currentChar.intBoundingRectHeight))
x = currentChar.intBoundingRectX
y = currentChar.intBoundingRectY
w = currentChar.intBoundingRectWidth
h =currentChar.intBoundingRectHeight
crop_img = imgThresh[y:y+(h), x:x+(w)]

cv2.rectangle(imgThreshColor, pt1, pt2, main.SCALAR_GREEN, 2) # draw

green box around the char

# crop char out of threshold image

imgROI = imgThresh[currentChar.intBoundingRectY :
currentChar.intBoundingRectY + currentChar.intBoundingRectHeight,
currentChar.intBoundingRectX : currentChar.intBoundingRectX +
currentChar.intBoundingRectWidth]

imgROIResized = cv2.resize(imgROI, (RESIZED_CHAR_IMAGE_WIDTH,

RESIZED_CHAR_IMAGE_HEIGHT)) # resize image, this is necessary for
char recognition

npaROIResized = imgROIResized.reshape((1,
RESIZED_CHAR_IMAGE_WIDTH * RESIZED_CHAR_IMAGE_HEIGHT))
# flatten image into 1d numpy array

npaROIResized = np.float32(npaROIResized) # convert from 1d numpy

array of ints to 1d numpy array of floats

retval, npaResults, neigh_resp, dists = kNearest.findNearest(npaROIResized,

k=3) # finally we can call findNearest !!!

C-4
 strCurrentChar = str(chr(int(npaResults[0][0]))) # get character from results

if main.showstep == True:
cv2.imshow(strCurrentChar, crop_img)
#cv2.imshow("tresh", imgThresh)
if main.writeresult == True:
filename= timeformat +'.jpg'
#filename=filename.replace("img/","")
dirc="output/char/"+filename
dirplatroi="output/sgmtchar"
# If need float32 for proving knn method here
#print (npaROIResized)
#np.savetxt('cobain.txt', npaROIResized)
if not os.path.exists(dirplatroi):
os.makedirs(dirplatroi)
cv2.imwrite(dirplatroi+"/"+filename+".jpg", imgThreshColor)
if not os.path.exists(dirc):
os.makedirs(dirc)
#print dirc+"/"+strCurrentChar
cv2.imwrite(dirc+"/"+str(i)+"-"+strCurrentChar+"-"+"Hasil"+".jpg",
crop_img)
i=i+1
strChars = strChars + strCurrentChar # append current char to full string

# end for

if main.showstep == True: # show steps

#######################################################
cv2.imshow("detection", imgThreshColor)

C-5
 # end if # show steps
##################################################################
#######

return strChars

def removeInnerOverlappingChars(listOfMatchingChars):
listOfMatchingCharsWithInnerCharRemoved = list(listOfMatchingChars) #
this will be the return value

for currentChar in listOfMatchingChars:

for otherChar in listOfMatchingChars:
if currentChar != otherChar: # if current char and other char are not the same
char . . .
# if current char and other char have center points at
almost the same location . . .
if distanceBetweenChars(currentChar, otherChar) <
(currentChar.fltDiagonalSize * MIN_DIAG_SIZE_MULTIPLE_AWAY):
# if we get in here we have found overlapping chars
# next we identify which char is smaller, then if that char was not
already removed on a previous pass, remove it
if currentChar.intBoundingRectArea < otherChar.intBoundingRectArea:
# if current char is smaller than other char
if currentChar in listOfMatchingCharsWithInnerCharRemoved: # if
current char was not already removed on a previous pass . . .
listOfMatchingCharsWithInnerCharRemoved.remove(currentChar) #
then remove current char
# end if
else: # else if other char is smaller than current char
if otherChar in listOfMatchingCharsWithInnerCharRemoved: # if
other char was not already removed on a previous pass . . .

C-6
 listOfMatchingCharsWithInnerCharRemoved.remove(otherChar) #
then remove other char
# end if
# end if
# end if
# end if
# end for
# end for

return listOfMatchingCharsWithInnerCharRemoved
# end function

def angleBetweenChars(firstChar, secondChar):

fltAdj = float(abs(firstChar.intCenterX - secondChar.intCenterX))
fltOpp = float(abs(firstChar.intCenterY - secondChar.intCenterY))

if fltAdj != 0.0: # check to make sure we do not divide by zero if the

center X positions are equal, float division by zero will cause a crash in Python
fltAngleInRad = math.atan(fltOpp / fltAdj) # if adjacent is not zero, calculate
angle
else:
fltAngleInRad = 1.5708 # if adjacent is zero, use this as the angle, this is
to be consistent with the C++ version of this program
# end if

fltAngleInDeg = fltAngleInRad * (180.0 / math.pi) # calculate angle in degrees

return fltAngleInDeg

def distanceBetweenChars(firstChar, secondChar):

intX = abs(firstChar.intCenterX - secondChar.intCenterX)

C-7
 intY = abs(firstChar.intCenterY - secondChar.intCenterY)

return math.sqrt((intX ** 2) + (intY ** 2))

def findListOfMatchingChars(possibleChar, listOfChars):

# the purpose of this function is, given a possible char and a big list of
possible chars,
# find all chars in the big list that are a match for the single possible char, and
return those matching chars as a list
listOfMatchingChars = [] # this will be the return value

for possibleMatchingChar in listOfChars: # for each char in big list

if possibleMatchingChar == possibleChar: # if the char we attempting to find
matches for is the exact same char as the char in the big list we are currently
checking
# then we should not include it in the list of matches b/c that
would end up double including the current char
continue # so do not add to list of matches and jump back to top of
for loop
# end if
# compute stuff to see if chars are a match
fltDistanceBetweenChars = distanceBetweenChars(possibleChar,
possibleMatchingChar)

fltAngleBetweenChars = angleBetweenChars(possibleChar,
possibleMatchingChar)

fltChangeInArea = float(abs(possibleMatchingChar.intBoundingRectArea -
possibleChar.intBoundingRectArea)) / float(possibleChar.intBoundingRectArea)

C-8
 fltChangeInWidth = float(abs(possibleMatchingChar.intBoundingRectWidth -
possibleChar.intBoundingRectWidth)) /
float(possibleChar.intBoundingRectWidth)
fltChangeInHeight = float(abs(possibleMatchingChar.intBoundingRectHeight -
possibleChar.intBoundingRectHeight)) /
float(possibleChar.intBoundingRectHeight)

# check if chars match

if (fltDistanceBetweenChars < (possibleChar.fltDiagonalSize *
MAX_DIAG_SIZE_MULTIPLE_AWAY) and
fltAngleBetweenChars < MAX_ANGLE_BETWEEN_CHARS and
fltChangeInArea < MAX_CHANGE_IN_AREA and
fltChangeInWidth < MAX_CHANGE_IN_WIDTH and
fltChangeInHeight < MAX_CHANGE_IN_HEIGHT):

listOfMatchingChars.append(possibleMatchingChar) # if the chars are a

match, add the current char to list of matching chars
# end if
# end for

return listOfMatchingChars

def findListOfListsOfMatchingChars(listOfPossibleChars):
# with this function, we start off with all the possible chars in one big list
# the purpose of this function is to re-arrange the one big list of chars into a
list of lists of matching chars,
# note that chars that are not found to be in a group of matches do not need to
be considered further
listOfListsOfMatchingChars = [] # this will be the return value

C-9
 for possibleChar in listOfPossibleChars: # for each possible char in the
one big list of chars
listOfMatchingChars = findListOfMatchingChars(possibleChar,
listOfPossibleChars) # find all chars in the big list that match the current char

listOfMatchingChars.append(possibleChar) # also add the current char to

current possible list of matching chars

if len(listOfMatchingChars) < MIN_NUMBER_OF_MATCHING_CHARS: #

if current possible list of matching chars is not long enough to constitute a
possible plate
continue # jump back to the top of the for loop and try again with next
char, note that it's not necessary
# to save the list in any way since it did not have enough chars to
be a possible plate
# end if

# if we get here, the current list passed test as a "group" or "cluster"

of matching chars
listOfListsOfMatchingChars.append(listOfMatchingChars) # so add to our list
of lists of matching chars

listOfPossibleCharsWithCurrentMatchesRemoved = []

# remove the current list of matching chars from the big list so we
don't use those same chars twice,
# make sure to make a new big list for this since we don't want to
change the original big list
listOfPossibleCharsWithCurrentMatchesRemoved =
list(set(listOfPossibleChars) - set(listOfMatchingChars))

C-10
 recursiveListOfListsOfMatchingChars =
findListOfListsOfMatchingChars(listOfPossibleCharsWithCurrentMatchesRemov
ed) # recursive call

for recursiveListOfMatchingChars in recursiveListOfListsOfMatchingChars:

# for each list of matching chars found by recursive call
listOfListsOfMatchingChars.append(recursiveListOfMatchingChars) #
add to our original list of lists of matching chars
# end for

break # exit for

# end for

return listOfListsOfMatchingChars

def checkIfPossibleChar(possibleChar):
# this function is a 'first pass' that does a rough check on a contour to see if it
could be a char,
# note that we are not (yet) comparing the char to other chars to look for a
group
if (possibleChar.intBoundingRectArea > MIN_PIXEL_AREA and
possibleChar.intBoundingRectWidth > MIN_PIXEL_WIDTH and
possibleChar.intBoundingRectHeight > MIN_PIXEL_HEIGHT and
MIN_ASPECT_RATIO < possibleChar.fltAspectRatio and
possibleChar.fltAspectRatio < MAX_ASPECT_RATIO):
return True
else:
return False

def findPossibleCharsInPlate(imgGrayscale, imgThresh):

C-11
 listOfPossibleChars = [] # this will be the return value
contours = []
imgThreshCopy = imgThresh.copy()

# find all contours in plate

contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)

for contour in contours: # for each contour

possibleChar = PossibleChar.PossibleChar(contour)

if checkIfPossibleChar(possibleChar): # if contour is a possible char, note

this does not compare to other chars (yet) . . .
listOfPossibleChars.append(possibleChar) # add to list of possible chars
# end if
# end if

return listOfPossibleChars
# end function

def detectCharsInPlates(possiblePlate,filename):
intPlateCounter = 0
imgContours = None
contours = []

# preprocess to get grayscale and threshold images

possiblePlate.imgGrayscale, possiblePlate.imgThresh =
Preprocess.preprocess(possiblePlate.imgPlate)

C-12
 possiblePlate.imgThresh = cv2.resize(possiblePlate.imgThresh, (0, 0), fx = 1.6,
fy = 1.6)

thresholdValue, possiblePlate.imgThresh =
cv2.threshold(possiblePlate.imgThresh, 0.0, 255.0, cv2.THRESH_BINARY |
cv2.THRESH_OTSU)

listOfPossibleCharsInPlate =
findPossibleCharsInPlate(possiblePlate.imgGrayscale, possiblePlate.imgThresh)

listOfListsOfMatchingCharsInPlate =
findListOfListsOfMatchingChars(listOfPossibleCharsInPlate)

for i in range(0, len(listOfListsOfMatchingCharsInPlate)): # within each

list of matching chars
listOfListsOfMatchingCharsInPlate[i].sort(key = lambda matchingChar:
matchingChar.intCenterX) # sort chars from left to right
listOfListsOfMatchingCharsInPlate[i] =
removeInnerOverlappingChars(listOfListsOfMatchingCharsInPlate[i]) # and
remove inner overlapping chars
intLenOfLongestListOfChars = 0
intIndexOfLongestListOfChars = 0

for i in range(0, len(listOfListsOfMatchingCharsInPlate)):

if len(listOfListsOfMatchingCharsInPlate[i]) > intLenOfLongestListOfChars:
intLenOfLongestListOfChars = len(listOfListsOfMatchingCharsInPlate[i])
intIndexOfLongestListOfChars = i
if len(listOfListsOfMatchingCharsInPlate)>0:

C-13
 longestListOfMatchingCharsInPlate =
listOfListsOfMatchingCharsInPlate[intIndexOfLongestListOfChars]

possiblePlate.strChars = recognizeCharsInPlate(possiblePlate.imgThresh,
longestListOfMatchingCharsInPlate,filename)
if len(listOfListsOfMatchingCharsInPlate)==0:
print ("No character ditected!")

return possiblePlate

C-14