Buku Labyrinthgame

PROYEK AKHIR
DETEKSI KEPALA UNTUK PERPINDAHAN KARAKTER

MENGGUNAKAN STEADY-STATE GENETIC ALGORITHM
(SSGA) PADA APLIKASI GAME LABYRINTH
Oleh :
Wais Al-Qonri Hanif

NRP. 7408 040 028
Dosen Pembimbing :
Nana Ramadijanti, S.Kom., M.Kom.

NIP. 19711109 199802 2 001
Dr.Eng. Indra Adji Sulistijono, S.T., M.Eng.

NIP. 19670527 199403 1 018
PROGRAM STUDI D4 TEKNIK INFORMATIKA

DEPARTEMEN TEKNIK INFORMATIKA DAN KOMPUTER
POLITEKNIK ELEKTRONIKA NEGERI SURABAYA
2012
PROYEK AKHIR
SAMPUL

MENGGUNAKAN STEADY-STATE GENETIC ALGORITHM
(SSGA) PADA APLIKASI GAME LABYRINTH
Oleh :
Wais Al-Qonri Hanif

NRP. 7408 040 028
Dosen Pembimbing :
Nana Ramadijanti, S.Kom., M.Kom.

NIP. 19711109 199802 2 001
Dr.Eng. Indra Adji Sulistijono, S.T., M.Eng.

NIP. 19670527 199403 1 018
PROGRAM STUDI D4 TEKNIK INFORMATIKA

DEPARTEMEN TEKNIK INFORMATIKA DAN KOMPUTER
POLITEKNIK ELEKTRONIKA NEGERI SURABAYA
2012
i
HALAMAN PENGESAHAN

MENGGUNAKAN STEADY-STATE GENETIC ALGORITHM (SSGA)
PADA APLIKASI GAME LABYRINTH
Oleh :
Wais Al-Qonri Hanif
NRP. 7408 040 028
Proyek Akhir ini Digunakan Sebagai Salah Satu Syarat Untuk

Memperoleh Gelar Sarjana Sains Terapan (S.ST.)
di
Politeknik Elektronika Negeri Surabaya
2012
Disetujui oleh :
Tim Penguji Proyek Akhir : Dosen Pembimbing :
1. Drs. Achmad Basuki, M.Kom., Ph. D. 1. Nana Ramadijanti, S.Kom., M.Kom.

NIP. 19690112 199403 1 002 NIP. 19711109 199802 2 001
2. Yuliana Setiowati, S.Kom. 2. Dr.Eng. Indra Adji

NIP. 19780706 200212 2 003 Sulistijono, S.T., M.Eng.
NIP. 19670527 199403 1 018
3. Rizky Yuniar Hakkun, S.Kom.

NIP. 19810622 200812 1 003
Mengetahui,
Ketua Program Studi D4 Teknik Informatika
Departemen Teknik Informatika dan Komputer
Politeknik Elektronika Negeri Surabaya
Isbat Uzzin Nadhori, S.Kom., M.T.

NIP. 19740505 200312 1 002
ii
ABSTRAK
Perkembangan Teknologi Informasi khususnya dalam

Computer Vision (CV) kini sudah sampai pada bidang hiburan. CV
dapat membuat komputer mendeteksi benda-benda yang ditangkap dari
kamera. Teknologi tersebut diterapkan pada sebuah game dengan rule
melewati sebuah labyrinth, dan pergerakan karakter dikontrol dengan
mendeteksi gerak kepala player. Pada tembok labyrinth diberi gambar
yang berisi cerita yang berguna sebagai petunjuk untuk dapat
menyelesaikan labyrinth tersebut. Dalam game ini dideteksi posisi
kepala dan dilakukan tracking dari gerakan kepala player menggunakan
webcam. Metode yang digunakan untuk mendeteksi posisi kepala dan
melakukan tracking gerakan kepala adalah Steady-State Genetic
Algorithm (SSGA), diawali dengan melakukan perubahan warna RGB
menjadi warna hitam, cokelat, dan putih untuk deteksi kulit wajah. Hasil
akhir yang didapat dari penelitian ini adalah game dapat dikendalikan
dengan gerakan kepala player. Kini bermain game lebih mengasyikkan
dan tidak selalu menggunakan joystick.
Kata kunci : game labyrinth, tracking, steady-state genetic algorithm,

rgb
iii
ABSTRACT
Development of Information Technology, especially in

Computer Vision (CV) has been submitted to the entertainment field.
CV can make the computer detect objects that are captured from the
camera. The technology is applied into a game with the rule through a
labyrinth, and the character movement is controlled by detecting the
motion of the head of player. On the walls of labyrinth were given a
picture that contains stories that serve clues to solve the labyrinth. In this
game was detected the position of head and make tracking the
movement of player’s head using a webcam. The method used to detect
the position of the head and make tracking the movement of the head is
Steady-State Genetic Algorithm (SSGA), begin with the RGB color
changes to black, brown, and white for the detection of facial skin. The
result of this research is the game can be controlled by the movement of
the head of the player. Now playing the game is more fun and not
always using a joystick.
Keywords : game labyrinth, tracking, steady-state genetic algorithm,

rgb
iv
KATA PENGANTAR
Puji syukur saya panjatkan kehadirat Allah SWT, yang telah

melimpahkan rahmat dan hidayah-Nya, sehingga dapat menyelesaikan
proyek akhir ini yang berjudul :

MENGGUNAKAN STEADY-STATE GENETIC
ALGORITHM (SSGA) PADA APLIKASI GAME
LABYRINTH
Tujuan penyusunan proyek akhir ini adalah untuk memenuhi

salah satu persyaratan guna menyelesaikan studi di Politeknik
Elektronika Negeri Surabaya. Dalam menyelesaikan proyek akhir ini,
penulis melaksanakan berdasarkan teori-teori yang telah diperoleh
dalam perkuliahan, berbagai buku refensi dan bimbingan dari dosen
pembimbing serta dari berbagai pihak yang telah memberikan semangat
dan bantuan.
Penulis sadar bahwa masih banyak kesalahan dan kekurangan
dalam penyusunan buku proyek akhir ini. Untuk itu penulis mohon maaf
dan mengharapkan kritik dan saran guna penyempurnaan di masa yang
akan datang. Penulis juga berharap buku proyek akhir ini dapat
memberikan manfaat sehingga para pembaca dapat mengembangkan
proyek akhir ini.
Surabaya, Juli 2012
Penulis
v
UCAPAN TERIMA KASIH
Alhamdulillah, puji syukur kehadirat “ Allah SWT ”, berkat rahmat

dan hidayah-Nya penulis dapat menyelesaikan proyek akhir ini. Ucapan
terima kasih penulis sampaikan kepada berbagai pihak yang telah
membantu memperlancar penyelesaian proyek akhir ini.
1. Seluruh keluarga, khususnya kedua orang tua penulis yang selalu

memberikan dukungan serta doa selama proses penyusunan proyek
akhir ini.
2. Bapak Dadet Pramadihanto, M.Eng., Ph. D., selaku Direktur
Politeknik Elektronika Negeri Surabaya.
3. Ibu Arna Fariza, S.Kom., M.Kom., selaku Ketua Departemen
Teknik Informatika dan Komputer PENS.
4. Bapak Izbat Uzzin Nadhori, S.Kom., M.T., selaku Ketua Program
Studi D4 Teknik Informatika PENS
5. Ibu Nana Ramadijanti, S.Kom., M.Kom., selaku pembimbing I
pada penyusunan proyek akhir ini.
6. Bapak Dr.Eng. Indra Adji Sulistijono, S.T., M.Eng., selaku
pembimbing II pada penyusunan proyek akhir ini.
7. Bapak dan ibu dosen yang telah memberikan ilmu yang sangat
berguna selama proses perkuliahan.
8. Seluruh staf dan karyawan PENS yang telah membantu dalam
proses administrasi.
9. Fathan Mustaqiim yang banyak membantu memberikan saran dan
referensi mengenai algoritma sistem.
10. Teman-teman seperjuangan Arvan Novandianto, Ahmad Syafii,
Shendy Febrian, Wisnu Andri yang bersama-sama bahu-membahu.
11. Teman-teman sekelas D4 TI A angkatan 2008 yang telah
membantu, memberikan ide dan solusi dalam penyusunan proyek
akhir ini.
12. Serta pihak-pihak yang lain yang tidak dapat saya sebutkan satu-
persatu.
vi
DAFTAR ISI
HALAMAN JUDUL......................................................................i
HALAMAN PENGESAHAN........................................................ii
ABSTRAK......................................................................................iii
ABSTRACT....................................................................................iv
KATA PENGANTAR....................................................................v
UCAPAN TERIMA KASIH..........................................................vi
DAFTAR ISI...................................................................................vii
DAFTAR GAMBAR......................................................................ix
DAFTAR TABEL...........................................................................xi
BAB I. PENDAHULUAN..............................................................1
1.1. Latar Belakang.........................................................................1
1.2. Perumusan Masalah.................................................................1
1.3. Batasan Masalah......................................................................2
1.4. Tujuan......................................................................................2
1.5. Metodologi...............................................................................2
1.6. Sistematika Penulisan..............................................................4
BAB II. TEORI PENUNJANG......................................................7

2.1. YCrCb Color System...............................................................7
2.2. Grafika Komputer....................................................................7
2.2.1. Bitmap..........................................................................8
2.2.2. Open Graphics Library (OpenGL)...............................8
2.2.3. Translasi 3D.................................................................10
2.2.4. Rotasi 3D......................................................................10
2.3. Steady-State Genetic Algorithm (SSGA)................................11
2.4. Labyrinth..................................................................................12
2.4.1. Game Labyrinth 3D......................................................13
BAB III. PERENCANAAN DAN PEMBUATAN SISTEM.........17

3.1. Desain Sistem..........................................................................17
3.2. Proses Teknis Pengambilan Gambar.......................................18
3.3. Scalp Color Modeling..............................................................19
3.4. Head Detection........................................................................21
3.5. Head Tracking..........................................................................29
3.6. Game Labyrinth.......................................................................31
3.6.1. Menggambar Peta.........................................................31
vii
3.6.2. Menggambar Tembok..................................................33
3.6.3. Menampilkan Pertanyaan.............................................35
3.6.4. Load Texture................................................................37
3.6.5. Menghitung Waktu.......................................................38
3.6.6. Menentukan Collision..................................................39
3.6.7. Menentukan Gerak Karakter........................................40
3.7. Skenario Game.........................................................................42
BAB IV. PENGUJIAN DAN ANALISA SISTEM........................67

4.1. Segmentasi Warna...................................................................67
4.2. Hasil Percobaan Steady-State Algortihm (SSGA)...................68
4.3. Hasil Percobaan Gerakan Kepala Player.................................72
4.4. Hasil Percobaan Gerakan Karakter Pada Game......................74
4.5. Hasil Percobaan Gerakan Karakter Pada Game Dengan Latar
Belakang Yang Berbeda..........................................................77
4.5.1. Latar Belakang Berwarna Putih...................................77
4.5.2. Latar Belakang Berwarna Coklat Kulit........................78
4.5.3. Latar Belakang Berwarna Campuran (Putih, Coklat,
Hitam)..........................................................................78
4.6. Hasil Percobaan Gerakan Karakter Pada Game Dengan
Intensitas Cahaya Yang Berbeda.............................................79
4.6.1. Kondisi A.....................................................................80
4.6.2. Kondisi B......................................................................81
4.6.3. Kondisi C......................................................................82
4.6.4. Kondisi A + B..............................................................83
4.6.5. Kondisi A + C..............................................................84
4.6.6. Kondisi B + C...............................................................85
4.6.7. Kondisi A + B + C........................................................86
4.6.8. Kondisi Lampu Mati....................................................87
BAB V. PENUTUP........................................................................89
5.1. Kesimpulan..............................................................................89
5.2. Saran........................................................................................89
DAFTAR PUSTAKA.....................................................................91
LAMPIRAN....................................................................................93
BIODATA PENULIS.....................................................................95
viii
DAFTAR GAMBAR
Gambar 1.1. Metodologi Proyek Akhir........................................3

Gambar 2.1. Labyrinth..................................................................13
Gambar 2.2. Sudut Pandang Player Dalam Game........................14
Gambar 2.3. Area Pandangan.......................................................14
Gambar 2.4. Field of View............................................................15
Gambar 2.5. 3D Maze Survival....................................................15
Gambar 3.1. Blok Diagram Sistem...............................................17
Gambar 3.2. Hasil Capture Dari Kamera......................................19
Gambar 3.3. Hasil Scalp Color Modeling.....................................21
Gambar 3.4. Flowchart Head Detection........................................22
Gambar 3.5. Individu Yang Dibangkitkan....................................23
Gambar 3.6. 50 Individu Yang Dibangkitkan Secara Acak..........23
Gambar 3.7. Template Kepala Manusia........................................25
Gambar 3.8. Hasil Deteksi Kepala Menggunakan SSGA............29
Gambar 3.9. Batas-Batas Nilai Pada Koordinat xi dan yi..............31
Gambar 3.10. Peta Pada Game Labyrinth.......................................33
Gambar 3.11. Tembok-Tembok Pada Game Labyrinth.................35
Gambar 3.12. Tampilan Pertanyaan...............................................37
Gambar 3.13. Ilustrasi Collision.....................................................39
Gambar 3.14. Gerak Karakter.........................................................42
Gambar 3.15. Tampilan Awal Game..............................................42
Gambar 3.16. Tampilan Menu Play................................................43
Gambar 3.17. Tampilan Ketika Cerita Yang Dipilih Perang 10
November 1945........................................................43
Gambar 3.18. Tampilan Ketika Cerita Yang Dipilih Perang
Diponegoro..............................................................44
Gambar 3.19. Tampilan Ketika Tombol ‘h’ Ditekan......................45
Gambar 3.20. Tampilan Pertanyaan...............................................45
Gambar 3.21. Tampilan Akhir Labyrinth.......................................46
Gambar 3.22. Tampilan Pause........................................................46
Gambar 3.23. Tampilan Ketika Gameover.....................................47
Gambar 3.24. Tampilan Menu Learning........................................48
Gambar 3.25. Tampilan Learning Perang 10 November 1945.......48
Gambar 3.26. Tampilan Learning Perang Diponegoro...................49
Gambar 3.27. Tampilan Menu Help...............................................49
Gambar 3.28. Tampilan Menu Credit.............................................50
Gambar 3.29. Map Labyrinth Perang 10 November 1945.............51
ix
Gambar 3.30. Map Labyrinth Perang Diponegoro.........................62
Gambar 4.1. Grafik 5 Iterasi Terhadap Nilai Fitness....................69
Gambar 4.2. Grafik 10 Iterasi Terhadap Nilai Fitness..................69
Gambar 4.3. Grafik 15 Iterasi Terhadap Nialai Fitness................70
Gambar 4.4. Grafik Individu Terhadap Waktu.............................71
Gambar 4.5. Latar Belakang Berwarna Putih...............................77
Gambar 4.6. Latar Belakang Berwarna Coklat Kulit....................78
Gambar 4.7. Latar Belakang Berwarna Campuran (Putih, Coklat,
Hitam)......................................................................78
Gambar 4.8. Kondisi A.................................................................80
Gambar 4.9. Hasil Percobaan Kondisi A......................................80
Gambar 4.10. Kondisi B.................................................................81
Gambar 4.11. Hasil Percobaan Kondisi B......................................81
Gambar 4.12. Kondisi C.................................................................82
Gambar 4.13. Hasil Percobaan Kondisi C......................................82
Gambar 4.14. Kondisi A + B..........................................................83
Gambar 4.15. Hasil Percobaan Kondisi A + B...............................83
Gambar 4.16. Kondisi A + C..........................................................84
Gambar 4.17. Hasil Percobaan Kondisi A + C...............................84
Gambar 4.18. Kondisi B + C..........................................................85
Gambar 4.19. Hasil Percobaan Kondisi B + C...............................85
Gambar 4.20. Kondisi A + B + C...................................................86
Gambar 4.21. Hasil Percobaan Kondisi A + B + C........................86
Gambar 4.22. Kondisi Lampu Mati................................................87
Gambar 4.23. Hasil Percobaan Kondisi Lampu Mati.....................87
x
DAFTAR TABEL
Tabel 3.1. Alur Cerita 10 November 1945 Yang Benar.................51

Tabel 3.2. Alur Cerita 10 November 1945 Yang Salah..................56
Tabel 3.3. Alur Cerita Diponegoro Yang Benar.............................63
Tabel 3.4. Alur Cerita Diponegoro Yang Salah..............................65
Tabel 4.1. Hasil Scalp Color Modeling..........................................67
Tabel 4.2. Hasil Percobaan Gerak Ke Kiri.....................................72
Tabel 4.3. Hasil Percobaan Gerak Ke Kanan.................................73
Tabel 4.4. Hasil Percobaan Gerak Maju.........................................74
Tabel 4.5. Gerakan Karakter Dalam Game.....................................75
Tabel 4.6. Gerakan Karakter Dalam Game Dengan Latar
Belakang Yang Berbeda................................................79
Tabel 4.7. Gerakan Karakter Dalam Game Dengan Intensitas
Cahaya Yang Berbeda...................................................88
xi
BAB I
PENDAHULUAN
1.1. Latar Belakang

Teknologi Informasi (TI) adalah istilah umum yang
menjelaskan teknologi apapun yang membantu manusia dalam
membuat, mengubah, menyimpan, mengkomunikasikan dan/atau
menyebarkan informasi. TI menyatukan komputasi dan komunikasi
berkecepatan tinggi untuk data, suara, gambar, dan video. Cabang
ilmu dalam TI yang mempelajari tentang gambar dan video adalah
Computer Vision (CV). CV merupakan suatu ilmu dalam Teknologi
Informasi yang dapat membuat mesin atau komputer dapat melihat,
melihat di sini diartikan sebagai mengekstrak informasi dari sebuah
gambar baik dari online kamera ataupun offline. Salah satu
teknologi dari CV adalah mendeteksi obyek yaitu komputer dapat
mendeteksi benda-benda yang ditangkap dari kamera. Teknologi
tersebut diterapkan pada sebuah game dengan rule melewati sebuah
labyrinth, dan pergerakan karakter dikontrol dengan mendeteksi
gerak kepala player. Pada tembok labyrinth diberi gambar yang
berisi cerita yang berguna sebagai petunjuk untuk dapat
menyelesaikan labyrinth tersebut. Dalam game ini dideteksi posisi
kepala dan dilakukan tracking dari gerakan kepala player
menggunakan webcam. Metode yang digunakan untuk mendeteksi
posisi kepala dan melakukan tracking gerakan kepala adalah
Steady-State Genetic Algorithm (SSGA), diawali dengan melakukan
perubahan RGB menjadi warna hitam, cokelat, dan putih untuk
deteksi kulit wajah. Kemudian jika gambar kepala tersebut bergerak
maju berarti karakter bergerak maju, dan jika gambar kepala
tersebut bergerak ke kanan dengan nilai tertentu maka karakter
menghadap ke kanan, dan jika kepala bergerak ke kiri dengan nilai
tertentu maka karakter menghadap ke kiri. Kini bermain game lebih
mengasyikkan dan tidak selalu menggunakan joystick.
1.2. Perumusan Masalah

Beberapa lingkup permasalahan yang akan dibahas dalam
penelitian proyek akhir ini diantaranya :
a. Bagaimana mempelajari cara membuat game 3D menggunakan
Mac OS X, karena masih sangat jarang game menggunakan
1
Mac OS X dan untuk kedepannya dapat digunakan sebagai
referensi tambahan.
b. Bagaimana menerapkan prinsip-prinsip game desain ke dalam
game labyrinth 3D.
c. Bagaimana merancang dan membuat labyrinth 3D mulai dari
lantai, tembok-temboknya secara menarik agar player senang
memainkannya.
d. Bagaimana melakukan scalp color modeling yang menentukan
warna hitam, cokelat, dan putih.
e. Bagaimana membuat labyrinth 3D dengan deteksi kepala
menggunakan SSGA.
f. Bagaimana menentukan gerakan maju, kanan, kiri
menggunakan SSGA
1.3. Batasan Masalah

Sedangkan batasan masalah pada proyek akhir ini, antara lain :
a. Untuk memainkan game ini menggunakan gerakan kepala
dari 1 player saja yang tidak menggunakan topi, kacamata,
dan masker dengan background putih dan dengan
pencahayaan yang normal, dan dengan kulit kepala rata-rata
orang tropis.
b. Game ini dirancang dan dibangun menggunakan XCode
dengan bahasa C untuk menerapkan teknologi CV ke dalam
game dan pembuatan rule game, dan juga menggunakan
OpenGL untuk mendesain labyrinth.
1.4. Tujuan
Membuat suatu aplikasi game yang tidak selalu menggunakan
joystick atau keyboard untuk memainkannya, tetapi menggunakan
gerakan kepala. Player dengan daya eksplorasi yang tinggi
mungkin dapat dengan mudah menyelesaikan game ini.
1.5. Metodologi
Metodologi dari proyek akhir yang akan dikerjakan memiliki
beberapa tahapan yaitu:
2
Studi Literatur dan Pengambilan Data
Perancangan dan Pembuatan Sistem
Pengujian dan Analisa
Pembuatan Laporan
Gambar 1.1.Metodologi proyek akhir
1.5.1. Studi Literatur dan Pengambilan Data

Pada tahap ini yang dilakukan adalah mencari
referensi-referensi yang berhubungan dengan proyek akhir
ini baik berupa buku, paper, tutorial atau informasi
mengenai konsep atau metode yang dibutuhkan untuk
membangun aplikasi ini. Referensi yang digunakan yaitu
Human Detection and Gesture Recognition Based on
Ambient Intelligence, Cognitive Development in Partner
Robots for Information Support to Elderly People, Rancang
Bangun Robot Pantilt : Pendeteksian Posisi Kepala Manusia
Menggunakan Algoritma Genetika, OpenGL Programming
Guide.
1.5.2. Perancangan dan Pembuatan Sistem

Untuk perancangan sistem, dibagi menjadi dua bagian
besar, yaitu sistem yang menangkap dan mengolah gambar
kepala player sehingga sistem bisa mengenali maksud dari
gerakan kepala player. Dan yang kedua adalah pembuatan
game. Untuk lebih detilnya adalah sebagai berikut :
 Mendeteksi adanya kepala player yaitu
menggunakan metode SSGA. Pemilihan
3
metode ini adalah karena prosesnya lebih
cepat.
 Kemudian dilakukan penentuan maju, kanan,
dan kiri menggunakan SSGA.
 Langkah terakhir adalah mengintegrasikan
dengan game.
1.5.3. Pengujian dan Analisa

Pada tahap pengujian pertama, dilakukan pengujian
terhadap pendeteksian kepala player. Pengujian dilakukan
dengan cahaya yang berbeda-beda. Kemudian dilakukan uji
coba penangkapan gerakan kepala player untuk mendeteksi
gerak maju, kanan, dan kiri. Pengujian ketiga adalah
gerakan dalam game.
1.5.4. Pembuatan Laporan

Penulisan laporan proyek akhir ini, dikerjakan pada
akhir penelitian sebagai penjelasan dari proses pengerjaan
sistem mulai dari tahap persiapan, perancangan,
pelaksanaan hingga pengujian dan analisa sistem.
1.6. Sistematika Penulisan

Sistematika penulisan buku proyek akhir adalah sebagai
berikut :
BAB I PENDAHULUAN
Memuat tentang latar belakang, perumusan masalah,
batasan masalah, tujuan, dan metodologi serta sistematika
penulisan penelitian.
BAB II TEORI PENUNJANG

Memuat tentang uraian mengenai landasan teori yang
digunakan dalam penelitian, yang mendukung pendekatan
dan pemecahan permasalahan penelitian.
BAB III PERENCANAAN DAN PEMBUATAN SISTEM

Memuat tentang perencanaan sistem dalam penelitian,
yang meliputi cara kerja sistem atau perancangan
perangkat lunak, tempat dan waktu pengujian sistem, dan
pengumpulan dan cara analisa data.
4
BAB IV PENGUJIAN DAN ANALISA
Memuat tentang pengujian sistem dan analisa, yang
meliputi pembuatan perangkat lunak, pengujian perangkat
lunak, dan pembahasan penelitian.
BAB V PENUTUP
Memuat tentang kesimpulan dari pembahasan penelitian,
dan saran untuk pengembangan dan pemanfaatan hasil
penelitian lebih lanjut.
5
Halaman Ini Sengaja Dikosongkan
6
BAB II
TEORI PENUNJANG
2.1. YCrCb Color System

Warna yang diterima dari kamera adalah warna RGB. Untuk
memodelkan warna kulit sistem warna RGB ini ditransformasikan
ke sistem warna YCrCb untuk memisahkan intensitas Y dengan
chromaticity yang dinyatakan dalam dua variabel Cr dan Cb. Harga
Cr membedakan warna antara jarak intensitas terhadap unsur
warna merah sedangkan Cb menyatakan jarak intensitas terhadap
unsur warna biru. Dalam memodelkan warna kulit hanya informasi
Cr dan Cb yang dipakai, sehingga pengaruh perubahan intensitas
dapat dihilangkan. Pada daerah saturasi dari cahaya yang
tertangkap kamera, harga Cr dan Cb sangat stabil, sehingga nilai Cr
dan Cb merupakan informasi handal untuk proses klasifikasi
warna.
Untuk mengubah citra berwarna yang mempunyai nilai matrik
masing-masing r, g, dan b menjadi citra warna YCrCb dapat
dilakukan dengan menghitung seperti pada persamaan berikut,
(Sumber: Ferman Hakiki, “Rancang Bangun Robot Pantilt:
Pendeteksian Posisi Kepala Manusia Menggunakan Algoritma
Genetika”, PENS-ITS, Surabaya, 2009, halaman 23).
Y = 0.59G + 0.31R +0.11B (2.1)

Cr = 0.713 * (R - Y) (2.2)
Cb= 0.564 * (B - Y) (2.3)
2.2. Grafika Komputer

Grafika komputer dapat diartikan sebagai seperangkat alat yang
terdiri dari perangkat keras dan perangkat lunak untuk membuat
gambar, grafik atau citra realistik untuk seni, game komputer, foto
dan film animasi. Grafika komputer merupakan bagian yang
menarik dalam bidang ilmu komputer. Ini dikarenakan untuk dapat
memahaminya dengan baik diperlukan kemampuan matematika
dan juga keahlian untuk memprogram dan kreatifitas.
Banyak cara dan variasi untuk menghasilkan gambar dengan
komputer. Seringkali kita akan dihadapkan pada masalah algoritma
dan pemrograman untuk menghasilkan citra realistik.
7
2.2.1. Bitmap
Merupakan representasi dari gambar yang terdiri dari
baris dan kolom pada titik grafik gambar di komputer. Nilai
dari titik disimpan dalam satu atau lebih data bit. Tampilan
dari bitmap atau raster, menggunakan titik – titik berwarna
yang dikenal dengan sebutan piksel. Struktur bitmap terdiri
dari header, info header dan color table. Header merupakan
bagian dari file bitmap yang berisi informasi header dari file
gambar bitmap. Ukuran dari header ini 14 byte, masing –
masing terdiri dari signatur 2 byte (berisi “BM” sebagai
tanda gambar mempunyai format bmp), FileSize 4 byte
(besarnya ukuran gambar mempunyai satuan bytes,
Reserved 4 bytes (tidak digunakan atau sama diisi dengan
nilai nol) dan DataOffset 4 byte(file offset untuk raster
data).
2.2.2. Open Graphics Library (OpenGL)

OpenGL adalah software (perangkat lunak) interface
perangkat keras grafik. Interface ini terdiri dari sekitar 150
command atau perintah yang berbeda yang bisa digunakan
untuk menentukan obyek dan operasi yang dibutuhkan
untuk menghasilkan aplikasi 3D yang interaktif. OpenGL
didesain untuk memperlancar, diimplementasikan pada
banyak jenis perangkat keras yang berbeda. OpenGL tidak
menyediakan perintah untuk menggambarkan model dari
objek tiga dimensi, kita harus membangun model yang
diinginkan dari satu set kecil dari geometri seperti titik,
garis, dan poligon. Library yang menyediakan fitur ini
tentunya bisa dibuat dengan OpenGL. The OpenGL Utility
Library (GLU) menyediakan beberapa fitur modeling,
seperti permukaan kuadrik, kurva, dan bentuk-bentuk
lainnya. GLU adalah bagian standar dari setiap
implementasi OpenGL. OpenGL memiliki lebih dari 200
fungsi. Fungsi tersebut bisa dikelompokkan menjadi :
a. Fungsi primitif, menentukan elemen yang bisa

menghasilkan gambar di layar. Fungsi ini terdiri dari 2
jenis, yaitu primitif geometric seperti polygon (segi
8
banyak) yang bisa dibuat menjadi dua, tiga, atau empat
dimensi, dan primitif gambar seperti bitmaps.
b. Fungsi atribut, mengontrol tampilan dari primitif.
Fungsi ini menentukan warna, jenis garis, properti
material, sumber cahaya, dan tekstur.
c. Fungsi pandangan, menentukan properti kamera.
OpenGL menyediakan sebuah virtual kamera yang
bisa diposisikan dan diorientasikan relatif ke obyek
yang ditentukan dengan fungsi primitif. Lensa kamera
juga bisa dikendalikan sehingga bisa dihasilkan sudut
yang lebar dan pandangan telefoto (jarak jauh).
d. Fungsi windowing, fungsi ini mengendalikan windows
pada layar dan penggunaan dari mouse dan keyboard.
e. Fungsi kontrol, menghidupkan macam-macam fitur
OpenGL.
Fungsi-fungsi OpenGL dimuat di dalam 2 library yang

disebut dengan gl dan glu (atau GL dan GLU). Library
yang pertama, adalah fungsi utama dari OpenGL, berisi
semua fungsi OpenGL yang dibutuhkan sedangkan yang
kedua, The openGL Utility Llibrary (GLU) memuat fungsi
yang ditulis menggunakan fungsi dari library utama dan
sangat membantu bagi pengguna. Fungsi utama
mempunyai nama yang diawali dengan “gl” seperti
“glVertex3f()”, sedangkan fungsi didalam GLU
mempunyai nama yang diawali dengan “glu” seperti
“gluOrtho2D()”.
The OpenGL Utility Toolkit (GLUT) merupakan

libraryuser interface yang sangat terkenal untul aplikasi
OpenGL. Ini memberikan sebuah interface yang sederhana
untuk penanganan antarmuka window, mouse, keyboard,
dan perangkat input lainnya. Memiliki fasilitas untuk
nested pop-up menu, dan termasuk utilitas untuk fungsi
bitmap dan stroke fonts, serta untuk menggambar obyek
grafis primitif seperti spheres, tori, dan teapots. Atraksi
yang besar window system independence, yang
(digabungkan dengan OpengGL window system
independence) menyediakan lingkungan yang sangat
9
menarik untuk pengembangan lintas-platform aplikasi
grafis.
2.2.3. Translasi 3D
Transformasi translasi merupakan suatu operasi yang
menyebabkan perpindahan objek 3D dari satu tempat ke
tempat yang lain. Perubahan ini berlaku dalam arah yang
sejajar dengan sumbu x, sumbu y, dan sumbu z.
Dalam operasi translasi, setiap titik pada suatu entitas
yang ditranslasi bergerak dalam jarak yang sama.
Pergerakan itu dapat berlaku dalam arah sumbu x saja,
dalam arah sumbu y saja, dalam sumbu z saja, atau bisa
ketiganya.
Sekiranya titik asal P(x, y, z) ditranslasi ke titik baru
Q(x`, y`, z`) maka titik baru ini dapat dicari dengan rumus
berikut, (Sumber: Achmad Basuki, Nana Ramadijanti,
“Grafika Komputer”, Politeknik Elektronika Negeri
Surabaya-ITS, Surabaya, 2009, halaman 9).
x` = x+dx (2.4)
y` = y+dy (2.5)
z` = z+dz (2.6)
Nilai – nilai dx, dy, dan dz adalah nilai perubahan

untuk operasi translasi. Ini berarti bahwa titik P ditranslasi
dalam arah x sebanyak dx, dalam arah y sebanyak dy, dan
dalam arah z sebanyak dz. Koordinat Q (x`, y`, z`) adalah
koordinat baru hasil dari operasi translasi.
2.2.4. Rotasi 3D
Transformasi rotasi merupakan suatu operasi yang
menyebabkan perpindahan objek 3D dari titik P ke titik P`
yang berupa permindahan berputar sebesar sudut .
Perputaran ini berlaku searah terhadap sumbu x, sumbu y,
dan sumbu z.
Untuk proses rotasi 3 dimensi, terdapat tiga macam
rotasi, yaitu rotasi terhadap sumbu X (rotationXMTX),
rotasi terhadap sumbu Y (rotationYMTX) dan rotasi pada
10
sumbu Z (rotationZMTX). Perbedaan dari masing-masing
matriks rotasi ini adalah peletakan nilai cos() dan sin().
Berikut rumus rotasi terhadap sumbu x, (Sumber:
Achmad Basuki, Nana Ramadijanti, “Grafika Komputer”,
Politeknik Elektronika Negeri Surabaya-ITS, Surabaya,
2009, halaman 19).
0 0 0 0
Rx = 0 cos() -sin() 0 (2.7)
0 sin() cos() 0
0 0 0 1
Berikut rumus rotasi terhadap sumbu y, (Sumber:

2009, halaman 20).
cos() 0 -sin() 0
Ry = 0 0 0 0 (2.8)
sin() 0 cos() 0
0 0 0 1
Berikut rumus rotasi terhadap sumbu z, (Sumber:

2009, halaman 21).
cos() -sin() 0 0
Rz = sin() cos() 0 0 (2.9)
0 0 0 0
0 0 0 1
2.3. Steady-State Genetic Algorithm (SSGA)

Algoritma Genetika (Genetic Algorithms, GA) diusulkan
pertama kali oleh John Holland dan kolega-koleganya di
Universitas Michigan untuk aplikasi cellular automata. Teknik ini
menjadi populer di antara saintis dan rekayasawan seluruh dunia
11
untuk memecahkan optimisasi mereka. Algoritma Genetika adalah
algoritma yang memanfaatkan proses seleksi alamiah yang dikenal
dengan proses evolusi. Dalam proses evolusi, individu secara terus-
menerus mengalami perubahan gen untuk menyesuaikan dengan
lingkungan hidupnya. “Hanya individu-individu yang kuat yang
mampu bertahan”. Proses seleksi alamiah ini melibatkan perubahan
gen yang terjadi pada individu melalui proses perkembangbiakan.
Dalam algoritma genetika ini, proses perkembangbiakan ini
menjadi proses dasar yang menjadi perhatian utama, dengan dasar
berpikir: “Bagaimana mendapatkan keturunan yang lebih baik”.
GA secara khusus dapat diterapkan untuk memecahkan masalah
optimisasi yang kompleks. Karena itu GA baik untuk aplikasi yang
memerlukan strategi pemecahan masalah secara adaptif. Salah satu
macam dari algoritma genetika adalah steady-state genetic
algorithm.
Steady state genetic algorithm ini awalnya dilakukan
pembangkitan individu, kemudian dilakukan penggantian beberapa
individu dalam beberapa generasi. Individu terburuk akan diganti
dengan individu baru hasil dari crossover dan mutasi. Untuk proses
crossover ini digunakan elitist crossover dimana secara acak
mendapatkan satu induk dan nilai gennya dikombinasikan dengan
individu terbaik. Untuk menghemat waktu komputasi, maka induk
yang dihasilkan secara acak diganti dengan individu terburuk.
Sedangkan untuk mutasi digunakan adaptive mutation yang
memang sangat baik untuk mencapai lokal optima. Dipilihnya
metode ini daripada metode GA yang lainnya karena prosesnya
sangat cepat.
2.4. Labyrinth
Labyrinth adalah salah satu bagian permainan teka-teki yang
memiliki percabangan yang kompleks dan pemain harus dapat
menemukan rute keluar. Sejak zaman dahulu, labyrinth telah
digunakan dalam berbagai kepentingan, mulai dari proteksi
keamanan hingga hiburan. Pada umumnya, labyrinth dibuat untuk
tujuan hiburan.
Labyrinth dalam dunia nyata banyak dibuat di taman atau
ruangan-ruangan dengan pembatas berupa pagar tanaman, tembok
atau pagar. Labyrinth ini secara tidak langsung menyesatkan orang
yang masuk ke dalamnya. Labyrinth untuk permainan biasanya
12
dicetak dalam sebuah kertas untuk diselesaikan oleh pemain.
Permainan dilakukan dengan cara menuliskan jalan yang telah
ditempuh menggunakan pensil atau hanya dengan menunjuk
jalannya menggunakan jari. Labyrinth terbagi menjadi beberapa
kategori sesuai jenisnya, yaitu labyrinth 2 dimensi, 3 dimensi,
berbentuk segitiga, persegi, dan masih banyak lagi.
Gambar 2.1. Labyrinth

Sumber : http://ciricara.com
(diakses pada tanggal 9 Juli 2012, jam 21.00)
2.4.1. Game Labyrinth 3D

Game labyrinth adalah game untuk mencari jalan
keluar. Pembahasan game tidak bisa lepas dari matematika
dan fisika. Struktur game labyrinth: Game labyrinth terdiri
dari dua komponen utama, yaitu player dan tembok. Untuk
mempermudah pembuatan game, tembok diganti dengan
kubus yang disusun-susun secara berjejer-jejer membentuk
tembok, jalan, tikungan dan lain sebagainya. Struktur ini
adalah struktur yang paling banyak dipakai karena
kemudahannya.
Karena game ini adalah game 3D, maka player utama

tidak diperlihatkan. Permainan mengambil sudut pandang
dari orang pertama. Apa yang tampak dilayar adalah apa
yang tampak dari "mata" player utama. Player utama
biasanya diberi istilah kamera, karena prosesnya memang
mirip dengan kamera.
13
Gambar 2.2. Sudut pandang player dalam game
Sumber : http://najicayuri.blogspot.com
(diakses pada tanggal 10 September 2011, jam 14.00)
Dalam gambar di atas ada istilah FOV (Field of View)

atau area pandangan. Semua yang berada di area FOV akan
tampak oleh player utama/kamera dan akan tampak pula di
layar. FOV dari atas akan tampak seperti trapesium, walau
bentuk sebenarnya dari FOV adalah mirip limas yang
dipotong di ujungnya, dikenal juga dengan istilah frustum.
Gambar 2.3. Area pandangan

Sumber : http://wartawarga.gunadarma.ac.id
(diakses pada tanggal 9 Juli 2012, jam 21.30)
Garis merah adalah batas dekat penglihatan/layar

(jaraknya terserah, tapi jarak standard yang dipakai adalah
160). Garis biru adalah batas kiri, kanan, atas, dan bawah
penglihatan. FOV biasanya memiliki besar sudut 90 derajat
untuk sudut yang berada di bawah. Hal ini untuk
memudahkan dalam perhitungan selajutnya.
14
Semua yang berada dalam wilayah FOV akan
diproyeksikan ke layar, dan hasilnya akan tampak seperti
gambar di bawah ini.
Gambar 2.4. Field of View
Berikut salah satu contoh game labyrinth 3D adalah 3D

Maze Survival. Game ini dibuat dengan menggunakan
Adobe Flash. Untuk memainkannya menggunakan arah
panah pada keyboard. Game ini merupakan game labyrinth
dikutip karena jalan-jalan didalamnya cukup mengasyikkan.
Gambar 2.5. 3D Maze Survival

Sumber : http://dawgsdk.cside.com/maze3d/
(diakses pada tanggal 12 September 2011, jam 15.00)
15
Halaman Ini Sengaja Dikosongkan
16
BAB III
PERENCANAAN DAN PEMBUATAN SISTEM
Pada bab ini akan dipaparkan perencanaan dan pembuatan

perangkat lunak secara keseluruhan, dimana dalam proyek akhir ini,
terdiri dari dua sub besar perangkat lunak, yaitu deteksi gerakan kepala
player dan pembuatan game.
3.1. Desain Sistem

Sebelum sistem diimplementasikan, terlebih dahulu dibuat
sistematika perancangan yang mepresentasikan keseluruhan sistem
agar didapatkan hasil yang maksimal.
Generate Individu
Scalp Color Modeling

Selection
Head Detection
Elitists Crossover
Head Tracking
Adaptive Mutation
Game Labyrinth
Gambar 3.1. Blok diagram sistem
Blok diagram sistem di atas, merupakan keseluruhan proses

untuk mengimplementasikan proyek akhir ini. Dimana pada
awalnya gambar kepala player yang ditangkap berupa nilai RGB.
17
Kemudian gambar diproses awalnya dilakukan Scalp Color
Modeling untuk menentukan warna rambut (hitam), warna kulit
(cokelat) dan warna lainnya (putih). Kemudian dilakukan Head
Detection menggunakan metode SSGA, dari hasil SSGA akan
dilakukan Head Tracking dan dilakukan keputusan apakah gerakan
kepala maju, kiri, dan ke kanan melebihi nilai yang ditentukan
untuk menggerakkan karakter di dalam game.
3.2. Proses Teknis Pengambilan Gambar

Pembahasan kali ini akan menjelaskan bagaimana teknis untuk
mendapatkan gambar yang nantinya akan diproses lebih lanjut.
Untuk proses pengambilan gambar obyek, akan menggunakan
library OpenCV yang telah tersedia secara gratis.
Beberapa modul OpenCV antara lain :
a. cv – merupakan fungsi-fungsi utama OpenCV,
b. cvaux – merupakan fungsi tambahan (eksperimental)
OpenCV,
c. highgui – merupakan fungsi yang menangani masalah
GUI.
Header file OpenCV :

a. #include “OpenCV/OpenCV.h”
b. #include “OpenCV/cvaux.h”
c. #include “OpenCV/highgui.h”
Berikut ini program inisialisasi kamera :
IplImage
*img=cvCreateImage(cvSize(360,240),8,3);
CvCapture *capture = 0;
IplImage *frame = 0;
capture = cvCaptureFromCAM( 0 );
if ( !capture ) {
fprintf( stderr, "Cannot open
initialize webcam!\n" );
return1;
}
18
frame = cvQueryFrame( capture );
if( !frame ) break;
cvShowImage( "original", img);
Penjelasan program di atas sebagai berikut :

1. Deklarasi window dengan ukuran 360 x 240 dan
disimpan di img.
2. Deklarasi variable CvCapture dan IplImage.
3. Inisialisasi kamera, mengambil gambar dari kamera
dan ditampung di capture.
4. Kemudian jika kamera tidak terdeteksi maka akan
muncul peringatan error.
5. Variabel frame menyimpan gambar dari capture.
6. Jika frame tidak ada atau kosong maka program akan
berhenti.
7. Kemudian ditampilkan pada window dengan nama
“original”.
Hasil capture dari kamera :
Gambar 3.2. Hasil capture dari kamera
3.3. Scalp Color Modeling

Karena gambar yang ditangkap oleh kamera memiliki struktur
warna yang menggunakan sistem Red Green Blue (RGB) maka
perlu kita lakukan scalp color modeling yang berguna untuk
memodelkan warna kulit, sistem warna RGB ditransformasikan ke
sistem warna YCrCb untuk memisahkan intensitas Y dengan
chromaticity yang dinyatakan dalam dua variabel Cr dan Cb. Harga
Cr membedakan warna antara jarak intensitas terhadap unsur
19
warna merah sedangkan Cb menyatakan jarak intensitas terhadap
unsur warna biru. Dalam memodelkan warna kulit hanya informasi
Cr dan Cb yang dipakai, sehingga pengaruh perubahan intensitas
dapat dihilangkan. Pada daerah saturasi dari cahaya yang
tertangkap kamera, harga Cr dan Cb sangat stabil, sehingga nilai Cr
dan Cb merupakan informasi handal untuk proses klasifikasi
warna. Untuk mengubah citra berwarna yang mempunyai nilai
matrik masing-masing r, g, dan b menjadi citra warna YCrCb dapat
dilakukan dengan menghitung seperti pada persamaan (2.1), (2.2),
dan (2.3).
Berikut program mendeteksi warna kulit :
floatr = data[i * step + j * channel + 2], g =

data[i * step + j * channel + 1], b = data[i *
step + j * channel + 0];
y =(int)(0.59*g+0.31*r+0.10*b);
cr = (int)(0.713*(r-y));
cb = (int)(0.564*(b-y));
jarak=sqrt(pow((cr-11),(double)2))+(pow((cb+11),
(double)2));
if(jarak<90) {
data[i * step + j * channel + 2]=230;
}
elseif(r>30 || g>30 || b>30)
{
}
else
{
}
20
1. Pertama kita ambil nilai RGB dari setiap pixel.
2. Kemudian nilai-nilai RGB tadi kita rubah ke YCrCb
dengan rumus yang telah ditentukan.
3. Kemudian kita hitung jarak intensitas warna merah dan
biru.
4. Kemudian jika jarak < 90 kita rubah menjadi warna coklat
dengan nilai R=230, G=190, dan B=100, jika R>30,
G>30, dan B>30 maka kita rubah menjadi putih, dengan
merubah nilai RGB menjadi 255, selain ketentuan tadi
kita rubah RGBnya menjadi hitam dengan nilai RGB
menjadi 0.
Hasil scalp color modeling :
Gambar 3.3. Hasil scalp color modeling
3.4. Head Detection

Setelah proses scalp color modeling selesai, proses selanjutnya
yaitu head detection. Metode yang digunakan yaitu Steady-State
Genetic Algorithm (SSGA).
21
START
Random Individu
For i < 5
Selection
Elitist Crossover
Adaptive Mutation
N
i>5
Coordinate of Head Found
END
Gambar 3.4. Flowchart Head Detection
Awalnya, komputer mambangkitkan individu secara acak

sebanyak n buah. Individu tersebut terdiri dari gen-gen. Gen
tersebut terdiri dari posisi koordinat [xi, yi, lebari, tinggii] sehingga
menghasilkan gambar kotak.
22
xi,yi
tinggii
lebari
Gambar 3.5. Individu yang dibangkitkan
Gambar di atas merupakan individu yang dibangkitkan.

Individu di atas terdiri dari gen [xi, yi, lebari, tinggii].
Gambar 3.6. 50 individu yang dibangkitkan secara acak
Gambar di atas menunjukkan 50 individu yang dibangkitkan

secara acak. Gambar kotak berwarna biru menunjukkan individu
yang dibangkitkan. Gen-gen dari masing-masing individu di atas
terdiri posisi [xi, yi, lebari, tinggii].
Gen-gen yang dibangkitkan harus dibatasi range randomnya,

karena jika tidak individu akan melebihi frame dari window. Selain
dibatasi randomnya, harus dibatasi juga lebar tidak boleh melebihi
1,3 dari tinggi, dan tinggi tidak boleh melebihi 1,3 dari lebar.
23
Berikut program membangkitkan individu :
for (int i=0;i<jmlindi; i++){

x[i]=rand()%360;
y[i]=rand()%240;
width[i]=rand()%150;
height[i]=rand()%150;
if(width[i]>=1.3*height[i])
height[i]=width[i];
if(height[i]>=1.3*width[i])
width[i]=height[i];
xa[i]=x[i]+width[i];
ya[i]=y[i]+height[i];
if(xa[i]>=360)
xa[i]=359;
if(ya[i]>=240)
ya[i]=239;
cvDrawRect(src,cvPoint(x[i],y[i]),cvPoint(xa[i],ya
[i]),cvScalar(255,0,0,0),1);
}
1. Individu dibangkitkan sebanyak n yang ditentukan.

2. Kemudian xi, yi, widthi, dan heighti di-random dengan
nilai yang telah ditentukan untuk batas maksimalnya.
3. Kemudian widthi diberi batas agar tidak melebihi 1,3 x
heighti begitu pula heighti diberi batas agar tidak
melebihi 1,3 x widthi.
4. xai merupakan penjumlahan nilai dari xi dan widthi,
dan yai merupakan penjumlahan nilai dari y i dan
heighti. Hal ini bertujuan untuk menggambar individu
dari koordinat xi,yi hingga xai,yai.
5. xai dan yai juga harus dibatasi agar tidak melewati
frame window.
Setelah membangkitkan individu, proses selanjutnya yaitu

seleksi, dengan cara menghitung nilai fitness dari masing-masing
individu. Namun sebelum dilakukan perhitungan nilai fitness,
dilakukan pembuatan template kepala manusia agar dapat
24
dilakukan perhitungan nilai fitness. Untuk memodelkan kepala
manusia, maka perlu dibuat template dari kepala manusia seperti
berikut :
warna rambut
warna kulit
warna lain
Gambar 3.7. Template kepala manusia
Setelah dibuat template kepala manusia maka dapat dilakukan

perhitungan nilai fitness. Proses ini bertujuan untuk mencari
individu terbaik yang nantinya akan menjadi induk untuk
menghasilkan keturunan-keturunan yang baru. Untuk proses
seleksi ini, individu akan diseleksi dengan mencari individu
dengan nilai fitness terbaik dan terburuk. Individu yang semakin
dekat dengan kepala manusia mempunyai nilai fitness yang
semakin besar. Setelah didapatkan, maka kedua individu tersebut
akan diproses dengan crossover dan mutasi. Untuk menghitung
nilai fitness, digunakan persamaan sebagai berikut, (Sumber:
Ferman Hakiki, “Rancang Bangun Robot Pantilt: Pendeteksian
Posisi Kepala Manusia Menggunakan Algoritma Genetika”,
PENS-ITS, Surabaya, 2009, halaman 31).
ƒiHe=Ckulit
Kp
wajah
Kp
+ Crambut+ η1Kp.CKpkulit wajah
.CKp rambut
- η2Kp.CKp lainya
(3.1)
Dimana :
ƒiHe = nilai fitness
CKp = jumlah piksel warna kulit wajah
kulit wajah
Kp
Crambut = jumlah piksel warna rambut
CKp = jumlah piksel warna lainnya
lainya
25
η1Kp dan η2Kp = koefisien warna rambut, warna kulit dan warna
lain yang bernilai antara 0 sampai 1.
Berikut program untuk menghitung nilai fitness :
intr = data[i * step + j * channel + 2], g =

data[i * step + j * channel + 1], b = data[i *
step + j * channel + 0];
if(r==0&&g==0&&b==0)
hair++;
elseif(r==230&&g==190&&b==100)
skin++;
else
other++;
sum_hair[index][k][l]=hair;
sum_skin[index][k][l]=skin;
sum_other[index][k][l]=other;
fit_func[index][k][l]=(sum_hair[index][k][l]
+sum_skin[index][k][l]+(0.9*sum_hair[index][k]
[l]*sum_skin[index][k][l])-(0.1*sum_other[index]
[k][l]))/100;
1. Pertama program mengambil nilai RGB dari setiap

pixel.
2. Jika RGB yang didapat bernilai 0, maka variabel hair
kita tambahkan nilainya.
3. Jika R=230, G=190, dan B=100, maka variabel skin
kita tambahkan nilainya.
4. Jika nilai RGB-nya selain dari nilai yang ditentukan
tadi maka variabel other kita tambahkan nilainya.
5. Kemudian kita masukkan variabel hair, skin, dan other
ke dalam rumus untuk menghitung nilai fitness.
Setelah proses seleksi dari menghitung nilai fitness yang

terbaik, maka dilakukan proses selanjutnya yaitu crossover. Untuk
proses crossover ini digunakan elitist crossover dimana secara acak
mendapatkan satu induk dan nilai gennya dikombinasikan dengan
26
individu terbaik. Untuk menghemat waktu komputasi, maka induk
yang dihasilkan secara acak diganti dengan individu terburuk.
[xterbaik, yterbaik, lebarterbaik, tinggiterbaik] gen individu terbaik

[xterburuk, yterburuk, lebarterburuk, tinggiterburuk] gen individu terburuk
Gen-gen individu terbaik dikombinasikan dengan gen-gen individu

terburuk.
[xterbaik, yterbaik, lebarterbaik, tinggiterbaik] gen individu terbaik

[xterbaik, yterbaik, lebarterbaik, tinggiterbaik] gen individu terburuk
Berikut program untuk crossover:
P=(double)rand()/(double)RAND_MAX;
if (P<PROB_CROSSOVER) {
arrayindi[i][0]=arrayindi[bestFitness][0];
arrayindi[i][4]=arrayindi[i]
[0]+arrayindi[i][2]; arrayindi[i]
[5]=arrayindi[i][1]+arrayindi[i][3];
}
1. Jika variabel P yang dirandom lebih kecil dari

probabilitas crossover yang telah ditentukan, maka
proses crossover dilakukan.
2. Gen-gen dari individu yang buruk xi, yi, lebari dan
tinggii dikombinasikan dengan individu terbaik.
Setelah proses crossover maka selanjutnya adalah adaptive

mutation, (Sumber: Ferman Hakiki, “Rancang Bangun Robot
Pantilt: Pendeteksian Posisi Kepala Manusia Menggunakan
Algoritma Genetika”, PENS-ITS, Surabaya, 2009, halaman 34).
(
gi , j ← gi , j + ∝ j .
fit max−fit i
)
+ β . N (0 , 1)
fit max−fit min j
(3.2)
27
Dimana fiti adalah nilai fitness dari individu ke i, fitmax dan fitmin
adalah nilai fitness maksimal dan minimal dalam suatu populasi,
N(0,1) adalah nilai acak dari 0 sampai 1. αj dan βj adalah koefisien
dan offset. Proses mulai dari seleksi, crossover dan mutasi ini akan
berlangsung sampai nilai maksimal iterasi tercapai atau nilai fitness
yang dihasilkan tidak berubah.
Berikut program untuk adaptive mutation :
P=(double)rand()/(double)RAND_MAX;
n=(double)rand()/(double)RAND_MAX;
a=(double)rand()/(double)RAND_MAX;
b=a+1;
if(P<PROB_MUTATION){
arrayindi[i][0]+=((a*((totfit[bestFitness]-
totfit[i])/(totfit[bestFitness]-
totfit[badFitness])))+b)*n;
arrayindi[i][4]=arrayindi[i][0]+arrayindi[i]
[2];
arrayindi[i][5]=arrayindi[i][1]+arrayindi[i]
[3];
if(arrayindi[i][4]>=360)
arrayindi[i][4]=359;
if(arrayindi[i][5]>=240)
arrayindi[i][5]=239;
}
1. Jika variabel P yang dirandom lebih kecil dari

probabilitas mutasi yang telah ditentukan, maka proses
adaptive mutation dilakukan.
28
2. Gen-gen dari individu yang buruk x,y, lebar dan tinggi
diganti dengan hasil dari proses perhitungan adaptive
mutation.
Setelah semua proses telah dilakukan, maka kepala player

dapat terdeteksi.
Gambar 3.8. Hasil deteksi kepala menggunakan SSGA
3.5. Head Tracking

Setelah didapatkan hasil dari head detection, maka proses
selanjutnya adalah head tracking. Proses dari head tracking yaitu
dari beberapa individu dengan fitness terbaik diambil rata-ratanya,
kemudian rata-rata itu yang dijadikan koordinat untuk dijadikan
koordinat dari kepala player yang baru. Berikut program untuk
head tracking :
if(count!=4){
temp_gen[0]+=arrayindi[bestFitness][0];
count++;
}else{
29
temp_gen[0]/=5;
temp_gen[1]/=5;
temp_gen[2]/=5;
temp_gen[3]/=5;
temp_gen[4]/=5;
temp_gen[5]/=5;
fix_gen[0]=temp_gen[0];
temp_gen[0]=0;
temp_gen[1]=0;
temp_gen[2]=0;
temp_gen[3]=0;
temp_gen[4]=0;
temp_gen[5]=0;
count=0;
}
cvDrawRect(img,cvPoint(fix_gen[0],fix_gen[1]),cvPo
int(fix_gen[4],fix_gen[5]),cvScalar(0,0,255,0),1);
Penjelasan program di atas sebagi berikut :
1. Awalnya gen-gen dari individu yang terbaik disimpan
dalam variabel temp_gen dan terus ditambahkan setiap
iterasi.
2. Jika sampai iterasi yang ditentukan, maka gen-gen
individu tadi dibagi sebanyak iterasi yang dilakukan.
3. Kemudian hasil bagi tadi ditampung dalam variabel
fix_gen dan variabel temp_gen dikembalikan ke 0 lagi
nilainya.
4. Barulah kita gambarkan hasil tadi untuk membentuk
koordinat baru.
Setelah head tracking tadi proses selanjutnya adalah

menentukan jika gerakan kepala bergerak maju, ke kanan dan ke
kiri memberikan nilai. Prosesnya dengan memberikan batasan nilai
pada koordinat xi dan yi. Berikut program untuk menentukan
gerakan :
if(fix_gen[0]>210){
yrot-=5.0f;
30
}
elseif(fix_gen[0]<30){
yrot+=5.0f;
}
elseif(fix_gen[1]<50){
xpos -= (float)sin(yrot*piover180) * 0.1f;
zpos -= (float)cos(yrot*piover180) * 0.1f;
}
x
0 360
xi,yi
y
240
Gambar 3.9. Batas-batas
1. fix_gen[0] menyimpan gen x, jadi jika koordinat x >

210 maka karakter akan berputar menghadap ke arah
kanan, dan jika koordinat x < 30 maka karakter akan
berputar menghadap ke arah kiri.
2. fix_gen[1] menyimpan gen y, jadi jika koordinat y <
50 maka karakter akan bergerak maju.
Hasil keputusan di atas akan diintegrasikan dalam game

labyrinth. Untuk perpindahan karakter dalam game.
3.6. Game Labyrinth

Pembuatan game labyrinth dibagi menjadi 2 bagian besar, yaitu
pembuatan dunia labyrinth itu sendiri, dan menyediakan kontrol
agar player atau dalam labyrinth sebenarnya kamera dapat
bergerak menjelajahi labyrinth.
3.6.1. Menggambar Peta
31
Peta dalam OpenGL dapat dibuat secara 2D atau 3D.
Pada game labyrinth ini peta yang dibuat adalah peta dalam
2D. Berikut program untuk membuat peta:
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -0.1f);
glBindTexture(GL_TEXTURE_2D, texture[71]);
glBegin(GL_QUADS);
glVertex3f(-0.049f, 0.006f, 0.0f);//1
glVertex3f( -0.0455f, 0.006f, 0.0f);
glVertex3f( -0.0455f, 0.0065f, 0.0f);
glVertex3f(-0.049f, 0.0065f, 0.0f);
glEnd();
glLoadIdentity();
glTranslatef(gerakpanahx, gerakpanahy, -
0.1f);
glRotatef(panahrot, 0.0f, 0.0f, 1.0f);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-
0.0001f, 0.001f, 0.0f);//7
glTexCoord2f(1.0f, 0.0f); glVertex3f(
0.0001f, 0.001f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(
0.0008f, -0.001f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-
0.0008f, -0.001f, 0.0f);
glEnd();
Penjelasan program di atas sebagai berikut:
1. Program membuat kotak-kotak/persegi dengan
koordinat z = -0.1.
2. Kotak-kotak tersebut akan disusun sehingga
menyusun suatu peta.
3. Kemudian program membuat suatu segitiga
sebagai pengganti karakter pada peta yang
menunjukkan pergerakan.
4. glTranslatef men-translasi pada koordinat x dan
y dengan variabel gerakpanahx dan
gerakpanahy. Variabel tersebut dapat berubah
nilainya.
32
5. glRotate berfungsi untuk merotasi karakter,
karena nilai 1 diisi pada koordinat z, maka
karakter berotasi terhadap sumbu z.
Gambar 3.10. Peta pada game labyrinth
3.6.2. Menggambar Tembok

Tembok dalam OpenGL dapat berupa bangun persegi
dalam 2D atau kubus dalam 3D. Pada game labyrinth ini
tembok yang dibangun adalah tembok dalam 2D. Berikut
program untuk membangun tembok :
Image *image1;
image1 = (Image *) malloc(sizeof(Image));
if (image1 == NULL) {
printf("Error allocating space for
image");
exit(0);
}
if (!
ImageLoad("/Users/wais/Desktop/labyrinth
buat progres/labyrinth/lantai1.bmp",
image1)) {
exit(1);
}
glGenTextures(1, &texture[0]);
33
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG
_FILTER,GL_NEAREST); // scale cheaply when
image bigger than texture
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN
_FILTER,GL_NEAREST); // scale cheaply when
image smalled than texture
glTexImage2D(GL_TEXTURE_2D, 0, 3, image1-
>sizeX, image1->sizeY, 0, GL_RGB,
GL_UNSIGNED_BYTE, image1->data);
glClear(GL_COLOR_BUFFER_BIT |
GL_DEPTH_BUFFER_BIT);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.5f,
0.0f, -2.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 0.5f,
0.0f, -2.0f);
0.3f, -2.0f);
0.3f, -2.0f);
glEnd();
1. Awalnya program mengalokasikan memori.
2. Kemudian mengambil alamat gambar tersebut,
dan selanjutnya membuat tekstur ke dalam 2D.
3. Kemudian program mengatur gambar jika
gambar lebih besar atau lebih kecil dari tekstur,
maka gambar dibuat agar pas dengan tekstur.
4. Selanjutnya program melakukan clear screen
dan depth buffer.
5. Kemudian memasang teksture pada bidang
tembok. Tekstur yang digunakan diambil dari
gambar berformat bitmap.
6. glVertex3f merupakan koordinat letak gambar
tembok pada labyrinth, sedangkan
glTexCoord2f merupakan koordinat 4 titik
sudut pada persegi. Penentuan 4 titik tersebut
harus tepat dan bersambungan, agar pada saat
34
tekstur digambarkan pada bidang tembok,
gambar tekstur tidak terbalik.
Gambar 3.11. Tembok-tembok pada game labyrinth
3.6.3. Menampilkan Pertanyaan

Dalam game labyrinth diberikan pertanyaan-pertanyaan
ketika pemain telah melewati tembok yang memberikan alur cerita
yang benar. Pertanyaan yang diberikan merupakan pemanggilan
texture. Berikut program menampilkan pertanyaan:
GLvoid pertanyaan19(void)
{
glLoadIdentity();
if (w2==0){
xper2=rand()%1;
w2=1;
//printf("%d\n",xper);
}
hasilp2=xper2+97;
glBindTexture(GL_TEXTURE_2D,
texture[hasilp2]);
glBegin(GL_QUADS);
35
-0.025f, 0.0f);//1
-0.025f, 0.0f);
0.025f, 0.0f);
0.025f, 0.0f);
glEnd();
}
if
(((xpos2>=8.399998f)&&(xpos2<=8.499998f))&&((zpos2
>=-21.400036f)&&(zpos2<=-
20.500032f))&&(pertanyaanlevel2==1)) {
pertanyaan19();
}
if
(((xpos2>=8.399998f)&&(xpos2<=8.499998f))&&((zpos2
>=-21.400036f)&&(zpos2<=-
20.500032f))&&(kiriper2==1)) {
xper2++;
if(xper2>1)
xper2=0;
pertanyaan19();
kiriper2=0;
}
if
(((xpos2>=8.399998f)&&(xpos2<=8.499998f))&&((zpos2
>=-21.400036f)&&(zpos2<=-
20.500032f))&&(kananper2==1)) {
pertanyaanlevel2=0;
xpos2=8.399997f;
//gerakpanahx2=-0.0422f;
kananper2=0;
}
Penjelasan program di atas sebagai berikut:
1. Program membuat suatu tampilan persegi, dengan
menampilkan texture gambar berformat bitmap,
dengan texture gambar yang ditampilkan tersebut
diacak, dari 3 gambar yang diacak akan
ditampilkan satu.
36
2. Kemudian, jika player sampai pada koordinat
tertentu misalnya pada program 8,5>xpos2>=8,4
dan -20,5>zpos2>-21,4, maka pertanyaan
ditampilkan.
3. Player harus menjawab pertanyaan untuk
melanjutkan permainan, ketika player menjawab
jawaban yang benar, maka pertanyaan menghilang
dan permainan dilanjutkan. Ketika player
menjawab pertanyaan yang salah maka program
kembali menampilkan pertanyaan tersebut yang
sudah diacak kembali.
Gambar 3.12. Tampilan pertanyaan
3.6.4. Load Texture

Dalam game tembok-tembok yang digambar semuanya
menggunakan texture. Mulai dari tembok yang bergambar batu
bata sampai tembok yang memberikan petunjuk dalam bentuk
cerita. Berikut program load texture:
Image *image2;
image2 = (Image *) malloc(sizeof(Image));

if (image2 == NULL) {
printf("Error allocating space for image");
exit(0);
}
if (!ImageLoad("/Users/wais/Desktop/coba
menu/10111945.bmp", image2)) {
exit(1);
37
}
glGenTextures(1, &texture[4]);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTE
R,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTE
R,GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, 3, image2-
>sizeX, image2->sizeY, 0, GL_RGB,
GL_UNSIGNED_BYTE, image2->data);

1. Awalnya program mengalokasikan memori. Jika
gagal mengalokasikan maka akan muncul
peringatan.
2. Program mengecek apakah alamat untuk
memanggil gambarnya sudah benar, jika tidak
maka program akan berhenti.
3. Kemudian program akan menyimpannya dalam
array, agar mudah dalam memanggilnya nanti.
3.6.5. Menghitung Waktu

Dalam game juga terdapat waktu selama 10 menit. Jika
dalam batas waktu itu pemain masih juga belum dapat
menyelesaikan game labyrinth maka permainan akan berakhir atau
disebut gameover. Berikut program menghitung waktu :
sec_now=clock()/1250000;
if(sec_last!=sec_now){
if(batasdetik==0){
batasdetik=60;
menit--;
}
batasdetik--;
sec_last=sec_now;
}
char timeSTR[10],menitSTR[10];
sprintf(menitSTR,"%d",menit);
sprintf(timeSTR,"%d",batasdetik);
38
glLoadIdentity();
bitmap_output(0.02f,0.04f,0.0f, "TIME :
",GLUT_BITMAP_TIMES_ROMAN_24);
bitmap_output(0.037f,0.04f,0.0f, " :
",GLUT_BITMAP_TIMES_ROMAN_24);
bitmap_output(0.04f,0.04f,0.0f,
timeSTR,GLUT_BITMAP_TIMES_ROMAN_24);
bitmap_output(0.035f,0.04f,0.0f,
menitSTR,GLUT_BITMAP_TIMES_ROMAN_24);
Penjelasannya sebagai berikut :
1. Program awalnya memanggil fungsi clock() dari
library “time.h”. Kemudian meyimpannya dalam
variabel, karena fungsi clock() berjalan ketika
program dijalankan dan tidak akan berhenti sampai
program berhenti.
2. clock()/1250000 artinya waktu yang berjalan
dijadikan detik. Karena jika tidak dibagi 1250000,
waktu yang berjalan berformat mikro detik.
3. Kemudian program menyiapkan variabel
batasdetik dan menit, batasdetik mempunyai nilai
60 dan menit mempunyai nilai 9. Kedua variabel
tersebut akan berkurang seiring dengan
bertambahnya detik di fungsi clock().
4. Kemudian program menampilkannya dalam game
labyrinth. Dengan fungsi bitmap_output. Karena
fungsi itu hanya bisa membaca variabel bertipe
char, dan variabel batasdetik dan menit bertipe
integer, maka perlu dilakukan perubahan terlebih
dahulu menggunakan sprintf.
3.6.6. Menentukan Collision

Collision disini artinya tabrakan atau lebih tepatnya
tabrakan antara karakter dan tembok agar karakter tidak berjalan
melebihi atau menembus tembok.
A B
39
Gambar 3.13. Ilustrasi collision
Titik A dan B merupakan titik-titik ujung dari tembok, titik

A dan B sendiri juga mempunyai koordinat x, y, dan z. Titik C
merupakan karakter yang akan bergerak menabrak tembok. Titik C
juga mempunyai koordinat x, y, dan z. Jadi ketika titik C menabrak
tembok, maka kita beri batasan. Ketika titik C menabrak tembok
koordniat x atau z nya diberi nilai yang sama dengan koordinat
titik A dan B. Dengan begitu titik C tidak akan bergerak melewati
atau menembus titik A dan B. Berikut programnya :
if(((zpos2<=-11.79f)&&(zpos2>=-
11.90f))&&((xpos2<=9.5f)&&(xpos2>=8.4f)))
zpos2=-11.90f;
Penjelasannya sebagai berikut :

1. Program memberikan batasan ketika zpos2 berada
di antara -11.79 dan -11.90 dan xpos2 berada di
antara 9.5 dan 8.4 maka zpos2 diberi nilai -11.90
3.6.7. Menentukan Gerak Karakter

Gerak karakter dalam game labyrinth ini adalah maju,
kanan, dan kiri. Sebenarnya pada gerak maju, objek dalam game
ditranslasi searah sumbu x atau z , kemudian gerak kanan dan kiri
sebenarnya objek dalam game dirotasi terhadap sumbu y. Berikut
program gerak karakter :
if(fix_gen[0]>200){
yrot-=5.0f;
}
if(fix_gen[0]<40){
yrot+=5.0f;
}
if(fix_gen[1]<58){
xpos -= (float)sin(yrot*piover180) * 0.1f;
zpos -= (float)cos(yrot*piover180) * 0.1f;
}
switch (key) {
caseGLUT_KEY_UP:
xpos -= (float)sin(yrot*piover180) *
40
0.5f;
zpos -= (float)cos(yrot*piover180) *
0.5f;
printf("maju\n");
printf("%f %f %f\
n",xtrans,ytrans,ztrans);
break;
caseGLUT_KEY_LEFT:
yrot += 30.0f;
printf("kiri\n");
printf("%f %f %f\
break;
caseGLUT_KEY_RIGHT:
yrot -= 30.0f;
printf("kanan\n");
printf("%f %f %f\
break;
}
Penjelasan program di atas sebagai beikut :
1. Jika fix_gen[0] atau koordinat x > 200 maka
karakter berputar ke arah kanan dan objek dirotasi
terhadap sumbu negatif y.
2. Jika fix_gen[0] atau koordinat x < 40 maka
karakter berputar ke arah kiri dan objek dirotasi
terhadap sumbu positif y.
3. Jika fix_gen[1] atau koordinat y < 58 maka
karakter bergerak maju dan dilakukan translasi
sumbu x atau z berdasarkan posisi karakter.
4. Jika tombol panah atas pada keyboard ditekan
maka karakter bergerak maju dan dilakukan
translasi sumbu x atau z berdasarkan posisi
karakter.
5. Jika tombol panah kiri ditekan maka karakter
berputar ke arah kiri dan objek dirotasi terhadap
sumbu positif y.
41
6. Sebaliknya jika tombol panah kanan ditekan maka
karakter berputar ke arah kiri dan objek dirotasi
terhadap sumbu negatif y.
Gambar 3.14. Gerak karakter
3.7. Skenario Game

Game labyrinth juga mempunyai skenario di dalamnya. Mulai
dari tampilan awal sampai keluar dari game.
Gambar 3.15. Tampilan awal game
42
Ketika game dijalankan maka akan muncul tampilan seperti di
atas. Window yang sebelah kiri adalah tampilan dari webcam,
ketika kepala pemain bergerak ke kiri, maka karakter akan beputar
menghadap ke kiri, begitu pula jika kepala pemain bergerak ke
kanan dan maju. Window sebelah kanan merupakan menu dari
game labyrinth. Ada 5 tombol di game di atas.
1. Play
Tombol Play berfungsi untuk memulai memainkan game
labyrinth. Berikut tampilan jika tombol Play ditekan.
Gambar 3.16. Tampilan menu Play
Setelah tombol Play ditekan maka pemain bisa memilih

cerita mana yang dimainkan dalam labyrinth dengan menekan
tombol panah kanan dan kiri kemudian tekan “ENTER” untuk
memilih. Jika ingin kembali ke menu awal pemain bisa
menekan tombol “ESCAPE”.
43
Gambar 3.17. Tampilan ketika cerita yang dipilih
Perang 10 November 1945
Gambar 3.18. Tampilan ketika cerita yang dipilih

Perang Diponegoro
Setelah memilih cerita, maka pemain akan memasuki

labyrinth yang bertema sesuai cerita yang dipilih. Untuk
bergerak maju pemain dapat menggerakkan kepalanya maju,
dan untuk bergerak ke kanan dan ke kiri pemain dapat
menggerakkan kepalanya ke kanan dan ke kiri, walaupun
pemain masih dapat menggunakan tombol pada keyboard
untuk memainkannya, namun akan terasa lebih mengasyikkan
jika pemain bisa ikut bergerak dalam permainannya. Jika
pemain tersesat dan bingung tidak tahu arah kemana, maka
pemain bisa menekan tombol ‘h’ pada keyboard untuk
menampilkan map labyrinth.
44
Gambar 3.19. Tampilan ketika tombol ‘h’ ditekan
Dalam game terdapat petunjuk-petunjuk pada tembok

yang bisa membantu pemain menyelesaikan labyrinth.
Namun ada juga petunjuk pada tembok yang menyesatkan,
maka dari itu pemain harus pintar memilih alur cerita yang
benar, jika cerita itu bertema Perang 10 November 1945 maka
pemain harus mengikuti cerita yang bertema itu. Kemudian
setelah melewati petunjuk yang benar pada tembok, maka
akan muncul pertanyaan yang harus dijawab oleh pemain.
Pertanyaan tersebut berguna untuk menguji apakah pemain
sudah paham cerita pada petunjuk.
45
Gambar 3.20. Tampilan pertanyaan
Pemain dapat menjawab pertanyaan dengan memilih
jawaban yang benar dengan menggerakkan kepalanya ke arah
jawaban yang akan dipilih, bisa juga menggunakan keyboard.
Kemudian setelah pemain mengikuti alur yang benar dan
menjawab semua pertanyaan dengan benar, maka pemain
akan sampai di akhir labyrinth.
Gambar 3.21. Tampilan akhir labyrinth
Dalam game pemain bisa menekan tombol “ESCAPE”

jika ingin keluar ataupun ingin jeda sejenak yang disebut
pause.
46
Gambar 3.22. Tampilan pause
Ketika tombol “ESCAPE” ditekan maka akan ada dua

pilihan, yang pertama continue untuk melanjutkan permainan
dan exit untuk keluar ke menu awal. Dalam game labyrinth
ada waktu selama 10 menit yang membatasi pemain untuk
segera menyelesaikan labyrinth. Jika dalam waktu 10 menit
tersebut pemain tidak juga bisa menyelesaikan labyrinth
maka permainan akan berakhir atau disebut gameover.
Gambar 3.23. Tampilan ketika gameover
Ketika gameover pemain hanya bisa menekan tombol

“ESCAPE” untuk kembali ke menu awal, dan mengulang
permainan dari awal.
2. Learning
47
Tombol Learning berfungsi untuk menampilkan cerita
yang benar dari Perang 10 November 1945 dan Perang
Diponegoro.
Gambar 3.24. Tampilan menu Learning
Setelah tombol Learning ditekan pemain dapat memilih

cerita mana yang ingin dipelajari dengan menekan tombol
panah kanan dan kiri dan tombol “Enter” untuk memilih dan
tombol “ESCAPE” untuk kembali ke menu awal.
48
Gambar 3.25. Tampilan Learning Perang 10 November 1945
Gambar 3.26. Tampilan Learning Perang Diponegoro
Setelah memilih cerita mana untuk dipelajari, maka

pemain dapat menekan tombol panah kanan untuk membaca
cerita selanjutnya dan kiri untuk membaca cerita sebelumnya.
Tombol “ESCAPE” digunakan untuk kembali ke menu
sebelumnya.
3. Help
Tombol Help berfungsi untuk menampilkan bagaimana
cara bermain game labyrinth dengan benar sesuai rule.
49
Gambar 3.27. Tampilan menu Help
4. Credit
Tombol Credit berfungsi untuk menampilkan pihak mana
saja yang terlibat dalam pembuatan game labyrinth. Credit
merupakan salah satu bentuk apresiasi kepada pihak-pihak
tersebut.
Gambar 3.28. Tampilan menu Credit
5. Exit
Tombol Exit berguna untuk keluar dari aplikasi game
labyrinth.
Seperti yang telah dijelaskan sebelumnya, dalam game

labyrinth ini terdapat 2 level yang berbeda dan tentunya dengan
map labyrinth yang berbeda pula. Dalam game karakter bergerak
50
melewati tembok-tembok untuk menyelesaikan labyrinth. Agar
mudah maka diberikan petunjuk lewat cerita yang ada pada
tembok. Namun pada game labyrinth ini diberikan alur cerita yang
benar dan alur cerita yang salah. Jadi untuk menyelesaikan
labyrinth, player harus mengikuti alur cerita yang benar, dan alur
cerita yang salah akan membuat player tersesat. Berikut map
labyrinth untuk Perang 10 November 1945 beserta titik-titik
dimana lokasi petunjuk-petunjuk cerita dengan alur yang benar dan
salah:
S10
K L N
J M
S6
S9
I F
H G
D E
S1 C
A B
Gambar 3.29. Map labyrinth Perang 10 November 1945
Berikut alur cerita yang benar untuk cerita Perang 10

November 1945 yang didapat dari sumber
http://id.wikipedia.org/wiki/Peristiwa_10_November dan
http://umum.kompasiana.com/ :
Tabel 3.1. Alur cerita 10 November 1945 yang benar
51
B
52
E
53
H
54
K
55
N
Tabel 3.1 merupakan alur cerita yang harus dicari dan diikuti
player untuk menyelesaikan labyrinth dan menemukan EXIT.
Karena selain alur cerita yang benar juga terdapat alur cerita yang
salah, yang dapat menipu player dalam mengikuti alur cerita.
Berikut alur cerita yang salah, yang menyimpang dari alur cerita
pada tabel 3.1 yang didapat dari sumber
http://id.wikipedia.org/wiki/Jembatan_Merah,
http://id.wikipedia.org/wiki/Tugu_Pahlawan,
http://id.wikipedia.org/wiki/Kota_Surabaya,
http://www.surabaya.go.id/profilkota/ :
Tabel 3.2. Alur cerita 10 November 1945 yang salah
S1
56
S2
S3
S4
57
S5
S6
S7
58
S8
S9
S10
59
S11
S12
S13
60
S14
S15
S16
61
S17
Tabel 3.2 merupakan alur cerita yang tidak boleh diikuti oleh
player karena dapat membuat tersesat. Dalam game labyrinth di
setiap persimpangan akan diberikan alur cerita yang benar pada
tembok yang mengarah pada jalan yang benar, dan diberikan alur
cerita yang salah pada tembok yang mengarah pada jalan yang
salah.
Berikut map labyrinth untuk Perang Diponegoro beserta titik-
titik dimana lokasi petunjuk-petunjuk cerita dengan alur yang
benar dan salah:
F E
D S5
C S4
S2 B S3
A
S1
62
Gambar 3.30. Map labyrinth Perang Diponegoro
Berikut alur cerita yang benar untuk cerita Perang Diponegoro

yang didapat dari sumber
http://id.wikipedia.org/wiki/Perang_Diponegoro,
http://id.wikipedia.org/wiki/Diponegoro,
http://serbasejarah.wordpress.com/2009/04/01/perang-jawa-2-
latar-belakang-perang-diponegoro/,
http://warofweekly.blogspot.com/2010/09/perang-diponegoro-
korban-200-ribu-orang.html :
Tabel 3.3. Alur cerita Diponegoro yang benar
63
D
64
Tabel 3.3 merupakan alur cerita yang harus dicari dan diikuti
player untuk menyelesaikan labyrinth dan menemukan EXIT.
Karena selain alur cerita yang benar juga terdapat alur cerita yang
salah, yang dapat menipu player dalam mengikuti alur cerita.
Berikut alur cerita yang salah, yang menyimpang dari alur cerita
pada tabel 3.3 yang didapat dari sumber
http://id.wikipedia.org/wiki/Perang_Padri :
Tabel 3.4. Alur cerita Diponegoro yang salah
S1
S2
65
S3
S4
S5
66
Tabel 3.4 merupakan alur cerita yang tidak boleh diikuti oleh
player karena dapat membuat tersesat. Dalam game labyrinth di
setiap persimpangan akan diberikan alur cerita yang benar pada
tembok yang mengarah pada jalan yang benar, dan diberikan alur
cerita yang salah pada tembok yang mengarah pada jalan yang
salah.
BAB IV
PENGUJIAN DAN ANALISA SISTEM
Pada bab IV ini akan membahas sistem kerja, pengujian, dan juga
analisa dari rancang bangun sistem ini. Disini juga disajikan hasil uji
coba secara nyata percobaan dengan kondisi yang berbeda-beda.
4.1. Segmentasi Warna
67
Pada proyek akhir ini program akan menampilkan 2 gambar
dari kamera. Yang pertama gambar dengan nilai rgb, yang kedua
adalah gambar dengan hasil segmentasi warna. Segmentasi warna
harus dilakukan terlebih dahulu sebelum proses pencarian posisi
kepala player dilakukan. Hal ini digunakan agar informasi yang
ada dalam gambar menjadi lebih sedikit sehingga waktu
komputasinya akan lebih cepat.
Tujuan dari percobaan ini adalah untuk membandingkan
intensitas cahaya pada keaddan terang, sedang dan gelap.
Dari hasil pengambilan data yang dilakukan maka hasil
segmentasi warna tersebut sangat dipengaruhi oleh terang
intensitas cahaya. Semakin terang cahaya yang mengenai kamera,
maka hasil proses segmentasi warna akan semakin terang.
Tabel 4.1. Hasil scalp color modeling
NO A B KET
Intensitas
1
cahaya tinggi
Intensitas
2 cahaya
sedang
Intensitas
3 cahaya
rendah
(A) gambar sebelum dilakukan scalp color modeling.

(B) gambar sesudah dilakukan scalp color modeling.
Gambar 4.1. pada kolom A merupakan capture gambar awal

atau sebelum dilakukan scalp color modeling, dan pada kolom B
68
merupakan capture gambar sesudah dilakukan scalp color
modeling. Dari gambar no 3, pada kolom B, tampak bahwa
terdapat banyak sekali noise. Jadi intensitas cahaya rendah sangat
tidak baik untuk dilakukan pendeteksian kepala menggunakan
SSGA. Begitu pula dengan gambar no 1 pada kolom B tampak
pada intensitas cahaya tinggi, masih terdapat noise walaupun tidak
banyak. Sedangkan gambar 2 pada kolom B dengan intensitas
cahaya sedang, kulit wajah dapat terdeteksi dengan baik. Jadi
untuk proses penentuan posisi kepala player menggunakan SSGA
digunakan intensitas cahaya sedang agar hasilnya bisa optimal.
4.2. Hasil Percobaan Steady-State Genetic Algorithm (SSGA)

Setelah proses segmentasi warna selesai, maka proses
selanjutnya adalah mendeteksi kepala player menggunakan SSGA.
Proses ini dilakukan secara realtime. Prosesnya adalah meng-
capture gambar, menyimpan gambar dan menampilkannya secara
cepat.
Percobaan ini dilakukan dengan mengambil data dari metode
SSGA dengan jumlah individu yang berbeda-beda yaitu 10, 25, 50,
dan 100. Setiap jumlah individu itu diulang beberapa kali mulai
dari 5, 10 dan 15 kali.
Pengambilan data dilakukan di lab Tugas Akhir dengan
intensitas cahaya sedang.
Berikut adalah hasil percobaan untuk steady-state genetic
algorithm.
GRAFIK 5 ITERASI TERHADAP NILAI FITNESS

30000
25000
Nilai Fitness
20000 10 Individu
15000 25 Individu
10000 50 Individu
5000 100 Individu
0
0 1 2 3 4 5 6
Iterasi 69
Gambar 4.1. Grafik 5 iterasi terhadap nilai fitness

30000
25000
20000
Nilai Fitness
10 Individu
15000 25 Individu
10000 50 Individu
5000 100 Individu
0
0 2 4 6 8 10 12
Iterasi
70
35000
30000
25000
Nilai Fitness
10 Individu
20000
25 Individu
15000
50 Individu
10000
100 Individu
5000
0
0 2 4 6 8 10 12 14 16
Iterasi
Pada gambar 4.1., 4.2., 4.3, dapat dilihat bahwa nilai fitness
semakin lama semakin stabil. Hal ini membuktikan bahwa individu
dalam suatu iterasi telah menemukan posisi kepala player.
Semakin individu tersebut mendekati posisi kepala player maka
semakin bagus nilai fitnessnya. Namun dari percobaan yang telah
dilakukan individu sebanyak 10 dan iterasi sebanyak 5, sudah
mampu mendeteksi kepala player dan mengikuti kemana kepala
bergerak dengan cepat.
71
GRAFIK INDIVIDU TERHADAP WAKTU
500000
Waktu (mikrodetik)
400000
300000 5 Iterasi
200000 10 Iterasi
100000 15 Iterasi
0
10 25 50 100
Individu
Gambar 4.4. Grafik individu terhadap waktu
Setelah dilakukan percobaan, dapat dianalisa bahwa terdapat

perbedaan saat jumlah individu berbeda-beda. Ketika jumlah
individu sedikit, proses untuk mendeteksi kepala player sangat
cepat. Tapi ketika jumlah individu banyak, proses untuk
mendeteksi kepala player semakin lambat.
Hal ini disebabkan karena program menghitung semua nilai
fitness dari semua individu dan membandingkannya satu persatu,
untuk mencari fitness maksimal dan fitness minimal. Proses ini
bertujuan agar individu yang dihasilkan nantinya tidak jauh
berbeda dengan gen-gen induknya. Kemudian dilakukan proses
elitist crossover, yang mengkombinasikan nilai semua gen dari
individu dengan nilai fitness terbaik dengan nilai fitness terburuk.
Setelah itu, dilakukan proses adative mutation yang menggunakan
rumus tertentu yang sudah dijelaskan pada bab 2.
Jadi, dalam menjalankan program ini harus dicari jumlah
individu yang sesuai sehingga kecepatan individu dalam
mendeteksi kepala player dapat optimal.
Begitu juga dengan iterasi, banyaknya iterasi juga akan
mempengaruhi kecepatan pendeteksian kepala player. Namun dari
percobaan yang telah dilakukan individu sebanyak 10 dan iterasi
sebanyak 5, sudah mampu mendeteksi kepala player dan mengikuti
kemana kepala bergerak dengan cepat.
72
4.3. Hasil Percobaan Gerakan Kepala Player
Setelah program dapat mendeteksi kepala player dengan baik,
kemudian dilakukan program untuk memutuskan gerakan maju,
kanan, dan kiri. Prosesnya dengan memberikan batasan nilai pada
koordinat x dan y.
 Gerak ke kiri
Tabel 4.2. Hasil percobaan gerak ke kiri
N
GAMBAR X Y LEBAR TINGGI KET
O
2
1 97 123 117 kiri
8
2
2 54 127 128 kiri
3
Gerak
3
3 57 127 128 tidak
4
terdeteksi
Gerak
6
4 87 127 129 tidak
7
terdeteksi
Pada tabel 4.2., pada gambar 1 dan gambar 2 program berhasil

mendeteksi gerakan kepala ke arah kiri, karena koordinat x pada
individu melewati batas dari inisialisasi awal yang ditentukan,
yaitu 30. Jadi jika koordinat x < 30 maka dideteksi gerak ke kiri.
73
Namun pada gambar 3 dan 4, program gagal mendeteksi gerakan,
karena koordinat tidak melewati batas dari inisialisasi awal yang
ditentukan.
 Gerak ke kanan
Tabel 4.3. Hasil percobaan gerak ke kanan
N
GAMBAR X Y LEBAR TINGGI KET
O
21
1 91 127 127 kanan
8
23
2 70 131 131 kanan
4
Gerak
18
3 58 134 132 tidak
7
terdeteksi
Gerak
14
4 73 136 136 tidak
0
terdeteksi

mendeteksi gerakan kepala ke arah kiri, karena koordinat x pada
individu melewati batas dari inisialisasi awal yang ditentukan,
yaitu 210. Jadi jika koordinat x > 210 maka dideteksi gerak ke
kiri. Namun pada gambar 3 dan 4, program gagal mendeteksi
gerakan, karena koordinat tidak melewati batas dari inisialisasi
awal yang ditentukan.
74
 Gerak maju
Tabel 4.4. Hasil percobaan gerak maju
N LEBA TINGG
GAMBAR X Y KET
O R I
10 2
1 134 134 maju
5 7
3
2 96 127 132 maju
6
Gerak
5 tidak
3 76 132 132
1 terdeteks
i
Gerak
5 tidak
4 92 135 138
2 terdeteks
i

mendeteksi gerakan maju, karena koordinat y pada individu
melewati batas dari inisialisasi awal yang ditentukan, yaitu 50. Jadi
jika koordinat y < 50 maka dideteksi gerak maju. Namun pada
gambar 3 dan 4, program gagal mendeteksi gerakan, karena
koordinat tidak melewati batas dari inisialisasi awal yang
ditentukan.
4.4. Hasil Percobaan Gerakan Karakter Pada Game

Setelah semua proses pendeteksian kepala player selesai
dilakukan dengan baik, maka percobaan selanjutnya adalah
75
gerakan karakter dalam game. Gerak karakter dalam game
labyrinth ini adalah maju, kanan, dan kiri.
Tabel 4.5. Gerakan karakter dalam game
76
(A) Gerak karakter maju
(B) Gerak karakter ke kiri
(C) Gerak karakter ke kanan
Pada tabel 4.5., pada kolom A, awalnya karakter diam, namun

ketika kepala bergerak maju sebanyak 2 kali, maka karakter
bergerak maju 2 langkah dan game memberikan output berupa
indikator kata maju dan koordinat karakter bergerak sebanyak 2
kali.
Pada tabel 4.5., pada kolom B, awalnya karakter diam, namun
ketika kepala bergerak ke kiri sebanyak 3 kali, maka karakter
bergerak memutar ke kiri sebanyak 3 kali dan game memberikan
output berupa indikator kata kiri dan koordinat karakter bergerak
sebanyak 3 kali. Dapat dilihat bahwa saat karakter bergerak
memutar ke kiri, koordinatnya tidak berubah, hal itu menunjukkan
bahwa karakter tetap tidak berpindah hanya bergerak memutar
saja.
Pada gambar 4.5., pada kolom C, awalnya karakter diam,
namun ketika kepala bergerak ke kanan sebanyak 2 kali, maka
karakter bergerak memutar ke kanan sebanyak 3 kali dan game
memberikan output berupa indikator kata kanan dan koordinat
karakter bergerak sebanyak 3 kali. Dapat dilihat bahwa saat
karakter bergerak memutar ke kanan, koordinatnya tidak berubah,
hal itu menunjukkan bahwa karakter tetap tidak berpindah hanya
bergerak memutar saja.
77
4.5. Hasil Percobaan Gerakan Karakter Pada Game Dengan Latar
Belakang Yang Berbeda
Percobaan dengan latar belakang yang berbeda sangat
diperlukan, karena sangat berpengaruh pada baik atau tidaknya
mendeteksi kepala pemain. Percobaan ini dilakukan di dalam
Laboratorium Tugas Akhir IT. Pada percobaan ini, ada beberapa
kondisi latar belakang, antara lain:
 Latar belakang berwarna putih
 Latar belakang berwarna coklat kulit
 Latar belakang berwarna campuran (putih, coklat,
hitam)
4.5.1. Latar Belakang Berwarna Putih

Hasil percobaan dengan latar belakang berwarna putih:
Gambar 4.5. Latar belakang berwarna putih
Analisa:
 Kepala dapat terdeteksi
 Gerakan maju, kanan, kiri dapat dilakukan
78
4.5.2. Latar Belakang Berwarna Coklat Kulit
Hasil percobaan dengan latar belakang berwarna
coklat kulit:
Gambar 4.6. Latar belakang berwarna coklat kulit
Analisa:
 Gerakan maju, kanan, kiri dapat dilakukan
4.5.3. Latar Belakang Berwarna Campuran (Putih,

Coklat, Hitam)
Hasil percobaan dengan latar belakang berwarna
campuran (putih, coklat, hitam):
Gambar 4.7. Latar belakang berwarna campuran

(putih, coklat, hitam)
79
Analisa:
 Kepala tidak dapat terdeteksi, karena program
terjebak pada lokal optima yang serupa
dengan kepala pemain
 Gerakan maju, kanan, kiri tidak dapat
dilakukan
Kesimpulan:
Pada percobaan di atas telah dilakukan 3 macam latar
belakang yang berbeda, dan sistem game labyrinth memberikan
hasil dari 2 latar belakang dari 3 latar belakang hasil uji coba
yang dapat mendeteksi kepala.
Tabel 4.6. Gerakan karakter dalam game dengan

latar belakang yang berbeda
Kondisi Putih Cokelat Campuran

Kepala Terdeteksi V V X
Permainan Dapat Dilakukan V V X
4.6. Hasil Percobaan Gerakan Karakter Pada Game Dengan

Intensitas Cahaya Yang Berbeda
Percobaan dengan intensitas cahaya yang berbeda sangat
diperlukan, karena sangat berpengaruh pada baik atau tidaknya
mendeteksi kepala pemain. Percobaan ini dilakukan di dalam
Laboratorium Tugas Akhir IT.
Pada percobaan ini, ada beberapa kondisi intensitas cahaya,
antara lain:
 Kondisi A, lampu yang menyala 5, 6, dan 7
 Kondisi B, lampu yang menyala 2, 3, dan 4
 Kondisi C, lampu yang menyala 1 dan 8
 Kondisi A + B
 Kondisi A + C
 Kondisi B + C
 Kondisi A + B + C
 Kondisi semua lampu mati (hanya menggunakan
cahaya dari monitor)
80
4.6.1. Kondisi A
Kondisi A, lampu yang menyala 5, 6, dan 7.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.8. Kondisi A
Hasil:
Gambar 4.9. Hasil percobaan kondisi A
Analisa :
 Terdapat sedikit noise pada area gelap
81
 Gerakan maju, kanan, dan kiri dapat
dilakukan
4.6.2. Kondisi B
Kondisi B, lampu yang menyala 2, 3, dan 4.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.10. Kondisi B
Hasil:
Gambar 4.11. Hasil percobaan kondisi B
Analisa:
 Terdapat noise pada area gelap
82
dilakukan
4.6.3. Kondisi C
Kondisi C, lampu yang menyala 1 dan 8.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.12. Kondisi C
Hasil:
Gambar 4.13. Hasil percobaan kondisi C
Analisa:
83
dilakukan
4.6.4. Kondisi A + B
Kondisi A + B, lampu yang menyala 2, 3, 4, 5, 6, dan
7.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.14. Kondisi A + B
Hasil:
Gambar 4.15. Hasil percobaan kondisi A + B
Analisa:
84
dilakukan
4.6.5. Kondisi A + C
Kondisi A + C, lampu yang menyala 1, 5, 6, 7, dan 8.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.16. Kondisi A + C
Hasil:
Gambar 4.17. Hasil percobaan kondisi A + C
Analisa:
85
dilakukan
4.6.6. Kondisi B + C
Konsisi B + C, lampu yang menyala 1, 2, 3, 4, dan 8.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.18. Kondisi B + C
Hasil:
Gambar 4.19. Hasil percobaan kondisi B + C
Analisa:
86
dilakukan
4.6.7. Kondisi A + B + C
Kondisi A + B + C, semua lampu menyala.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.20. Kondisi A + B + C
Hasil:
Gambar 4.21. Hasil percobaan kondisi A + B + C
Analisa:
87
dilakukan
4.6.8. Kondisi Lampu Mati

Kondisi lampu mati, percobaan hanya menggunakan
cahaya dari monitor saja.
1 5
2 6
3 7
4 8
Posisi
Perangkat
Sistem Lampu mati
Lampu menyala
Gambar 4.22. Kondisi lampu mati
Hasil:
Gambar 4.23. Hasil percobaan kondisi lampu mati
Analisa:
 Kepala dapat terdeteksi namun tidak optimal
88
 Terdapat banyak noise
 Gerakan kanan dan kiri dapat dilakukan,
namun gerakan maju tidak dapat dilakukan
Kesimpulan:
Pada percobaan di atas telah dilakukan berbagai macam
intensitas cahaya, dan sistem game labyrinth memberikan hasil
uji coba yang sebagian besar dapat mendeteksi kepala
meskipun dengan intensitas cahaya yang rendah.
Namun intensitas cahaya rendah juga berpengaruh
terhadap deteksi gerakan, karena kamera menggunakan mode
Slow Shutter Speed untuk menangkap gambar, sehingga saat
terjadi gerakan, gambar melambat atau seolah-olah
menghilang.
Tabel 4.7. Gerakan karakter dalam game dengan

intensitas cahaya yang berbeda
Kondisi A B C AB AC BC ABC Mati

Kepala Terdeteksi V V V V V V V X
Noise V V V V V V V V
Permainan Dapat Dilakukan V V V V V V V X
89
BAB V
PENUTUP
5.1. Kesimpulan
Dari hasil uji coba program yang telah dilakukan, maka dapat
diperoleh kesimpulan bahwa:
1. Pada proses scalp color modeling, intensitas cahaya
sangat berpengaruh terhadap hasil deteksi. Hasil scalp
color modeling yang buruk menyebabkan sulitnya
individu dalam proses SSGA untuk menemukan posisi
kepala karena gangguan dari intensitas cahaya.
2. Kecepatan individu untuk menemukan dan bergerak
mengikuti kepala bergantung pada jumlah individu
yang dibangkitkan. Semakin banyak individu dan
iterasi, maka kecepatannya juga semakin lambat.
Berdasarkan hasil percobaan, dari jumlah individu
sebanyak 100 dan iterasi sebanyak 15, waktu yang
dibutuhkan adalah 472656,7 mikrodetik, sedangkan
individu sebanyak 10 dan iterasi sebanyak 5, waktu
yang dibutuhkan adalah 10109,2 mikrodetik.
3. Sedikitnya individu yang dibangkitkan menyebabkan
sulitnya individu tersebut untuk menemukan posisi
kepala, karena kurangnya referensi nilai fitness
terbesar, yang menyebabkan terjebak pada local
optima. Berdasarkan hasil percobaan, nilai fitness
minimum untuk menemukan posisi kepala adalah
1531,35.
4. Game dapat dimainkan dengan latar belakang
berwarna putih dan warna yang mirip dengan warna
kulit atau coklat dan dengan intensitas cahaya normal
dan game bekerja optimal jika jarak kamera dengan
player antara 30cm sampai 50cm.
5.2. Saran
90
1. Aplikasi game labyrinth ini dibangun pada sistem
operasi Mac OS X dan hanya bisa dimainkan oleh 1
player saja. Pada pengembangan selanjutnya
diharapkan aplikasi game labyrinth ini dapat
dimainkan oleh 2 player dan dapat berjalan pada
sistem operasi Windows.
2. Aplikasi game labyrinth ini dapat dimainkan dengan
latar belakang putih atau warna yang mirip warna kulit
atau coklat. Pada pengembangan selanjutnya
diharapkan aplikasi game labyrinth ini dapat
dimainkan pada latar belakang yang warnanya
campuran (warna putih, coklat, hitam tidak merata).
91
DAFTAR PUSTAKA
[1] Hakiki, Ferman, “Rancang Bangun Robot Pantilt: Pendeteksian

Posisi Kepala Manusia Menggunakan Algoritma Genetika”, PENS-
ITS, Surabaya, 2009.
[2] Parker J.R, “Algorithm For Image Processing And Computer

Vision”, Wiley Computer Publishing 1997.
[3] Naoyuki, Kubota, Jingzhe Pei, Akihiro Yorita, Hiroyuki Kojima,

“Human Tracking and Natural Communication of Partner Robots”,
Tokyo Metropolitan University, Tokyo.
[4] Adji Indra S, “Evolutionary Robot Vision for Multiple Human

Heads Tracking of A Partner Robot”, Korea, 26-29 Agustus 2007.
[5] Kustiawan, Dedi, “Kendali Raket Pada Game Serangga Nakal

Menggunakan Kamera”, PENS-ITS, Surabaya, 2009.
[6] Ramadijanti, Nana, “Image Processing”, Politeknik Elektronika

Negeri Surabaya-ITS, Surabaya, 2010.
[7] Basuki, Achmad, “Pengolahan Citra Menggunakan Visual Basic”,

Graha Ilmu.
[8] Rafael C. Gonzales E. Woods, “Digital Image Processimg, 2 nd

Edition”, Prentice Hall, 2001
[9] Basuki, Achmad, Ramadijanti Nana, “Grafika Komputer”,

Politeknik Elektronika Surabaya-ITS, Surabaya, 2009.
[10] Pramitasari, Ayu Dyah, “Rancang Bangun Dan Penerapan

Algoritma Backtrack Pada Labirin Matematika Berbasis Android”,
PENS-ITS, Surabaya, 2012.
92
[11] NeHe TM, NeHeProductionsTM, “OpenGL Lessons” <URL:
http://gamedev.net>
[12] Widi, “Game 3D Sederhana”, <URL :

http://najicayuri.blogspot.com/2010/12/teknik-pembuatan-game-3d-
sederhana.html>
[13] Mustofa, Moch. Amir, “Aplikasi Sketsa Wajah 3D Menggunakan

OPENGL”, PENS-ITS, 2009.
[14] Columbia Service-Learning Program, “John Jay Green Roof”,

<URL:http://community.seas.columbia.edu/cslp/>
[15] High Resolution Textures, “Stone Wall & Brick Wall Free
Textures”, <URL: http://www.highresolutiontextures.com/stone-
wall-brick-wall-free-textures>
[16] Ciri cara, “Labyrinth Park”, <URL: http://ciricara.com>
[17] Warta warga, “Pembuatan Game 3D Sederhana”, <URL:

http://wartawarga.gunadarma.ac.id/2010/03/pembuatan-game-
sederhana/>
[18] Flash/3D Maze Survival, “Flash Realtime 3D Maze Shooting Action

Game”, <URL: http://dawgsdk.cside.com/maze3d/>
[19] Wikipedia, “Peristiwa 10 November 1945”, <URL:

http://id.wikipedia.org/wiki/Peristiwa_10_November>
[20] Kompasiana, “Peristiwa 10 November 1945”, <URL:

http://umum.kompasiana.com/>
[21] Wikipedia, “Jembatan Merah Surabaya”, <URL:

http://id.wikipedia.org/wiki/Jembatan_Merah>
[22] Wikipedia, “Perang Diponegoro”, <URL:

http://id.wikipedia.org/wiki/Perang_Diponegoro>
93
[23] Wikipedia, “Perang Padri”, <URL:
http://id.wikipedia.org/wiki/Perang_Padri>
LAMPIRAN
Berikut adalah tabel hasil pengambilan data percobaan steady-

state genetic algorithm (SSGA).
5 Iterasi
Nilai Fitness Terbaik
10 Individu 25 Individu 50 Individu 100 Individu
1531,35 18092,7 21683,1 23614,1
1665,72 19514,9 21056,1 21645,2
1665,72 20866,2 24647,8 23070,2
1665,72 20866,2 24992,5 23070,2
1665,72 20866,2 25939,7 23070,2
10 Iterasi
13404,9 17619,2 16627,4 20728,5
14480,4 18548,3 17538,7 20255,3
15097,8 20377,2 17806,5 21412,4
15097,8 20720,8 19799,3 21701
15097,8 21025 20274,3 21701
16218,5 23371,3 21786,6 23387,7
16375,8 23674,3 21882 23401,1
17383,5 23690,9 22158,5 23401,1
17712,8 26575,9 22158,5 23401,1
17712,8 27530,1 22158,5 23401,1
15 Iterasi
94
5508,97 14278,6 19302,4 21274,9
6140,57 15215,4 19307 15276,8
7131,39 17125,9 19378,8 15276,8
7131,39 17312,6 20719,4 15276,8
7131,39 17436 21286 15276,8
7131,39 17660,9 21286 15276,8
7131,39 17886,7 21286 15276,8
7131,39 17897,5 21286 15276,8
7834,15 17986,4 23286,5 15276,8
7834,15 17986,4 23743,6 15276,8
7834,15 17986,4 26324,4 15276,8
8261,57 17986,4 26625,6 15276,8
8261,57 17986,4 28643 15276,8
8261,57 17986,4 28885,7 15276,8
8445,28 17986,4 29056,1 15276,8
N ITERAS INDIVID NILAI

WAKTU
O I U FITNESS
1 10 22605,265 10109,2
2 25 21763,3 35923,1
5
3 50 26475,55 85243
4 100 18330,279 173085,9
5 10 24372,197 21858,5
6 25 29426,244 76913,6
10
7 50 29717,33 171353,9
8 100 22975,6 336790,8
9 10 14858,852 26587,2
10 15 25 21493,978 105222,2
11 50 35933,18 246710,1
95
12 100 17516,432 472656,7
BIODATA PENULIS
Nama : Wais Al-Qonri Hanif

TTL : Bangkalan, 25 Februari 1991
Alamat : Jl. Trunojoyo 30 B Kamal
Email : waisalqonri@gmail.com
Skype : rhymeskid
Phone : 085648420240
Riwayat Pendidikan
 D4 Teknik Informatika PENS (2008-2012)

 SMAN 1 Kamal (2005-2008)
 SMPN 1 Kamal (2002-2005)
 SDN Banyuajuh 3 (1996-2002)
96

Buku Labyrinthgame

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Buku Labyrinthgame

Diunggah oleh

Hak Cipta:

Format Tersedia

PROYEK AKHIR

DETEKSI KEPALA UNTUK PERPINDAHAN KARAKTER

Wais Al-Qonri Hanif

Nana Ramadijanti, S.Kom., M.Kom.

Dr.Eng. Indra Adji Sulistijono, S.T., M.Eng.

PROGRAM STUDI D4 TEKNIK INFORMATIKA

DETEKSI KEPALA UNTUK PERPINDAHAN KARAKTER

Wais Al-Qonri Hanif

Nana Ramadijanti, S.Kom., M.Kom.

Dr.Eng. Indra Adji Sulistijono, S.T., M.Eng.

PROGRAM STUDI D4 TEKNIK INFORMATIKA

DETEKSI KEPALA UNTUK PERPINDAHAN KARAKTER

Proyek Akhir ini Digunakan Sebagai Salah Satu Syarat Untuk

Tim Penguji Proyek Akhir : Dosen Pembimbing :

1. Drs. Achmad Basuki, M.Kom., Ph. D. 1. Nana Ramadijanti, S.Kom., M.Kom.

2. Yuliana Setiowati, S.Kom. 2. Dr.Eng. Indra Adji

3. Rizky Yuniar Hakkun, S.Kom.

Isbat Uzzin Nadhori, S.Kom., M.T.

Perkembangan Teknologi Informasi khususnya dalam

Kata kunci : game labyrinth, tracking, steady-state genetic algorithm,

Development of Information Technology, especially in

Keywords : game labyrinth, tracking, steady-state genetic algorithm,

Puji syukur saya panjatkan kehadirat Allah SWT, yang telah

DETEKSI KEPALA UNTUK PERPINDAHAN KARAKTER

Tujuan penyusunan proyek akhir ini adalah untuk memenuhi

Surabaya, Juli 2012

Alhamdulillah, puji syukur kehadirat “ Allah SWT ”, berkat rahmat

1. Seluruh keluarga, khususnya kedua orang tua penulis yang selalu

BAB II. TEORI PENUNJANG......................................................7

BAB III. PERENCANAAN DAN PEMBUATAN SISTEM.........17

BAB IV. PENGUJIAN DAN ANALISA SISTEM........................67

Gambar 1.1. Metodologi Proyek Akhir........................................3

Tabel 3.1. Alur Cerita 10 November 1945 Yang Benar.................51

1.1. Latar Belakang

1.2. Perumusan Masalah

1.3. Batasan Masalah

Perancangan dan Pembuatan Sistem

Pengujian dan Analisa

Gambar 1.1.Metodologi proyek akhir

1.5.1. Studi Literatur dan Pengambilan Data

1.5.2. Perancangan dan Pembuatan Sistem

1.5.3. Pengujian dan Analisa

1.5.4. Pembuatan Laporan

1.6. Sistematika Penulisan

BAB II TEORI PENUNJANG

BAB III PERENCANAAN DAN PEMBUATAN SISTEM

2.1. YCrCb Color System

Y = 0.59G + 0.31R +0.11B (2.1)

2.2. Grafika Komputer

2.2.2. Open Graphics Library (OpenGL)

a. Fungsi primitif, menentukan elemen yang bisa

Fungsi-fungsi OpenGL dimuat di dalam 2 library yang

The OpenGL Utility Toolkit (GLUT) merupakan

Nilai – nilai dx, dy, dan dz adalah nilai perubahan

Berikut rumus rotasi terhadap sumbu y, (Sumber:

Berikut rumus rotasi terhadap sumbu z, (Sumber:

2.3. Steady-State Genetic Algorithm (SSGA)

Gambar 2.1. Labyrinth

2.4.1. Game Labyrinth 3D

Karena game ini adalah game 3D, maka player utama

Dalam gambar di atas ada istilah FOV (Field of View)

Gambar 2.3. Area pandangan

Garis merah adalah batas dekat penglihatan/layar