TA J2F007016
107
APLIKASI SIMULASI PENYELESAIAN MASALAH DUNIA BALOK MENGGUNAKAN ALGORITMA PERENCANAAN STRIPS DENGAN DELPHI DAN OPENGL SKRIPSI Disusun Sebagai Salah Satu Syarat Untuk Memperoleh Gelar Sarjana Komputer Disusun oleh: Havit Choirul Rovik J2F007016 JURUSAN ILMU KOMPUTER / INFORMATIKA FAKULTAS SAINS DAN MATEMATIKA UNIVERSITAS DIPONEGORO 2013
-
Upload
haru-el-rovix -
Category
Documents
-
view
93 -
download
0
Transcript of TA J2F007016
HALAMAN JUDUL
APLIKASI SIMULASI PENYELESAIAN MASALAH DUNIA BALOK
MENGGUNAKAN ALGORITMA PERENCANAAN STRIPS
DENGAN DELPHI DAN OPENGL
SKRIPSI
Disusun Sebagai Salah Satu Syarat
Untuk Memperoleh Gelar Sarjana Komputer
Disusun oleh:
Havit Choirul Rovik
J2F007016
JURUSAN ILMU KOMPUTER / INFORMATIKA
FAKULTAS SAINS DAN MATEMATIKA
UNIVERSITAS DIPONEGORO
2013
ii
HALAMAN PENGESAHAN
Judul : Aplikasi Simulasi Penyelesaian Masalah Dunia Balok Menggunakan
Algoritma Perencanaan STRIPS dengan Delphi dan OpenGL
Nama : Havit Choirul Rovik
NIM : J2F 007 016
Telah diujikan pada sidang tugas akhir pada tanggal 22 Januari 2013 dan dinyatakan lulus
pada tanggal 30 Januari 2013.
Mengetahui,
a.n. Ketua Jurusan Ilmu Komputer / Informatika
Sekretaris Jurusan Ilmu Komputer / Informatika
FSM UNDIP
Aris Sugiharto, S.Si, M.Kom
NIP. 19710811 199702 1 004
Semarang, 30 Januari 2013
Panitia Penguji Tugas Akhir
Ketua,
Drs. Eko Adi Sarwoko, M.Kom
NIP. 19651107 199203 1 003
iii
HALAMAN PENGESAHAN
Judul : Aplikasi Simulasi Penyelesaian Masalah Dunia Balok Menggunakan
Algoritma Perencanaan STRIPS dengan Delphi dan OpenGL
Nama : Havit Choirul Rovik
NIM : J2F 007 016
Telah diujikan pada sidang tugas akhir pada tanggal 22 Januari 2013.
Pembimbing Utama
Helmie Arif Wibawa, S.Si, M.Cs
NIP. 19780516 200312 1 001
Semarang, 30 Januari 2013
Pembimbing Anggota
Aris Sugiharto, S.Si, M.Kom
NIP. 19710811 199702 1 004
iv
ABSTRAK
Aplikasi penyelesaian masalah dunia balok yang ada sekarang ini hanya mampu
mensimulasikan delapan buah balok dan bangun yang disimulasikan masih terbatas bangun
datar dua dimensi. Oleh karena itu, dibutuhkan aplikasi simulasi yang mampu menangani
kelemahan yang ada. Aplikasi simulasi penyelesaian dunia balok dikembangkan
menggunakan algoritma perencanaan STRIPS. Algoritma ini berusaha mengatasi
kesulitan-kesulitan dalam hal waktu proses dan kebutuhan memori. Aplikasi simulasi
diimplementasikan dengan menggunakan Delphi 2010 dan OpenGL sehingga dapat
mensimulasikan dunia balok dalam pandangan tiga dimensi. Algoritma perencanaan
STRIPS mampu menghasilkan solusi penyelesaian masalah dunia balok lebih optimal
ketika dilengkapi prosedur pruning (pemangkasan).
Kata kunci: dunia balok, algoritma perencanaan STRIPS, pruning, OpenGL
v
ABSTRACT
Application of blocks world's problem solving that exist today is only able to simulate
eight blocks and limited to two dimensional geometric surface. Therefore, it required
simulation applications that can handle the weaknesses. Simulation applications of blocks
world's problem solving is developed using STRIPS planning algorithms. These algorithms
try to conquer the difficulties in terms of processing time and memory requirements.
Simulation applications implemented using Delphi 2010 and OpenGL so it can simulate
the blocks world in a three-dimensional view. STRIPS planning algorithms capable of
generating world problem solving solutions more optimal when equipped with pruning
procedure.
Keywords: blocks world, STRIPS planning algorithms, pruning, OpenGL
vi
KATA PENGANTAR
Puji syukur kehadirat Allah SWT atas karunia-Nya sehingga penulis dapat
menyelesaikan skripsi dengan judul “Aplikasi Simulasi Penyelesaian Masalah Dunia
Balok Menggunakan Algoritma Perencanaan STRIPS dengan Delphi dan OpenGL”.
Skripsi ini disusun sebagai salah satu syarat untuk memperoleh gelar sarjana
komputer pada Jurusan Ilmu Komputer / Informatika Fakultas Sains dan Matematika
Universitas Diponegoro. Dalam penyusunan skripsi ini, penulis mendapat bantuan dan
dukungan dari banyak pihak. Atas peran sertanya dalam membantu penyelesaian tugas
akhir ini, penulis ingin mengucapkan terima kasih kepada :
1. Dr. Muhammad Nur, DEA, selaku Dekan FSM UNDIP.
2. Drs. Eko Adi Sarwoko, M.Kom, selaku Ketua Jurusan Ilmu Komputer / Informatika.
3. Nurdin Bahtiar, S.Si., M.T, selaku Koordinator Tugas Akhir.
4. Helmie Arif Wibawa, S.Si, M.Cs, selaku dosen pembimbing I.
5. Aris Sugiharto, S.Si, M.Kom, selaku dosen pembimbing II.
6. Dan semua pihak yang telah mendukung pengerjaan skripsi ini.
Penulis menyadari bahwa masih banyak kekurangan dalam penyusunan skripsi ini,
untuk itu penulis mohon maaf dan mengharapkan saran serta kritik yang membangun dari
pembaca. Semoga skripsi ini dapat bermanfaat bagi pengembangan ilmu dan pengetahuan,
khususnya pada bidang Informatika.
Semarang, Januari 2013
Penulis
vii
DAFTAR ISI
Hal
HALAMAN JUDUL .............................................................................................................. i
HALAMAN PENGESAHAN ............................................................................................... ii
HALAMAN PENGESAHAN .............................................................................................. iii
ABSTRAK ........................................................................................................................... iv
ABSTRACT .......................................................................................................................... v
KATA PENGANTAR .......................................................................................................... vi
DAFTAR ISI ....................................................................................................................... vii
DAFTAR GAMBAR ............................................................................................................. x
DAFTAR TABEL .............................................................................................................. xiii
DAFTAR KODE ................................................................................................................ xiv
BAB I PENDAHULUAN .................................................................................................... 1
1.1. Latar Belakang ............................................................................................... 1
1.2. Rumusan Masalah .......................................................................................... 2
1.3. Tujuan dan Manfaat ....................................................................................... 2
1.4. Ruang Lingkup............................................................................................... 3
1.5. Sistematika Penulisan .................................................................................... 3
BAB II LANDASAN TEORI............................................................................................... 4
2.1. Kecerdasan Buatan......................................................................................... 4
2.2. Penyelesaian Dunia Balok Menggunakan Teknik Searching ........................ 6
2.3. Perencanaan (Planning) ................................................................................. 9
2.3.1. Algoritma Perencanaan STRIPS ........................................................ 9
2.3.2. Stack ................................................................................................. 13
2.3.3. Tumpukan (Stack) dalam STRIPS ................................................... 14
2.3.4. Sussman Anomaly ............................................................................ 15
2.4. Grafika Komputer ........................................................................................ 16
2.5. Delphi ........................................................................................................... 17
2.6. OpenGL........................................................................................................ 18
2.6.1. Sistem Koordinat .............................................................................. 18
2.6.2. Transformasi .................................................................................... 19
2.6.3. Pandangan (Viewing) ....................................................................... 19
2.6.4. Warna ............................................................................................... 20
2.6.5. Pencahayaan ..................................................................................... 21
2.6.6. Benda Tiga Dimensi ......................................................................... 21
viii
2.7. GLScene ....................................................................................................... 24
2.8. Pengembangan Perangkat Lunak ................................................................. 26
2.8.1. Siklus Hidup Pengembangan Perangkat Lunak ............................... 26
2.8.2. Linear Sequential Model .................................................................. 26
2.8.2.1. Flowchart ......................................................................... 27
2.8.2.2. Data Flow Diagram ......................................................... 28
BAB III ANALISIS DAN PERANCANGAN ................................................................... 30
3.1. Analisis ........................................................................................................ 30
3.1.1. Gambaran Umum Aplikasi .............................................................. 30
3.1.2. Analisis Kebutuhan Perangkat Lunak .............................................. 31
3.1.3. Pemodelan Fungsional ..................................................................... 32
3.1.3.1. Data Context Diagram (DCD) ......................................... 33
3.1.3.2. Data Flow Diagram (DFD) Level 1 ................................. 33
3.1.3.3. DFD Level 2 Gambar Balok ............................................ 35
3.1.3.4. DFD Level 2 Susun Tumpukan ........................................ 36
3.1.3.5. DFD Level 2 Temukan Solusi .......................................... 38
3.2. Perancangan ................................................................................................. 40
3.2.1. Perancangan Fungsi ......................................................................... 40
3.2.1.1. Fungsi Buka Berkas .......................................................... 41
3.2.1.2. Fungsi Konversi Berkas ................................................... 41
3.2.1.3. Fungsi Gambar Balok ....................................................... 41
3.2.1.4. Fungsi Susun Tumpukan .................................................. 42
3.2.1.5. Fungsi Temukan Solusi .................................................... 42
3.2.1.6. Fungsi Pangkas Solusi ...................................................... 43
3.2.1.7. Fungsi Simpan Solusi ....................................................... 44
3.2.1.8. Fungsi Jalankan Simulasi ................................................. 44
3.2.2. Perancangan Antarmuka .................................................................. 46
3.2.2.1. Rancangan Menu .............................................................. 47
3.2.2.2. Rancangan Input ............................................................... 48
3.2.2.3. Rancangan Rendering ....................................................... 49
3.2.2.4. Rancangan Analisis Hasil ................................................. 49
3.2.2.5. Rancangan Simulasi ......................................................... 50
3.2.2.6. Rancangan Output ............................................................ 50
3.2.3. Perancangan Area Simulasi.............................................................. 51
3.2.3.1. Rancangan Meja ............................................................... 52
3.2.3.2. Rancangan Balok .............................................................. 52
3.2.3.3. Rancangan Tangan Robot ................................................ 53
ix
BAB IV IMPLEMENTASI DAN PENGUJIAN ............................................................... 55
4.1. Implementasi ................................................................................................ 55
4.1.1. Implementasi Fungsi ........................................................................ 55
4.1.1.1. Fungsi Buka Berkas .......................................................... 56
4.1.1.2. Fungsi Konversi Berkas ................................................... 56
4.1.1.3. Fungsi Gambar Balok ....................................................... 57
4.1.1.4. Fungsi Susun Tumpukan .................................................. 57
4.1.1.5. Fungsi Temukan Solusi .................................................... 59
4.1.1.6. Fungsi Pangkas Solusi ...................................................... 60
4.1.1.7. Fungsi Simpan Solusi ....................................................... 61
4.1.1.8. Fungsi Jalankan Simulasi ................................................. 61
4.1.2. Implementasi Antarmuka ................................................................. 63
4.1.2.1. Implementasi Menu .......................................................... 63
4.1.2.2. Implementasi Input ........................................................... 64
4.1.2.3. Implementasi Rendering ................................................... 64
4.1.2.4. Implementasi Analisis Hasil ............................................. 64
4.1.2.5. Implementasi Simulasi ..................................................... 65
4.1.2.6. Implementasi Output ........................................................ 65
4.1.3. Implementasi Area Simulasi ............................................................ 66
4.1.3.1. Implementasi Meja ........................................................... 66
4.1.3.2. Implementasi Balok .......................................................... 67
4.1.3.3. Implementasi Tangan Robot ............................................ 68
4.2. Pengujian...................................................................................................... 69
4.2.1. Lingkungan Pengujian ..................................................................... 69
4.2.2. Perencanaan Pengujian..................................................................... 69
4.2.3. Proses Pengujian .............................................................................. 71
4.2.3.1. Pengujian Temukan Solusi ............................................... 72
4.2.3.2. Pengujian Jalankan Simulasi ............................................ 75
4.2.3.3. Hasil proses pengujian ...................................................... 78
4.2.4. Analisis Hasil Pengujian Algoritma Perencanaan STRIPS ............. 78
BAB V PENUTUP ............................................................................................................. 84
5.1. Kesimpulan .................................................................................................. 84
5.2. Saran ............................................................................................................ 84
DAFTAR PUSTAKA .......................................................................................................... 85
LAMPIRAN ........................................................................................................................ 87
Lampiran 1 : Tabel Initial State dan Goal State Proses Pengujian ....................... 87
Lampiran 2 : Tabel American Standard Code for Information Interchange ........ 90 Lampiran 3 : Tabel Hasil Proses Pengujian .......................................................... 91
x
DAFTAR GAMBAR
Hal
Gambar 2.1. Aplikasi yang Menggunakan Kecerdasan Buatan ............................................ 5
Gambar 2.2. Dunia Balok ...................................................................................................... 6
Gambar 2.3. Contoh Dua Buah State pada Dunia Balok..................................................... 11
Gambar 2.4. Stack ................................................................................................................ 13
Gambar 2.5. Operasi Push pada Stack ................................................................................. 13
Gambar 2.6. Operasi Pop pada Stack .................................................................................. 13
Gambar 2.7. Algoritma Perencanaan STRIPS menggunakan Stack [14] ............................ 14
Gambar 2.8. Tumpukan balok yang dikenal sebagai Sussman Anomaly ........................... 15
Gambar 2.9. Lingkungan IDE Delphi 2010 (codename: Weaver) ...................................... 17
Gambar 2.10. Representasi Sumbu Tiga Dimensi [3] ......................................................... 18
Gambar 2.11. Perspektif Viewing Volume melalui glFrustum [13] .................................... 19
Gambar 2.12. Kotak Warna Model RGB [13] .................................................................... 20
Gambar 2.13. Perbedaan Efek Pencahayaan terhadap Benda ............................................. 21
Gambar 2.14. Perbandingan Benda Dua dan Tiga Dimensi ................................................ 21
Gambar 2.15. Benda Tiga Dimensi dengan Delapan Buah Titik ........................................ 22
Gambar 2.16. Lokasi Titik [10] ........................................................................................... 23
Gambar 2.17. Hasil Menggambar dengan Modus GL_TRIANGLE_STRIP [10] .............. 23
Gambar 2.18. Tampilan GLScene [2] ................................................................................. 24
Gambar 2.19. Garis aliasing dan anti-aliasing [13] ............................................................ 25
Gambar 2.20. Kubus dengan anti-aliasing Berbeda [2] ...................................................... 25
Gambar 2.21. Linear Sequential Model dalam Pengembangan Perangkat Lunak .............. 26
Gambar 3.1. Gambaran Umum Aplikasi Simulasi Dunia Balok ......................................... 30
Gambar 3.2. Contoh Masukan initial state dan goal state Dunia Balok ............................. 31
Gambar 3.3. Data Context Diagram Simulasi Dunia Balok ............................................... 33
Gambar 3.4. DFD Level 1 Simulasi Dunia Balok ............................................................... 34
Gambar 3.5. DFD Level 2 Gambar Balok ........................................................................... 36
Gambar 3.6. DFD Level 2 Susun Tumpukan ...................................................................... 37
Gambar 3.7. DFD Level 2 Temukan Solusi ........................................................................ 39
Gambar 3.8. Algoritma Proses Pangkas Solusi ................................................................... 43
xi
Gambar 3.9. Algoritma Proses Jalankan Simulasi .............................................................. 45
Gambar 3.10. Rancangan Antarmuka Simulasi Dunia Balok ............................................. 46
Gambar 3.11. Rancangan Menu Simulasi Dunia Balok ...................................................... 47
Gambar 3.12. Rancangan Input ........................................................................................... 48
Gambar 3.13. Rancangan Rendering ................................................................................... 49
Gambar 3.14. Rancangan Analisis Hasil ............................................................................. 49
Gambar 3.15. Rancangan Simulasi...................................................................................... 50
Gambar 3.16. Rancangan Output ........................................................................................ 50
Gambar 3.17. Rancangan Area Simulasi ............................................................................. 51
Gambar 3.18. Tekstur Marbletiles untuk Permukaan Meja Dunia Balok ........................... 52
Gambar 3.19. Rancangan Balok dan Label ......................................................................... 52
Gambar 3.20. Rancangan Tangan Robot ............................................................................. 54
Gambar 3.21. Rancangan Silinder Lengan Robot ............................................................... 54
Gambar 4.1. Implementasi Antarmuka Simulasi Dunia Balok ........................................... 63
Gambar 4.2. Implementasi Menu Simulasi Dunia Balok .................................................... 64
Gambar 4.3. Implementasi Input ......................................................................................... 64
Gambar 4.4. Implementasi Rendering ................................................................................. 64
Gambar 4.5. Implementasi Analisis Hasil ........................................................................... 65
Gambar 4.6. Implementasi Simulasi ................................................................................... 65
Gambar 4.7. Implementasi Output ...................................................................................... 65
Gambar 4.8. Implementasi Area Simulasi ........................................................................... 66
Gambar 4.9. Implementasi Permukaan Meja ...................................................................... 67
Gambar 4.10. Implementasi Balok dan Label ..................................................................... 67
Gambar 4.11. Implementasi Tangan Robot ......................................................................... 68
Gambar 4.12. Implementasi Tangan Robot saat Memegang Balok .................................... 68
Gambar 4.13. Pesan Kesalahan Jumlah Balok Tidak Valid ................................................ 72
Gambar 4.14. Pengujian Memasukkan Jumlah Balok ......................................................... 72
Gambar 4.15. Pengujian Memasukkan Initial State ............................................................ 73
Gambar 4.16. Pesan Kesalahan Jumlah Balok pada Kotak Isian Tidak Valid .................... 73
Gambar 4.17. Pengujian Tombol Proses Initial State .......................................................... 73
Gambar 4.18. Pengujian Memasukkan Goal State .............................................................. 74
Gambar 4.19. Pengujian Tombol Proses Goal State ........................................................... 74
Gambar 4.20. Pengujian Menekan Tombol Temukan Solusi .............................................. 74
xii
Gambar 4.21. Pengujian Menyimpan Simulasi ................................................................... 75
Gambar 4.22. Berkas Hasil Pengujian Simpan Simulasi..................................................... 75
Gambar 4.23. Contoh Output Sebuah Solusi ....................................................................... 76
Gambar 4.24. Tangan Robot Memindahkan Balok Berdasarkan Langkah Solusi .............. 76
Gambar 4.25. Pengujian Tombol untuk Menjalankan dan Menghentikan Simulasi ........... 76
Gambar 4.26. Hasil Pengujian Frame Per Second .............................................................. 77
Gambar 4.27. Hasil Pengujian Mengubah Luas Area Simulasi .......................................... 77
Gambar 4.28. Grafik Hubungan Jumlah Balok Terhadap Lama Pencarian ........................ 79
Gambar 4.29. Grafik Perbandingan Antara Jumlah Solusi dengan Solusi Optimal ............ 79
xiii
DAFTAR TABEL
Hal
Tabel 2.1. Perbandingan Generate and Test, Hill Climbing dan Best-First Search ............. 8
Tabel 2.2. Daftar Operator untuk Tangan Robot ................................................................. 11
Tabel 2.3. Titik Penyusun .................................................... Error! Bookmark not defined.
Tabel 2.4. Permukaan (Face) ............................................... Error! Bookmark not defined.
Tabel 2.5. Simbol yang Dipakai pada Flowchart ................ Error! Bookmark not defined.
Tabel 2.6. Penomoran Level pada DFD .............................. Error! Bookmark not defined.
Tabel 2.7. Simbol DFD Versi Yourdan dan De Marco ....... Error! Bookmark not defined.
Tabel 3.1. SRS Fungsional .................................................................................................. 32
Tabel 3.2. SRS Non Fungsional .......................................................................................... 32
Tabel 4.1. Identifikasi dan Rencana Pengujian ................................................................... 70
Tabel 4.2. Hasil Pengujian Algoritma Perencanaan STRIPS .............................................. 80
xiv
DAFTAR KODE
Hal
Kode 2.1. Operator pada Algoritma Perencanaan STRIPS [5] ........................................... 10
Kode 2.2. Kondisi ditinjau dari sudut pandang balok ......................................................... 10
Kode 2.3. Kondisi ditinjau dari sudut pandang tangan robot .............................................. 11
Kode 2.4. Daftar PAD untuk Operator dalam Dunia Balok ................................................ 12
Kode 2.5. Rencana Penyelesaian dari Sussman Anomaly................................................... 15
Kode 2.6. Rencana Penyelesaian yang Efisien .................................................................... 16
Kode 3.1. Contoh Sebuah Rencana Penyelesaian pada Dunia Balok ................................. 31
Kode 4.1. Implementasi Fungsi Buka Berkas ..................................................................... 56
Kode 4.2. Implementasi Fungsi Konversi Berkas ............................................................... 56
Kode 4.3. Implementasi Fungsi Gambar Balok .................................................................. 57
Kode 4.4. Implementasi Fungsi Susun Tumpukan .............................................................. 57
Kode 4.5. Implementasi Fungsi Temukan Solusi ................................................................ 59
Kode 4.6. Implementasi Fungsi Pangkas Solusi ................................................................. 60
Kode 4.7. Implementasi Fungsi Simpan Solusi ................................................................... 61
Kode 4.8. Implementasi Fungsi Jalankan Simulasi ............................................................. 62
1
BAB I
PENDAHULUAN
1.1. Latar Belakang
Sejarah grafika telah dimulai sejak zaman dahulu kala yaitu ketika bangsa
Mesir, Roma dan Yunani berkomunikasi secara grafik. Beberapa lukisan yang
terdapat pada batu nisan orang Mesir dapat dikatakan sebagai lukisan Teknik. Pada
mulanya, perkembangan grafika komputer interaktif tidak begitu cepat karena
teknologi, jumlah dan harga komputer tidak mendukungnya. Perkembangan
perangkat keras (hardware) saat ini sudah berada pada tingkat yang sangat tinggi.
Berawal dari hal tersebut mulai dikembangkan aplikasi yang memungkinkan
pengguna untuk menjalankan simulasi.
Kecerdasan buatan (Artificial Intelligence, AI) seperti bidang ilmu lainnya juga
memiliki sejumlah subdisiplin ilmu yang sering digunakan untuk pendekatan yang
esensial bagi penyelesaian suatu masalah dan dengan aplikasi bidang AI yang
berbeda. Terdapat empat teknik untuk menyelesaikan suatu permasalahan pada AI,
yaitu pencarian (searching), penalaran (reasoning), perencanaan (planning) dan
pembelajaran (learning). [16]
Dunia Balok (Blocks World) merupakan salah satu permasalahan dalam area
aplikasi AI. Dunia Balok terdiri atas sejumlah balok yang diletakkan di atas meja.
Tugas dalam Dunia Balok adalah menata balok dengan cara tertentu menggunakan
tangan robot yang hanya dapat mengangkat satu balok pada satu waktu.
Penelitian untuk menyelesaikan permasalahan Dunia Balok telah banyak
dilakukan. Salah satu metode yang diusulkan yaitu menggunakan teknik pencarian.
Beberapa algoritma teknik pencarian heuristic yang dapat dipakai untuk
menyelesaikan permasalahan Dunia Balok adalah Generate and Test, Hill Climbing
dan Best-First Search. Algoritma ini berusaha mencari solusi yang dibutuhkan untuk
memindahkan balok dari initial state menuju goal state. [15]
2
Untuk memperlihatkan simulasi penyelesaian Dunia Balok, terdapat aplikasi
yang dibangun menggunakan teknik pencarian untuk menelusuri Goal Trees
(beberapa menyebutnya AND/OR Trees). Keterbatasan pada aplikasi ini hanya dapat
mensimulasikan delapan balok dan area simulasinya masih sebatas bangun datar dua
dimensi, sehingga belum dapat mewakili balok yang sesungguhnya. [18]
Selain menggunakan teknik pencarian (searching), untuk menyelesaikan
permasalahan Dunia Balok dapat menggunakan teknik perencanaan (planning).
Planning berusaha mengatasi kesulitan-kesulitan yang dialami oleh searching dalam
hal waktu proses dan kebutuhan memori. Salah satu algoritma dalam planning yaitu
STRIPS (Stanford Research Institute Problem Solving).
1.2. Rumusan Masalah
Berdasarkan latar belakang yang telah diuraikan maka dapat diangkat rumusan
masalah yaitu bagaimana membuat aplikasi simulasi penyelesaian masalah Dunia
Balok menggunakan algoritma perencanaan STRIPS dengan Delphi dan OpenGL
yang dapat memperlihatkan area simulasi dan Balok dalam pandangan tiga dimensi.
1.3. Tujuan dan Manfaat
Tujuan yang ingin dicapai dalam Tugas Akhir ini adalah menghasilkan sebuah
aplikasi untuk mensimulasikan penyelesaian masalah (problem solving) pada Dunia
Balok menggunakan algoritma perencanaan STRIPS dengan pemrograman Pascal
Delphi dan pustaka grafika OpenGL. Penggunaan OpenGL bertujuan memperoleh
penggambaran area simulasi dan Balok dalam pandangan tiga dimensi yang
mencakup pewarnaan, pencahayaan dan pemberian tekstur.
Manfaat aplikasi simulasi ini yaitu:
1. Memperlihatkan penyelesaian masalah pada Dunia Balok.
2. Dipergunakan sebagai alat bantu pembelajaran kecerdasan buatan, khususnya
pada bidang terapan perencanaan (planning) dan robotik.
3
1.4. Ruang Lingkup
Ruang lingkup aplikasi simulasi penyelesaian masalah Dunia Balok
menggunakan algoritma perencanaan STRIPS dengan Delphi dan OpenGL adalah
sebagai berikut:
1. Input berupa jumlah balok, initial state dan goal state dari Dunia Balok.
2. Area simulasi dan balok dalam tiga dimensi dengan ukuran dan warna balok
ditentukan oleh program.
3. Jumlah balok maksimal adalah 52 karena label balok menggunakan karakter
„A‟-„Z‟ dan „a‟-„z‟.
4. STRIPS sebagai algoritma perencanaan dengan kondisi initial state dan goal
state didefinisikan secara lengkap.
5. Output berupa tampilan animasi dan langkah penyelesaian Dunia Balok.
6. Bentuk implementasi menggunakan bahasa pemrograman Delphi dan pustaka
grafika OpenGL.
1.5. Sistematika Penulisan
Sistematika yang digunakan dalam penulisan tugas akhir ini adalah:
BAB I : Merupakan pendahuluan yang berisi latar belakang, rumusan masalah,
tujuan dan manfaat, ruang lingkup serta sistematika penulisan.
BAB II : Merupakan teori-teori penunjang yang berisi tentang kecerdasan buatan,
Dunia Balok, algoritma perencanaan STRIPS, Grafika Komputer, Data
Flow Diagram (DFD), Flowchart, Delphi dan OpenGL.
BAB III : Merupakan proses pembangunan aplikasi, yaitu gambaran umum
aplikasi, analisis kebutuhan dan perancangan aplikasi
BAB IV : Merupakan proses pengembangan aplikasi dan hasil yang didapat
pada tahap implementasi. Bab ini juga berisi rincian pengujian
aplikasi.
BAB V : Merupakan penutup yang berisi kesimpulan dan saran.
4
BAB II
LANDASAN TEORI
2.1. Kecerdasan Buatan
Kecerdasan Buatan (Artificial Intelligence, AI) merupakan cabang dari ilmu
komputer yang mempelajari tingkah laku cerdas. Definisi ini menunjukkan bahwa
kecerdasan buatan adalah bagian dari komputer sehingga harus didasarkan pada teori
dan prinsip-prinsip aplikasi dari bidangnya. Prinsip-prinsip ini meliputi struktur data
yang digunakan dalam representasi pengetahuan tersebut, serta bahasa dan teknik
pemrograman yang digunakan dalam mengimplementasikannya. [1]
Stuart Russel dan Peter Norvig [12] mengelompokkan definisi kecerdasan
buatan ke dalam empat kategori, yaitu:
1. Thinking humanly (berpikir seperti manusia)
Pendekatan ini dilakukan dengan dua cara sebagai berikut:
a. Melalui introspeksi, mencoba menangkap pemikiran-pemikiran manusia
pada saat berpikir. Seorang psikolog Barat mengatakan, “How do people
know that they understand?” Karena pada saat manusia menyadari
pemikirannya, ternyata pemikiran tersebut sudah lewat dan digantikan
kesadaran.
b. Melalui eksperimen-eksperimen psikologi.
2. Acting humanly (bertingkah seperti manusia)
Pada tahun 1950, Alan Turing merancang suatu ujian bagi komputer
berintelejensia untuk menguji apakah komputer tersebut mampu mengelabui
seorang manusia yang menginterogasinya melalui teletype (komunikasi berbasis
teks jarak jauh). Jika interrogator tidak dapat membedakan yang diinterogasi
adalaha manusia atau komputer, maka komputer berintelejensia tersebut lolos
dari Turing Test.
5
3. Thinking rationally (berpikir secara rasional)
Terdapat dua masalah dalam pendekatan ini, yaitu:
a. Tidak mudah untuk membuat pengetahuan informal dan menyatakan
pengetahuan tersebut ke dalam formal term yang diperlukan oleh notasi
logika.
b. Terdapat perbedaan besar antara dapat memecahkan masalah “dalam
prinsip” dan memecahkannya “dalam dunia nyata”.
4. Acting rationally (bertingkah secara rasional)
Membuat inferensi yang logis merupakan bagian dari suatu rational agent.
Hal ini disebabkan satu-satunya cara untuk melakukan aksi secara rasional
adalah dengan menalar secara logis. Dengan menalar secara logis, maka
didapatkan kesimpulan bahwa aksi yang diberikan akan mencapai tujuan atau
tidak. Jika mencapai tujuan, maka agent dapat melakukan aksi berdasarkan
kesimpulan tersebut.
Aplikasi yang menggunakan kecerdasan buatan akan mencoba untuk
memberikan output berupa solusi dari suatu masalah berdasarkan kumpulan
pengetahuan yang ada. [7]
Gambar 2.1. Aplikasi yang Menggunakan Kecerdasan Buatan
Pada Gambar 2.1, input yang diberikan pada aplikasi kecerdasan buatan berupa
masalah. Aplikasi dilengkapi dengan sekumpulan pengetahuan yang ada pada basis
pengetahuan. Aplikasi juga memiliki inference engine agar mampu mengambil
kesimpulan berdasarkan fakta atau pengetahuan. Output yang diberikan berupa solusi
masalah sebagai hasil dari inferensi .
6
Secara umum, untuk membangun suatu aplikasi yang mampu menyelesaikan
suatu masalah, perlu dipertimbangkan 4 (empat) hal:
1. Mendefinisikan masalah dengan tepat. Pendefinisian ini mencakup spesifikasi
yang tepat mengenai keadaan awal dan solusi yang diharapkan.
2. Menganalisis masalah tersebut serta mencari beberapa teknik penyelesaian
masalah yang sesuai.
3. Merepresentasikan pengetahuan yang perlu untuk menyelesaikan masalah
tersebut.
4. Memilih teknik penyelesaian masalah yang terbaik.
Di dalam kecerdasan buatan dikenal empat teknik penyelesaian masalah, yaitu:
searching, reasoning, planning dan learning. Dari setiap teknik tersebut, terdapat
banyak metode yang diusulkan dan sudah dibuktikan secara matematis maupun
empiris. Penggunaan teknik dan metode sangat bergantung pada permasalahan yang
akan diselesaikan. [16]
2.2. Penyelesaian Dunia Balok Menggunakan Teknik Searching
Dunia Balok (Blocks World) dinilai cukup layak sebagai lahan pengujian pada
kecerdasan buatan karena tingkat kompleksitas permasalahan yang mungkin timbul
di dalamnya. Di Dunia Balok dikenal istilah initial-state dan goal-state yang
masing-masing direpresentasikan oleh suatu komposisi dari sejumlah balok.
Kemudian, ada satu set operator yang dapat diaplikasikan oleh sebuah tangan robot
untuk memanipulasi balok. Gambar 2.2 memperlihatkan contoh Dunia Balok. [16]
Gambar 2.2. Dunia Balok
(Sumber: http://www.comp.dit.ie/jkelleher/ai1labs/Practical13/Practical13.html)
7
Tugas khusus dalam Dunia Balok adalah menata balok dengan cara tertentu
menggunakan tangan robot yang hanya dapat mengangkat satu balok pada satu
waktu. Permasalahan yang ada di dalam Dunia Balok yaitu, menyusun rangkaian
operator yang dapat mengubah initial-state menjadi goal-state. Rangkaian operator
tersebut biasa disebut sebagai rencana penyelesaian.
Dunia Balok adalah sebuah domain dengan karakteristik:
1. Memiliki sebuah permukaan datar tempat menyimpan balok, umumnya disebut
dengan meja.
2. Memiliki sejumlah balok.
3. Memiliki sebuah tangan robot yang dapat memanipulasi balok.
Algoritma pada Dunia Balok diuji dengan menghitung waktu dan jumlah
gerakan yang dibutuhkan untuk memindahkan balok dari initial state menuju goal
state. Tiga algoritma Heuristic yang diuji Pambudi Soenarsihanto dan Mira Hidayati
pada Lokakarya Komputasi Dalam Sains dan Teknologi Nuklir V adalah Generate
and Test, Hill Climbing dan Best-First Search. [15]
Algoritma Generate and Test memilih sebuah successor dari sebuah state
secara acak. Jadi pada kasus tertentu, jika bernasib baik maka akan mendapatkan
solusi yang bagus dengan jumlah gerakan perpindahan sedikit dalam waktu yang
singkat. Tetapi pada kasus-kasus yang lain ketika bernasib buruk akan mendapatkan
solusi yang jelek dengan banyak gerakan perpindahan dan waktu yang lama.
Adakalanya algoritma ini menghasilkan beberapa kali solusi salah yang sama persis
diakibatkan oleh proses pengambilan keputusan secara random.
Algoritma Hill Climbing adalah algoritma yang tercepat dalam studi
perbandingan yang dilakukan Pambudi Soenarsihanto dan Mira Hidayati. Setiap kali
berada pada suatu state, akan dihadapkan pada pemilihan sebuah successor dan
langsung turun ke kedalaman berikutnya sampai dengan tercapainya solusi. Proses
ini tentu saja memakan waktu yang cepat. Tetapi ada beberapa kasus di mana tidak
ada successor yang lebih baik daripada predecessor-nya. Ini disebabkan oleh
pengambilan state yang salah pada kedalaman sebelumnya, mengingat bahwa yang
terbaik pada satu kedalaman belum tentu akan terbaik untuk seterusnya. Dalam
8
kasus-kasus tersebut algoritma akan menemui jalan buntu dan tidak akan
menemukan goal state.
Algoritma Best-First Search adalah algoritma yang terbaik dalam studi
perbandingan tersebut. Dengan menggunakan algoritma ini pasti akan mendapatkan
goal state, karena adanya kemungkinan untuk kembali pada simpul-simpul yang
berada pada kedalaman sebelumnya. Dan goal state tersebut juga bagus ditinjau dari
jumlah gerakan yang dilakukan. Kendala untuk algoritma ini adalah lamanya waktu
pencarian. Karena adakalanya harus pergi ke state-state lain yang nilai evaluasinya
lebih baik. Selain itu juga dibutuhkan banyak tempat dalam memori untuk
menyimpan semua state yang masih mungkin dipilih pada kelanjutan proses
pencarian goal state.
Tabel 2.1 memperlihatkan hasil studi perbandingan dari tiga algoritma yang
dikerjakan Pambudi Soenarsihanto dan Mira Hidayati.
Tabel 2.1. Perbandingan Generate and Test, Hill Climbing dan Best-First Search
Jml Balok Generate and Test Hill Climbing Best-First Search
Jml Gerakan Waktu (ms) Jml Gerakan Waktu (ms) Jml Gerakan Waktu (ms)
3 6 0 4 0 4 0
4 9 10 7 0 7 60
5 12 20 10 10 9 80
6 15 20 - - 12 90
7 18 40 16 10 14 110
8 21 60 - - 17 220
9 24 80 21 20 19 400
10 27 100 24 20 22 720
Selain menggunakan teknik pencarian (searching) untuk menyelesaikan
permasalahan pada Dunia Balok ada satu teknik lagi yang dapat dipakai, yaitu
perencanaan (planning).
9
2.3. Perencanaan (Planning)
Pada kamus Oxford Advanced Learner’s, terdapat empat definisi yang
mengacu pada istilah plan (rencana), yaitu:
1. Ide atau metode yang telah dipikirkan secara detail sebelum menyelesaikan
suatu pekerjaan. Misalnya, idea atau metode untuk mengalahkan tim lawan
dalam suatu pertandingan sepak bola.
2. Diagram atau peta detail tentang bagian-bagian penting suatu kota, gedung,
mesin dan sebagainya.
3. Cara penyusunan suatu benda. Misalnya, susunan tempat duduk
4. Penyusunan keuangan sehingga seseorang akan mendapatkan keuntungan.
Misalnya, pensiun atau rencana investasi.
Planning (perencanaan) didefinisikan sebagai action or process of making
plans for something (aksi atau proses membuat rencana untuk sesuatu). Perencanaan
dalam kecerdasan buatan adalah suatu metode penyelesaian masalah dengan
memecah masalah ke dalam sub-sub masalah yang lebih kecil, menyelesaikan sub-
sub masalah satu demi satu, kemudian menggabungkan solusi-solusi dari sub-sub
masakah tersebut menjadi sebuah solusi lengkap dengan tetap mengingat dan
menangani interaksi yang terdapat pada sub-sub masalah tersebut. [16]
2.3.1. Algoritma Perencanaan STRIPS
Penelitian dari perencanaan (planning) dimulai dengan suatu perancangan
robot yang mampu melaksanakan tugas dengan beberapa fleksibilitas dan
responsivitas tertentu. Perencanaan merupakan persoalan yang sukar karena beberapa
alasan, di antaranya adalah ukuran deretan ruang kemungkinan dari gerakannya.
STRIPS merupakan singkatan dari STanford Research Institute Problem
Solver, sebuah pendekatan yang dikembangkan oleh Richard Fikes dan Nils Nilsson
untuk menyelesaikan permasalahan dunia balok. STRIPS menggambarkan
permasalahan ke dalam sebuah model. Di dalam model tersebut terdapat operator
yang dapat dipakai untuk mengubah suatu model (initial) ke dalam model lain (goal).
Nama Stanford sendiri sekarang telah berganti nama menjadi SRI International. [4]
10
Pada STRIPS, lingkup permasalahan didefinisikan ke dalam tiga entitas:
1. Initial State
2. Goal State
3. Operator, yang di dalamnya mencakup precondition dan effect.
Persyaratan yang harus dipenuhi agar suatu operator dapat diaplikasikan disebut
Precondition. Setelah suatu operator diaplikasikan, maka keadaan akan berubah
(effect). Keadaan yang ditambahkan setelah operator diaplikasikan disebut Add.
Dan keadaan yang dihapus setelah operator diaplikasikan disebut Delete.
Operator pada algoritma perencanaan STRIPS dapat dilihat pada kode 2.1.
Kode 2.1. Operator pada Algoritma Perencanaan STRIPS [5]
Untuk mendefinisikan kondisi balok pada suatu state dalam Dunia Balok
digunakan predikat-predikat berikut:
1. ON(A,B) – Balok A menempel di atas balok B.
2. ONTABLE(A) – Balok A berada di permukaan meja.
3. CLEAR(A) – Tidak ada balok yang sedang menempel di atas balok A.
Kondisi-kondisi tersebut direpresentasikan dalam First-Order Logic. First-
Order Logic adalah logic atau bahasa formal yang mencukupi untuk
merepresentasikan pengetahuan. Definisi kondisi ditinjau dari sudut pandang balok
dapat dilihat pada kode 2.2.
Kode 2.2. Kondisi ditinjau dari sudut pandang balok
∀𝑥 ONTABLE 𝑥 → ¬HOLDING 𝑥 ∧ ¬∃y 𝑂𝑁 𝑥, 𝑦
∀𝑥 CLEAR 𝑥 → ¬∃𝑦 𝑂𝑁 𝑦, 𝑥
∀𝑥 ∃y 𝑂𝑁 𝑥, 𝑦 → ¬HOLDING 𝑥 ∧ ¬HOLDING 𝑦 ∧ ¬𝑂𝑁 𝑦, 𝑥 ∧
¬∃𝑧 𝑂𝑁 𝑥, 𝑧 ∨ 𝑂𝑁(𝑦, 𝑧)
𝑖𝑓 < 𝑝𝑟𝑒𝑐𝑜𝑛𝑑𝑖𝑡𝑖𝑜𝑛𝑠 >
𝑡ℎ𝑒𝑛 (𝑟𝑒𝑡𝑟𝑎𝑐𝑡 < 𝑑𝑒𝑙𝑒𝑡𝑖𝑜𝑛𝑠 >)(𝑎𝑠𝑠𝑒𝑟𝑡 < 𝑎𝑑𝑑𝑖𝑡𝑖𝑜𝑛𝑠 >)
11
Sedangkan, untuk tangan robot digunakan :
1. HOLDING(A) – Tangan robot sedang memegang balok A.
2. ARMEMPTY – Tangan robot tidak sedang memegang balok.
Kondisi-kondisi tangan robot direpresentasikan dalam notasi First-Order Logic
dapat dilihat pada kode 2.3.
Kode 2.3. Kondisi ditinjau dari sudut pandang tangan robot
Untuk merepresentasikan suatu keadaan di Dunia Balok ke dalam notasi-notasi
First-Order Logic digunakan kondisi dari balok dan kondisi dari tangan robot.
Gambar 2.3 memperlihatkan contoh state pada Dunia Balok.
Gambar 2.3. Contoh Dua Buah State pada Dunia Balok
Selanjutnya untuk mengubah suatu keadaan menjadi keadaan yang lain,
diperlukan suatu operator. Tabel 2.2 memperlihatkan empat operator yang digunakan
pada Dunia Balok.
Tabel 2.2. Daftar Operator untuk Tangan Robot
Operator Hal yang Dilakukan
STACK(A,B) Menempelkan balok A di atas balok B
UNSTACK(A,B) Mengangkat balok A yang menempel di atas balok B
PICKUP(A) Mengangkat balok A dari permukaan meja
PUTDOWN(A) Menempelkan balok A di permukaan meja
∃𝑥 HOLDING 𝑥 → ¬ARMEMPTY ∧ ¬ONTABLE 𝑥 ∧ ¬∃𝑦 𝑂𝑁 𝑥, 𝑦 ∨ 𝑂𝑁(𝑦, 𝑥)
ARMEMPTY → ¬∃𝑥 HOLDING 𝑥
12
Suatu operator dapat diaplikasikan apabila persyaratan (precondition)
terpenuhi. Misalnya, STACK(A,B) dapat diaplikasikan jika kedua kondisi:
CLEAR(B) dan HOLDING(A) adalah benar. Jadi, setelah STACK(A,B)
diaplikasikan, maka keadaan yang ditambahkan (Add) adalah: ARMEMPTY dan
ON(A,B). Sedangkan keadaan yang dihapus (Delete) adalah: CLEAR(B) dan
HOLDING(A).
Daftar lengkap tentang Precondition, Add dan Delete untuk keempat operator
dalam dunia balok ditunjukkan oleh kode 2.4.
O : STACK(X,Y)
P : HOLDING(X)^CLEAR(Y)
A : ON(X,Y)^CLEAR(X)^ARMEMPTY
D : HOLDING(X)^CLEAR(Y)
O : UNSTACK(X,Y)
P : ARMEMPTY^CLEAR(X)^ON(X,Y)
A : CLEAR(Y)^HOLDING(X)
D : ON(X,Y)^CLEAR(X)^ARMEMPTY
O : PICKUP(X)
P : ARMEMPTY^CLEAR(X)^ONTABLE(X)
A : HOLDING(X)
D : ONTABLE(X)^CLEAR(X)^ARMEMPTY
O : PUTDOWN(X)
P : HOLDING(X)
A : ONTABLE(X)^CLEAR(X)^ARMEMPTY
D : HOLDING(X)
Keterangan :
O : Operator
P : Precondition
A : Add
D : Delete
Kode 2.4. Daftar PAD untuk Operator dalam Dunia Balok
13
2.3.2. Stack
Stack (Tumpukan) adalah struktur data dimana seluruh akses hanya dapat
dilakukan pada elemen yang terakhir ditambahkan. Contoh Stack dalam kehidupan
sehari-hari adalah tumpukan piring di sebuah restoran yang tumpukannya dapat
ditambah pada bagian paling atas dan jika mengambilnya pun dari bagian paling atas
pula. Gambar 2.4 memperlihatkan tumpukan koin, buku dan tumpukan dalam
implementasinya pada komputer. Stack menganut kaidah Last In First Out (LIFO).
Gambar 2.4. Stack
Dua operasi dasar pada Tumpukan adalah Push (operasi pemasukan elemen ke
dalam Tumpukan) dan Pop (operasi pengambilan satu elemen dari dalam
Tumpukan). Ilustrasi operasi push pada stack diperlihatkan gambar 2.5 dan ilustrasi
operasi pop diperlihatkan gambar 2.6.
Gambar 2.5. Operasi Push pada Stack
Gambar 2.6. Operasi Pop pada Stack
14
2.3.3. Tumpukan (Stack) dalam STRIPS
Dalam implementasinya ke dalam bahasa pemrograman, STRIPS
dikolaborasikan dengan struktur data Stack (Tumpukan). Kondisi-kondisi yang
merupakan goal state disimpan ke dalam sebuah Stack. Kondisi ini dapat berupa goal
tunggal, goal majemuk ataupun sebuah Operator.
Algoritma perencanaan STRIPS menggunakan Stack diperlihatkan pada
gambar 2.7. STRIPS akan bekerja memeriksa kondisi teratas pada Stack dan
mengerjakan langkah yang sesuai. Pemeriksaan ini akan terus dilakukan sampai
Stack telah kosong atau ketika goal state telah tercapai.
Gambar 2.7. Algoritma Perencanaan STRIPS menggunakan Stack [14]
Stack is empty ?
Push the goal on the stack
Begin
1
Pop goal from stack
Goal is achieved ?
Separate the complex goal
into sub goals
Permute the sub goals
Push the sub goals on stack
Pop action from stack
Apply action (do adds &
deletes)
Add action to plan
1
End
Goal is achieved ?
Pop goal from stack
Find one action that has the
goal in it’s add list
Pop the goal from stack
Push the action on the stack
Push the action’s
preconditions on the stack as
a compound goal
goal is compound ?
Stack top is goal ?
Yes
Yes Yes
No
No No
Yes
Yes
No
No
15
2.3.4. Sussman Anomaly
Sussman Anomaly adalah salah satu permasalahan kecerdasan buatan pada
domain dunia balok yang memperlihatkan kelemahan dari algoritma perencanaan.
Penyimpangan ini ditemukan oleh Alien Brown dan pertama kali dijelaskan oleh
Gerald Sussman. [12]
Gambar 2.8 memperlihatkan satu contoh kondisi pada Sussman Anomaly yang
terdiri atas tiga balok. Initial state: ONTABLE(A)^ONTABLE(B)^ON(C,A). Notasi
Goal State: ONTABLE(C)^ON(B,C)^ON(A,B). Solusi yang akan dihasilkan oleh
algoritma perencanaan STRIPS dapat dilihat pada kode 2.5.
Gambar 2.8. Tumpukan balok yang dikenal sebagai Sussman Anomaly
1. UNSTACK(C,A)
2. PUTDOWN(C)
3. PICKUP(A)
4. STACK(A,B)
5. UNSTACK(A,B)
6. PUTDOWN(A)
7. PICKUP(B)
8. STACK(B,C)
9. PICKUP(A)
10. STACK(A,B)
Kode 2.5. Rencana Penyelesaian dari Sussman Anomaly
Solusi pada kode 2.5 bukanlah sebuah rencana penyelesaian yang efisien.
Langkah 4 dan langkah 5 adalah dua langkah yang tidak mengubah kondisi.
Demikian juga langkah 3 dan langkah 6 adalah dua langkah yang tidak mengubah
16
kondisi. Rencana penyelesaian yang efisien untuk masalah Sussman Anomaly
tersebut dapat dilihat pada kode 2.5.
1. UNSTACK(C,A)
2. PUTDOWN(C)
3. PICKUP(B)
4. STACK(B,C)
5. PICKUP(A)
6. STACK(A,B)
Kode 2.6. Rencana Penyelesaian yang Efisien
Sebuah prosedur pruning (pemangkasan) dapat ditambahkan untuk menghapus
pasangan-pasangan langkah yang tidak perlu, yaitu pasangan STACK(x,y) dan
UNSTACK(x,y) serta pasangan PICKUP(x) dan PUTDOWN(x). Dari penambahan
prosedur ini dapat dihasilkan rencana penyelesaian yang efisien. [16]
2.4. Grafika Komputer
Grafika komputer merupakan sekumpulan alat yang digunakan untuk membuat
gambar dan berinteraksi dengan gambar dengan cara-cara seperti yang biasa
digunakan. Sekumpulan peralatan tersebut memberi fasilitas kepada programmer
untuk membuat program-program grafis yang baik. [10]
Salah satu pengaplikasian grafika komputer adalah untuk simulasi. Simulasi
sendiri dapat diartikan sebagai suatu sistem yang digunakan untuk memecahkan atau
menguraikan persoalan-persoalan dalam kehidupan nyata yang penuh dengan
ketidakpastian dengan menggunakan model atau metode tertentu dan lebih
ditekankan pada pemakaian komputer untuk mendapatkan solusinya. [6]
Simulasi merupakan salah satu cara untuk memecahkan berbagai persoalan
yang dihadapi di dunia nyata (real world). Simulasi memberikan hasil yang cukup
baik bila digunakan untuk memecahkan berbagai persoalan, termasuk dalam
pembuatan perencanaan kegiatan.
17
2.5. Delphi
Bahasa Pascal pada mulanya dirancang tahun 1971 oleh profesor Niklaus
Wirth di Polytechnic of Zurich, Switzerland. Ide utama bahasa Pascal adalah perintah
yang diatur melalui suatu konsep tipe data, dan membutuhkan deklarasi dan kontrol
program terstruktur. Pada tahun 1983 Borland merilis compiler Turbo Pascal dan
memperkenalkan Integrated Development Environment (IDE) dimana programmer
dapat mengedit kode, menjalankan compiler, melihat error dan melompat kembali ke
baris yang berisi error.
Setelah 9 (sembilan) versi compiler Turbo Pascal, Borland merilis Delphi
tahun 1995 yang mengubah Pascal ke dalam bahasa pemrograman visual. Pada 14
November 2006, pengembangan Delphi diserahkan kepada anak perusahaan,
CodeGear. Dua tahun berselang, CodeGear diakuisisi oleh Embarcadero
Technologies. Tahun 2010 Embarcadero merilis Delphi 2010 dengan codename
Weaver. [9]
Gambar 2.9 memperlihatkan lingkungan IDE Delphi 2010 yang terdiri atas
beberapa bagian dan setiap bagiannya memiliki komponen dan fungsi tertentu.
Gambar 2.9. Lingkungan IDE Delphi 2010 (codename: Weaver)
Dalam pembuatan aplikasi grafika interaktif, penggunaan Delphi sendiri
tidaklah cukup. Penggunaan pustaka (library) grafika mutlak diperlukan. Salah satu
paket grafik yang dapat digabungkan dengan Delphi adalah OpenGL (Open Graphic
Library).
18
2.6. OpenGL
OpenGL adalah singkatan dari Open Graphic Library. OpenGL diproduksi
oleh Silicon Graphic dan awalnya ditujukan hanya untuk sistem komputer mereka.
Dalam perkembangannya, OpenGL dijadikan salah satu bakuan (standar) dalam
dunia grafika komputer. OpenGL merupakan pustaka program (program library)
yang menyediakan sejumlah perintah yang berhubungan dengan grafika. [10]
OpenGL adalah antarmuka pemrograman aplikasi atau API (Application
Programming Interface) yang tidak tergantung pada piranti dan platform yang
digunakan. Antarmuka ini mempunyai kurang lebih sebanyak 150 fungsi atau
prosedur yang dibutuhkan dalam membuat suatu aplikasi tiga dimensi yang
interaktif.
2.6.1. Sistem Koordinat
Ada dua cara menyatakan sistem koordinat tiga dimensi, yaitu aturan tangan
kiri dan aturan tangan kanan. Pada dasarnya perbedaan antara dua aturan tersebut
adalah kemana sumbu 𝑥+ menunjuk.
(a) Aturan tangan kiri
(b) Aturan tangan kanan
Gambar 2.10. Representasi Sumbu Tiga Dimensi [3]
Pada Gambar 2.10 (a) atau aturan tangan kiri, sumbu 𝑥+ ditunjuk oleh ibu jari
dan mengarah ke kanan sedangkan pada Gambar 2.10 (b) (aturan tangan kanan),
sumbu 𝑥+ menuju arah kiri. Pada kedua aturan tersebut, sumbu 𝑦+ maupun 𝑧+
menuju ke arah yang sama. OpenGL menggunakan aturan tangan kanan untuk
merepresentasikan koordinat dunia tiga dimensi.
19
2.6.2. Transformasi
Transformasi merupakan metode untuk mengubah lokasi titik. Apabila
transformasi dikenakan terhadap sekumpulan titik yang membentuk sebuah benda
maka benda tersebut akan mengalami perubahan. Transformasi dapat berupa
transformasi dasar ataupun gabungan dari berbagai transformasi geometri. Contoh
transformasi geometri adalah translasi, rotasi dan penskalaan.
Menurut Suyoto [17] tujuan transformasi adalah:
1. Mengubah atau menyesuaikan komposisi pemandangan
2. Memudahkan membuat obyek yang simetris
3. Melihat obyek dari sudut pandang yang berbeda
4. Memindahkan satu atau beberapa obyek dari satu tempat ke tempat lain, ini
biasa dipakai untuk animasi komputer.
2.6.3. Pandangan (Viewing)
Untuk menghasilkan obyek 3D yang nampak riil maka diperlukan proyeksi
perspektif. Jarak terhadap benda pandangan akan mempengaruhi bagaimana benda
tersebut terlihat. Benda yang terlihat jauh akan kelihatan kecil sedangkan benda yang
dekat akan terlihat lebih besar. Efek ini disebut pemendekan (shortening). Pada
proyeksi perspektif semua garis menghilang pada satu atau lebih titik yang sama atau
disebut titik hilang (vanishing point).
Gambar 2.11. Perspektif Viewing Volume melalui glFrustum [13]
20
Gambar 2.11 memperlihatkan glFrustum pada OpenGL. Perintah glFrustum
menentukan viewing volume berdasarkan left, right, top, bottom, near, far. Semua
obyek yang berada di luar viewing volume akan dipotong. [10]
Secara baku lokasi kamera pada OpenGL terletak pada koordinat (0, 0, 0)
sehingga harus dilakukan penyesuaian agar diperoleh sudut pandang yang lebih baik.
Selain memanipulasi posisi kamera, realisme visual dicapai dengan menambahkan
efek warna dan pencahayaan.
2.6.4. Warna
Model warna RGB (Red, Green , Blue) didasarkan pada teori dimana mata
manusia peka terhadap cahaya dengan panjang gelombang 630 nm (merah), 530 nm
(hijau) dan 450 nm (biru). Dengan mencampur tiga warna dasar tersebut maka akan
dihasilkan berbagai warna yang lain (additive color). Penjumlahan warna merah,
hijau dan biru akan menentukan warna akhir yang dihasilkan, atau dapat dirumuskan:
𝑊 = 𝑅𝑅 + 𝐺𝐺 + 𝐵𝐵 ...................................................................................... (2.1)
dengan RR, GG dan BB bernilai antara 0 dan 1, dimana nilai 0 menyatakan tidak
ada komponen yang digunakan dan nilai 1 menyatakan pemakaian penuh. [10]
Model RGB dapat digambarkan sebagai sebuah kotak yang mempunyai tiga
buah sumbu yaitu: R(ed), G(reen), B(lue) dimana nilai masing-masing sumbu
berkisar dari 0 sampai 1. Warna ditentukan berdasarkan lokasi warna tersebut
terhadap sumbu RGB. Gambar 2.12 menunjukkan model RGB.
Gambar 2.12. Kotak Warna Model RGB [13]
21
2.6.5. Pencahayaan
Efek selanjutnya yang mempengaruhi benda sehingga terlihat nyata atau tidak
adalah tingkat pencahayaan, yaitu efek pewarnaan tingkat kecerahan setiap
permukaan yang terdapat pada obyek gambar.
(a) Tanpa Pencahayaan
(b) Dengan Pencahayaan
Gambar 2.13. Perbedaan Efek Pencahayaan terhadap Benda
Perbedaan efek pencahayaan terhadap suatu benda diperlihatkan gambar 2.13.
Benda (a) hanya diberikan pewarnaan tanpa memperhitungkan pencahayaan,
sedangkan benda (b) selain pemberian warna juga memperhitungkan pencahayaan.
Dengan mengubah-ubah nilai warna di antara permukaan benda, akan dengan mudah
dihasilkan efek pencahayaan. [19]
2.6.6. Benda Tiga Dimensi
Suatu benda dikatakan tiga dimensi apabila mempunyai tiga ukuran: lebar
(width), tinggi (height) dan kedalaman (depth). Perbandingan antara benda dua dan
tiga dimensi diperlihatkan pada gambar 2.14. Kertas digambarkan hanya mempunyai
dimensi lebar dan tinggi. Kaleng soda selain lebar dan tinggi juga memiliki dimensi
kedalaman. Tergantung dari sudut pandang, sebuah sisi dapat dianggap sebagai lebar
atau tinggi. Namun faktanya, kaleng tersebut memiliki tiga dimensi. [19]
Gambar 2.14. Perbandingan Benda Dua dan Tiga Dimensi
22
Sebuah benda tiga dimensi dapat disusun dengan menghubungkan sejumlah
titik. Kumpulan titik-titik yang saling terhubung tersebut disebut sebagai wireframe
atau kerangka, sedangkan benda yang disusun dari kumpulan titik dan permukaan
tersebut disebut sebagai mesh. [10]
Gambar 2.15. Benda Tiga Dimensi dengan Delapan Buah Titik
Benda tiga dimensi yang ada pada gambar 2.15 dapat disusun berdasarkan data
yang ada pada tabel 2.3 dan tabel 2.4 berikut:
Tabel 2.3. Titik Penyusun
Titik X Y Z
0 -1 -1 +1
1 +1 -1 +1
2 +1 +1 +1
3 -1 +1 +1
4 +1 -1 -1
5 -1 -1 -1
6 -1 +1 -1
7 +1 +1 -1
Tabel 2.4. Permukaan (Face)
Face V1 V2 V3 Keterangan
F1.a 0 1 2 Depan
F1.b 0 2 3 Depan
F2.a 1 4 7 Kanan
F2.b 1 7 2 Kanan
F3.a 4 5 6 Belakang
F3.b 4 6 7 Belakang
F4.a 5 3 0 Kiri
F4.b 5 6 3 Kiri
F5.a 3 2 7 Atas
F5.b 3 7 6 Atas
F6.a 0 1 4 Bawah
F6.b 0 4 5 Bawah
Tabel 2.4 menyatakan urutan titik yang menyusun sebuah permukaan. Untuk
setiap permukaan didefinisikan sebagai polygon segitiga (triangle). Sebagai contoh
permukaan bagian depan didefinisikan melalui dua buah segitiga, yaitu F1.a dan F1.b
yang masing-masing disusun dari titik (0, 1, 2) serta titik (0, 2, 3). [10]
23
Pada OpenGL, dengan memanfaatkan modus GL_TRIANGLE_STRIP, setiap
titik akan diproses satu kali dan selanjutnya OpenGL akan menggabungkan 3 titik
berurutan untuk membuat satu permukaan segitiga. Urutan titik apabila dibuka setiap
sisinya diperlihatkan pada gambar 2.16.
Gambar 2.16. Lokasi Titik [10]
Lokasi titik disimpan dalam array menggunakan urutan seperti ditunjukkan
pada gambar 2.17 (a). Apabila urutan titik tersebut digambar dengan modus
GL_TRIANGLE_STRIP maka OpenGL akan menghasilkan permukaan seperti pada
Gambar 2.17 (b).
Gambar 2.17. Hasil Menggambar dengan Modus GL_TRIANGLE_STRIP [10]
Pada implementasinya, penggambaran benda tiga dimensi secara primitif ini
akan dimudahkan oleh GLScene. GLScene adalah library (beberapa orang
mengatakannya sebagai framework) untuk OpenGL. Melalui GLScene, pemrogram
tidak dipusingkan lagi dengan urutan pengiriman titik.
a.
b.
24
2.7. GLScene
GLScene dibuat khusus untuk Delphi. GLScene menjadikan proses
pengembangan aplikasi dengan OpenGL menjadi sangat mudah dan sederhana.
Pertama kali diciptakan oleh Mike Lischke sebagai open source library untuk
komunitas programmer, kini GLScene dilanjutkan oleh Eric Grange dan terus
berkembang sejak saat itu. Telah ada banyak proyek yang dibuat menggunakan
GLScene, mulai dari permainan sederhana hingga aplikasi sains yang kompleks.
GLScene dapat diperoleh dari http://glscene.org. [20]
Gambar 2.18. Tampilan GLScene [2]
GLScene tidak hanya menangani sebatas penggambaran benda tida dimensi,
namun juga menyangkut viewing (tata letak kamera), light source (pencahayaan),
pemberian tekstur hingga efek animasi. Beberapa komponen pada GLScene
diperlihatkan pada gambar 2.18.
Spesifikasi minimum komputer untuk dapat menjalankan GLScene adalah:
1. Delphi 5 (atau lebih baru)
2. Komputer dengan kartu grafis 3D yang mendukung (minimal) OpenGL 1.0
25
Mengenai persyaratan kartu grafis untuk menjalankan GLScene, hal itu akan
berpengaruh terhadap penggambaran benda tiga dimensi. Penggambaran garis pada
OpenGL akan nampak “bergerigi” yang disebut aliasing. Kartu grafis yang bagus
telah menyediakan teknik yang dinamakan anti-aliasing. Perbedaan garis aliasing
dan anti-aliasing diperlihatkan pada gambar 2.19.
Gambar 2.19. Garis aliasing dan anti-aliasing [13]
Secara baku, anti-aliasing GLScene berada dalam kondisi aaDefault.
Apabila kartu grafis sama sekali tidak mendukung anti-aliasing, mode GLScene
akan berada pada aaNone. Penggunaan anti-aliasing pada GLScene diperlihatkan
pada gambar 2.20. Gambar 2.20 (a) menggunakan aaDefault sedangkan gambar
2.20 (b) menggunakan aa4xHQ. Semakin besar nilainya, maka gambar yang
dihasilkan akan semakin halus. Karakter HQ menandakan High Quality. Anti-aliasing
maksimum yang didukung oleh GLScene adalah csa16xHQ.
(a) aaDefault
(b) aa4xHQ
Gambar 2.20. Kubus dengan anti-aliasing Berbeda [2]
Selain berpengaruh pada proses penggambaran, kartu grafis juga berpengaruh
saat proses simulasi, yaitu ketika animasi mulai berjalan. Kartu grafis dengan
kualitas rendah akan menjalankan animasi secara perlahan, bahkan akan ada proses
penggambaran animasi yang terlewat.
26
2.8. Pengembangan Perangkat Lunak
Pengembangan perangkat lunak adalah proses, cara, dan alat untuk
mengembangkan atau upaya meningkatkan mutu suatu perangkat lunak agar dapat
dipakai untuk berbagai keperluan di kehidupan masyarakat modern. Berikut adalah
penjelasan dari metode pengembangan perangkat lunak yang digunakan untuk
membangun aplikasi simulasi pada penelitian tugas akhir ini.
2.8.1. Siklus Hidup Pengembangan Perangkat Lunak
Siklus hidup pengembangan perangkat lunak (Software Development Life
Cycle / SDLC) adalah sebuah kerangka kerja yang disusun dalam sebuah urutan
langkah-langkah atau fase-fase yang jelas dalam pengembangan suatu aplikasi.
Salah satu paradigma dalam SDLC adalah linear sequential model (beberapa
menyebutnya sebagai classic life cycle atau waterfall model).
2.8.2. Linear Sequential Model
Linear sequential model mengusulkan pendekatan sistematis dalam
pengembangan perangkat lunak yang dimulai analisis, desain, penulisan kode,
pengujian dan dukungan. Linear sequential model dalam pengembangan perangkat
lunak diperlihatkan pada gambar 2.21. [11]
Gambar 2.21. Linear Sequential Model dalam Pengembangan Perangkat Lunak
27
Dalam bukunya, Pressman [11] menjelaskan bahwa linear sequential model
mencakup beberapa aktivitas, yaitu:
1. Pemodelan dan rekayasa sistem / informasi (system / information engineering
and modeling)
2. Analisis persyaratan perangkat lunak (software requirements analysis)
3. Desain (design)
4. Penulisan kode (code generation)
5. Pengujian (testing)
6. Dukungan / pemeliharaan (support / maintenance)
Pada pembuatan tugas akhir simulasi penyelesaian masalah dunia balok
menggunakan algoritma perencanaan STRIPS dengan Delphi dan OpenGL, aktivitas
linear sequential model yang dilakukan dibatasi pada pengujian, tanpa melibatkan
tahap keenam, yaitu dukungan atau pemeliharaan.
Ada berbagai alat yang dapat dipakai untuk melakukan kegiatan analisis dan
perancangan suatu aplikasi. Di antara alat-alat tersebut ada yang berupa bagan arus
yang selama ini sering digunakan, yaitu Bagan Alir (flowchart) dan Diagram Aliran
Data (Data Flow Diagram / DFD).
2.8.2.1. Flowchart
Flowchart adalah bagan-bagan yang mempunyai arus yang menggambarkan
langkah-langkah penyelesaian suatu masalah. Flowcart merupakan cara penyajian
dari suatu algoritma. Ladjamudin [8] menjelaskan ada dua macam flowchart yang
menggambarkan proses dengan komputer, yaitu:
1. Flowchart Sistem
Bagan yang memperlihatkan urutan proses dalam sistem dengan menunjukkan
alat media input, output serta jenis media penyimpanan dalam proses pengolahan
data.
2. Flowchart Program
Bagan yang memperlihatkan urutan instruksi yang digambarkan dengan simbol
tertentu untuk memecahkan masalah dalam suatu program.
28
Flowchart disusun dengan simbol. Simbol ini dipakai sebagai alat bantu
menggambarkan proses di dalam program. Beberapa simbol yang dipakai pada
flowchart diperlihatkan pada tabel 2.5.
Tabel 2.5. Simbol yang Dipakai pada Flowchart
Gambar Keterangan
Simbol connector
Untuk menyatakan sambungan dari satu proses ke
proses lainnya dalam halaman / lembar yang sama
Simbol arus / flow
Untuk menyatakan jalannya arus suatu proses
Simbol input-output
Untuk menyatakan proses input dan output tanpa
tergantung dengan jenis peralatannya
Simbol process
Untuk menyatakan suatu tindakan yang dilakukan oleh
komputer
Simbol decision / logika
Untuk menunjukkan suatu kondisi tertentu yang akan
menghasilkan dua kemungkinan jawaban, ya / tidak
Simbol terminal
Untuk menyatakan permulaan atau akhir suatu program
2.8.2.2. Data Flow Diagram
Data Flow Diagram (DFD) merupakan model dari sistem untuk
menggambarkan pembagian sistem ke modul yang lebih kecil. Salah satu keuntungan
menggunakan DFD adalah memudahkan pengguna yang kurang menguasai bidang
komputer untuk mengerti sistem yang akan dikerjakan. [8]
Pengertian DFD mencakup beberapa diagram, yaitu:
1. Diagram Konteks
Diagram konteks adalah diagram yang terdiri atas suatu proses dan
menggambarkan ruang lingkup suatu sistem. Diagram konteks merupakan level
tertinggi dari DFD yang menggambarkan seluruh input ke sistem atau output
dari sistem. Hanya ada satu proses dan tidak terdapat data store.
29
2. Diagram Nol (Overview Diagram)
Diagram nol adalah diagram yang menggambarkan proses dari DFD. Diagram
nol memberikan pandangan secara menyeluruh mengenai sistem yang ditangani,
menunujukkan tentang fungsi-fungsi utama atau proses yang ada, aliran data dan
entitas eksternal. Dalam level ini sudah dimungkinkan adanya data store yang
digunakan.
3. Diagram Rinci (Level Diagram)
Diagram rinci adalah diagram yang menguraikan proses apa yang ada dalam
diagram nol atau diagram level di atasnya. Penomoran level pada DFD dapat
dilihat pada tabel 2.6.
Tabel 2.6. Penomoran Level pada DFD
Nama Level Nama Diagram Nomor Proses
0 Context
1 Diagram 0 1.0, 2.0, 3.0, ...
2 Diagram 1.0 1.1, 1.2, 1.3, ...
3 Diagram 1.1 1.1.1, 1.1.2, ...
3 Diagram 1.2 1.2.1, 1.2.2, ...
dst
Aliran data yang masuk ke dalam dan keluar dari suatu proses harus sama
dengan aliran data yang masuk dan keluar dari rincian proses pada level / tingkatan
di bawahnya. Dalam DFD, aliran data, proses dan entitas eksternal digambarkan
dengan simbol-simbol. Simbol DFD yang sering digunakan adalah versi Yourdan
dan De Marco, diperlihatkan pada tabel 2.7.
Tabel 2.7. Simbol DFD Versi Yourdan dan De Marco
Simbol Nama Simbol Nama
1
Process
Proses
Arus Data
Entity
Entitas Eksternal Data Store
Data Store
Split
Merge
Data Flow
balok_3d
[balok_dan_label]
[jumlah_balok_berkas]
[jumlah_balok]
Pengguna
Konversi Berkas
Susun Tumpukan
1.3.1
Gambar
Balok
1.3.2
Gambar
Label Balok
30
BAB III
ANALISIS DAN PERANCANGAN
3.1. Analisis
Analisis pada rekayasa perangkat lunak adalah aktivitas yang menjembatani
jarak antara rekayasa sistem dan desain. Tahap analisis bertujuan mencapai tiga
tujuan utama, yaitu (1) menggambarkan kebutuhan pengguna, (2) mempersiapkan
dasar-dasar untuk proses perancangan perangkat lunak dan (3) mendefinisikan
kebutuhan-kebutuhan yang dapat divalidasi saat perangkat lunak telah dihasilkan.
3.1.1. Gambaran Umum Aplikasi
Aplikasi simulasi Dunia Balok yang telah dikembangkan adalah aplikasi yang
di dalamnya terdapat basis pengetahuan berupa Daftar PAD dan inference engine
menggunakan algoritma perencanaan STRIPS. Gambaran umum aplikasi dapat
dilihat pada gambar 3.1.
Gambar 3.1. Gambaran Umum Aplikasi Simulasi Dunia Balok
Untuk menjalankan aplikasi, dibutuhkan tiga masukan, yaitu jumlah balok,
initial state dan goal state. Jumlah balok digunakan untuk menggambar balok dan
tangan robot yang akan memperlihatkan tampilan simulasi. Berdasarkan masukan
initial state, goal state dan basis pengetahuan berupa Daftar PAD akan dicari solusi
yang mampu mengubah kondisi initial state menjadi goal state menggunakan
algoritma perencanaan STRIPS. Keluaran dari aplikasi berupa solusi yang dapat
diperlihatkan penyelesaiannya ke pengguna aplikasi melalui sebuah simulasi.
31
Daftar PAD adalah Daftar Precondition, Add dan Delete untuk operator dalam
dunia balok. Daftar PAD diperlihatkan tabel 3.1. 𝑋 dan 𝑌 adalah variabel untuk
balok-balok A, B, C, dan seterusnya.
Contoh masukan aplikasi yang berupa initial state dan goal state diperlihatkan
gambar 3.2. Initial state dan goal state terdiri atas empat buah balok A, B, C dan D.
Pada initial state, yang terletak pada permukaan meja adalah balok A, C dan D.
Balok B terletak di atas balok A.
Gambar 3.2. Contoh Masukan initial state dan goal state Dunia Balok
Pada goal state, yang terletak pada permukaan meja adalah balok A dan D.
Balok C terletak di atas balok A dan balok B terletak di atas balok D.
Diperlukan serangkaian solusi untuk mengubah kondisi initial state menjadi
goal state seperti diperlihatkan gambar 3.2. Dengan menggunakan algoritma
perencanaan STRIPS, maka akan diperoleh rencana penyelesaian seperti
diperlihatkan kode 3.1. Aplikasi simulasi Dunia Balok yang telah dikembangkan
dilengkapi dengan kemampuan untuk menangani kasus Sussman Anomaly.
1. UNSTACK(B,A)
2. STACK (B,D)
3. PICKUP(C)
4. STACK(C,A)
Kode 3.1. Contoh Sebuah Rencana Penyelesaian pada Dunia Balok
32
3.1.2. Analisis Kebutuhan Perangkat Lunak
Dalam proses analisis kebutuhan ini akan digambarkan kebutuhan aplikasi
dalam bentuk spesifikasi menggunakan SRS (Software Requirement Spesification).
Aplikasi simulasi dunia balok yang dikembangkan harus dapat memenuhi
persyaratan-persyaratan fungsional dan non-fungsional yang dijabarkan dalam SRS
pada tabel 3.1 dan tabel 3.2.
Tabel 3.1. SRS Fungsional
No SRS ID Deskripsi
1 SRS-F-01 Membuat simulasi baru
2 SRS-F-02 Membuka berkas simulasi
3 SRS-F-03 Menyimpan simulasi
4 SRS-F-04 Menggambar area simulasi dalam bentuk tiga dimensi
5 SRS-F-05 Menggambar dan menyusun tumpukan balok
6 SRS-F-06 Menggambar tangan robot
7 SRS-F-07 Menemukan solusi optimal
8 SRS-F-08 Menampilkan dan menganalisis hasil pencarian solusi
9 SRS-F-09 Mensimulasikan solusi yang ditemukan
Tabel 3.2. SRS Non Fungsional
No SRS ID Deskripsi
1 SRS-NF-01 Mengubah kecepatan simulasi
2 SRS-NF-02 Mengubah ukuran area simulasi
3 SRS-NF-03 Mengubah dan menyimpan pengaturan rendering
4 SRS-NF-04 Menampilkan bantuan penggunaan simulasi
3.1.3. Pemodelan Fungsional
Pemodelan fungsional diberikan dalam bentuk representasi grafis DCD dan
DFD yang melukiskan aliran informasi di dalam aplikasi dan hasil transformasi yang
dilakukan karena perpindahan data dari masukan menjadi keluaran.
33
3.1.3.1. Data Context Diagram (DCD)
Pendefinisian dengan DCD memberikan data yang mengalir antara aplikasi
dengan lingkungan yang digambarkan secara global. Aplikasi simulasi dunia balok
memiliki satu external entity yaitu pengguna. DCD dapat dilihat pada gambar 3.3.
tampilan_dunia_balok
berkas
simulasi_penyelesaian
solusi
goal_state
initial_state
jumlah_balok
Pengguna
1
Simulasi Dunia
Balok
+
Gambar 3.3. Data Context Diagram Simulasi Dunia Balok
Pada gambar 3.3 dijelaskan bahwa pengguna memasukkan berkas, jumlah
balok, initial state dan goal state kepada aplikasi. Berkas adalah file teks yang di
dalamnya terdapat notasi-notasi yang menyatakan kondisi susunan tumpukan balok.
Aplikasi memberikan output berupa tampilan dunia balok, solusi dan simulasi
penyelesaian kepada pengguna. Tampilan dunia balok memperlihatkan susunan
balok dan tangan robot untuk keperluan simulasi penyelesaian dari solusi yang
ditemukan.
3.1.3.2. Data Flow Diagram (DFD) Level 1
Dari Data Context Diagram yang diperlihatkan pada gambar 3.3, dapat dibuat
diagram alir data (DFD) yang merupakan penjelasan lebih rinci pada setiap tahapan.
Gambar 3.4 memperlihatkan DFD Level 1 dari aplikasi simulasi dunia balok yang
terdiri atas delapan proses, yaitu Buka Berkas, Konversi Berkas, Gambar Balok,
Susun Tumpukan, Temukan Solusi, Pangkas Solusi, Jalankan Simulasi dan Simpan
Simulasi.
34
Gambar 3.4. DFD Level 1 Simulasi Dunia Balok
Penjelasan rinci dari delapan proses pada DFD Level 1 Simulasi Dunia Balok
adalah sebagai berikut:
1. Buka Berkas
Proses ini digunakan untuk membaca berkas bertipe Text Document (*.txt).
Berkas berisi notasi-notasi yang menyatakan kondisi balok dan tangan robot.
2. Konversi Berkas
Memproses teks dari proses Buka Berkas dan menyimpannya ke dalam sebuah
array. Dari proses ini didapatkan jumlah balok, initial state dan goal state.
3. Gambar Balok
Berdasarkan jumlah balok, proses Gambar Balok akan membuat (rendering)
balok dan labelnya. Proses ini dijabarkan lebih lanjut pada DFD level 2.
goal_state_berkas
goal_state_berkas
goal_state_berkas
initial_state_berkas
initial_state_berkas
initial_state_berkas
[initial_state]
[goal_state]
[tampilan_dunia_balok]
goal_state
goal_state
initial_state
initial_state
Operator
Delete
Add
Precondition
[berkas]
[solusi_optimal]
[simulasi_penyelesaian]
[jumlah_balok]
berkas
berkas
balok_dan_label
jumlah_balok_berkas
isi_berkas
solusi_optimal
solusi_optimal
solusi
Pengguna
1.1
Buka Berkas
1.2
Konversi
Berkas
1.3
Gambar
Balok
+
1.6
Pangkas
Solusi
1.4
Susun
Tumpukan
+
1.5
Temukan
Solusi
+1.7
Jalankan
Simulasi
1.8
Simpan
Simulasi
Berkas Teks
Daftar PAD
35
4. Susun Tumpukan
Setelah balok digambar, proses Susun Tumpukan akan menyusun balok
berdasarkan posisinya pada array dan menempatkan tangan robot di atas
tumpukan tertinggi balok. Proses ini dijabarkan lebih lanjut pada DFD level 2.
5. Temukan Solusi
Proses untuk menemukan solusi yang mampu mengubah initial state menjadi
goal state dengan memanfaatkan basis pengetahuan pada daftar PAD. Aliran
data yang masuk ke daftar PAD adalah precondition, sedangkan data yang
keluar yaitu add, delete dan operator. Proses ini dijabarkan lebih lanjut pada
DFD level 2.
6. Pangkas Solusi
Dalam beberapa kasus, solusi yang diperoleh dari proses Temukan Solusi adalah
solusi yang belum efisien. Proses Pangkas Solusi akan menjadikan solusi
menjadi optimal menggunakan prosedur pruning (pemangkasan).
7. Jalankan Simulasi
Solusi yang berhasil ditemukan (dan sudah melalui proses pemangkasan),
selanjutnya akan disimulasikan dan ditampilkan penyelesaiannya ke pengguna.
Simulasi ini berupa pergerakan animasi tangan robot yang mengubah kondisi
initial state menjadi goal state.
8. Simpan Simulasi
Proses Simpan Simulasi akan menyimpan solusi ke dalam berkas bertipe Text
Document (*.txt).
3.1.3.3. DFD Level 2 Gambar Balok
Pada DFD level 2, Proses Gambar Balok dipecah menjadi beberapa subproses
yang memperlihatkan proses-proses yang berlangsung di dalamnya. Gambar 3.5
memperlihatkan DFD level 2 untuk Proses Gambar Balok.
36
Gambar 3.5. DFD Level 2 Gambar Balok
Pada level ini, terdapat dua subproses, yaitu Gambar Balok dan Gambar Label
Balok. Gambar Balok akan menggambar balok dalam tiga dimensi, mencakup
pewarnaan dan pencahayaan. Gambar Label Balok akan memberikan keterangan
pada tiap balok, sehingga dapat dibedakan antara balok satu dengan lainnya. Saat
awal mula digambar, posisi balok akan terletak pada tengah area simulasi.
3.1.3.4. DFD Level 2 Susun Tumpukan
DFD level 2 Susun Tumpukan memecah proses Susun Tumpukan ke dalam
lima subproses, yaitu Pisahkan Teks, Konversi State, Urutkan State, Ubah Posisi
Balok dan Ubah Posisi Tangan Robot. Gambar DFD level 2 Susun Tumpukan
diperlihatkan pada gambar 3.6.
Penjelasan rinci dari lima subproses pada DFD Level 2 Susun Tumpukan
adalah sebagai berikut:
1. Pisahkan Teks
Subproses Pisahkan Teks digunakan untuk memisahkan state balok ke dalam
predikat dan konstanta. Contoh, ONTABLE(A) akan dipisahkan ke dalam
ONTABLE dan A (balok A terletak di permukaan meja). Conton lain, ON(B,C)
akan dipisahkan menjadi ON, B dan C (balok B terletak diatas balok C)
balok_3d
[balok_dan_label]
[jumlah_balok_berkas]
[jumlah_balok]
Pengguna
Konversi Berkas
Susun Tumpukan
1.3.1
Gambar
Balok
1.3.2
Gambar
Label Balok
37
2. Konversi State
Subproses Konversi State akan mencari balok yang bersesuaian dengan
konstanta dari proses Pisahkan Teks. Pada array, indeks yang digunakan adalah
angka integer (dimulai dari 1, 2, 3, dst). Sedangkan pada notasi dunia balok,
konstanta adalah huruf (A, B, C, ... z).
3. Urutkan State
Untuk menyusun balok, hal yang pertama dilakukan adalah menentukan balok-
balok yang terletak di permukaan meja. Selanjutnya, balok-balok disusun
berdasarkan urutan yang sesuai.
Contoh, kondisi ONTABLE(A)^ON(C,B)^ON(B,A). Langkah pertama yang
dilakukan adalah menentukan posisi A. Balok C belum dapat disusun karena C
terletak pada B sedangkan posisi B belum terdefinisi. Sehingga kondisi tersebut
harus diurutkan terlebih dahulu menjadi ONTABLE(A)^ON(B,A)^ON(C,B).
Gambar 3.6. DFD Level 2 Susun Tumpukan
[goal_state_berkas]
[initial_state_berkas]
[tampilan_dunia_balok]
[goal_state]
[initial_state]
g oal_state_balok
initial_state_balok
g oal_state_terurut
initial_state_terurut
g oal_state_terkonversi
initial_state_terkonversi
initial_state_terpisah
g oal_state_terpisah
[balok_dan_label]
Gambar Balok
1.4.1
Pisahkan
Teks
1.4.2
Konversi
State
1.4.3
Urutkan State
1.4.4
Ubah Posisi
Balok
1.4.5
Ubah Posisi
Tang an R obot
Split Initial State
Split Goal State
Peng g una
Split Initial State Berkas
Split Goal State Berkas
38
4. Ubah Posisi Balok
Setelah kondisi dalam keadaan terurut, langkah selanjutnya mengubah balok-
balok yang tadinya berada di tengah area simulasi ke dalam susunan yang sesuai.
Tugas ini dilakukan oleh subproses Ubah Posisi Balok. Predikat ONTABLE akan
menempatkan balok di permukaan meja. Predikat ON akan menyusun balok di
atas balok yang lain.
5. Ubah Posisi Tangan Robot
Subproses ini digunakan untuk mengubah kondisi tangan robot. Apabila
ditemukan kondisi HOLDING(X) maka balok X akan ditempatkan pada tangan
robot. Selain itu, subproses Ubah Posisi Tangan Robot juga akan meletakkan
tangan robot pada posisi di atas puncak tertinggi tumpukan balok.
Setelah proses 1.4.1 sampai 1.4.5 selesai dikerjakan, selanjutnya akan
ditampilkan output tampilan dunia balok kepada pengguna.
3.1.3.5. DFD Level 2 Temukan Solusi
DFD level 2 Temukan Solusi memecah proses Temukan Solusi ke dalam
delapan subproses, yaitu Pisahkan State, Operasi Tumpukan, Ubah Nilai, Cek
Kesamaan State, Cek Precondition, Tambah State, Hapus State dan Terapkan
Operator. Gambar DFD level 2 Temukan Solusi diperlihatkan pada gambar 3.7.
Penjelasan rinci dari delapan subproses pada DFD Level 2 Temukan Solusi
adalah sebagai berikut:
1. Pisahkan State
Subproses Pisahkan State bertindak sebagai inisialisasi awal proses Temukan
Solusi. Pada subproses ini, initial state dipisahkan berdasarkan karakter ‘^’
2. Operasi Tumpukan
Subproses Operasi Tumpukan adalah operasi dasar pada struktur data Stack
(Tumpukan), yaitu Push dan Pop. Dari proses ini akan didapatkan current state
yang dimasukkan ke dalam sebuah Stack.
39
Gambar 3.7. DFD Level 2 Temukan Solusi
3. Ubah Nilai
Current state yang melalui subproses akan diubah nilainya. Contoh,
ONTABLE(A) akan didapatkan satu nilai, yaitu A. Untuk ON(B,A) akan
didapatkan dua nilai, yaitu B dan A.
4. Cek Kesamaan State
Subproses Cek Kesamaan State digunakan untuk mengecek apakah current state
sudah sesuai dengan goal state. Apabila bernilai „Ya‟ maka pemeriksaan akan
dihentikan, apabila masik bernilai „Tidak‟ maka akan dilakukan kembali
perulangan.
[goal_state_berkas]
[initial_state_berkas]
[initial_state]
[goal_state]
add_current_state
precondition_current_state
delete_current_state
operator_current_state
current_state_final
stack_current_state
initial_state_terpisah
current_state
current_state
current_state
current_state
current_state
[solusi]
[Precondition]
[Add]
[Delete]
[Operator]
Pangkas Solusi
Daftar PAD
1.5.1
Ubah Nilai
1.5.2
Terapkan
Operator
1.5.3
Cek Kesamaan
State
1.5.4
Cek
Precondition
1.5.5
Tambah
State
1.5.6
Hapus State
1.5.7
Pisahkan
State
1.5.8
Operasi
Tumpukan
Split Initial State
Split Goal State
Split Initial State Berkas
Split Goal State Berkas
40
5. Cek Precondition
Pengecekan kondisi current state dilakukan oleh subproses Cek Precondition
untuk menentukan operator yang akan diterapkan. Apabila kondisi terpenuhi,
maka dapat diaplikasikan operator dengan menerapkan add atau delete.
6. Tambah State
Subproses ini digunakan untuk menambahkan kondisi ke dalam current state.
Tambah State merupakan penggambaran dari keadaan yang ditambahkan (add)
pada Daftar PAD (tabel 2.3)
7. Hapus State
Subproses ini digunakan untuk menghapus kondisi dari current state. Hapus
State merupakan penggambaran dari keadaan yang dihapus (delete) pada Daftar
PAD (tabel 2.3)
8. Terapkan Operator
Subproses Terapkan Operator akan memilih satu dari empat pilihan daftar
operator yang dapat mengubah kondisi, yaitu STACK, UNSTACK, PICKUP dan
PUTDOWN.
3.2. Perancangan
Dalam tahap perancangan terdapat beberapa kegiatan yang dilakukan, yaitu
perancangan fungsi dan perancangan antarmuka.
3.2.1. Perancangan Fungsi
Perancangan fungsi adalah representasi dari kebutuhan fungsional aplikasi
yang dihasilkan pada tahap analisis untuk memudahkan dalam implementasi
program. Berdasarkan pemodelan fungsional yang telah dibuat, terdapat delapan
buah fungsi utama yang akan digunakan dalam aplikasi simulasi dunia balok ini,
yaitu: Buka Berkas, Konversi Berkas, Gambar Balok, Susun Tumpukan, Temukan
Solusi, Pangkas Solusi, Jalankan Simulasi dan Simpan Solusi.
41
3.2.1.1. Fungsi Buka Berkas
Nomor proses : 1.1
Deskripsi : Proses membaca berkas bertipe Text Document (*.txt)
Algoritma :
Initial State:
Lokasi berkas (directory) terdefinisi
Final State:
Isi berkas selesai dibaca
Algoritma:
IF berkas bertipe *.txt THEN
baca teks
3.2.1.2. Fungsi Konversi Berkas
Nomor proses : 1.2
Deskripsi : Memproses teks dari proses Buka Berkas dan menyimpannya ke
dalam sebuah array
Algoritma :
Initial State:
Teks dalam berkas terdefinisi
Final State:
Teks terkonversi ke dalam array
Algoritma:
FOR jumlah teks
Pisahkan berdasarkan karakter ‘^’
Simpan ke dalam array
3.2.1.3. Fungsi Gambar Balok
Nomor proses : 1.3
Deskripsi : Proses membuat (rendering) balok dan labelnya
Algoritma :
Initial State:
Jumlah balok
Final State:
Balok dan label tercetak pada layar
Algoritma:
FOR jumlah balok
Atur warna, posisi, dimensi
Gambar balok
Gambar label
42
3.2.1.4. Fungsi Susun Tumpukan
Nomor proses : 1.4
Deskripsi : Menyusun balok berdasarkan posisi pada array
Algoritma :
Initial State:
Balok terdefinisi
Final State:
Balok tersusun berdasarkan posisinya
Algoritma:
FOR jumlah balok
Susun balok pada meja
Susun tumpukan balok
Tempatkan tangan robot di atas puncak tertinggi
3.2.1.5. Fungsi Temukan Solusi
Nomor proses : 1.5
Deskripsi : Menemukan solusi yang mengubah initial state goal state
Algoritma :
Initial State:
Initial state dan goal state
Final State:
Solusi dari initial state menjadi goal state
Algoritma:
Proses menggunakan algoritma perencanaan STRIPS
Pada proses Temukan Solusi, diperlukan masukan berupa Initial State dan
Goal State. Selanjutnya masukan tersebut diproses menggunakan Algoritma
Perencanaan STRIPS. Dari Initial State akan didapatkan Current State. Kondisi
Goal State yang belum tercapai akan dimasukkan ke dalam Stack. Algoritma
Perencanaan STRIPS akan memeriksa kondisi teratas (Top) pada Stack. Langkah
yang akan diambil tergantung apakah kondisi teratas tersebut berupa Goal
Tunggal, Goal Majemuk atau suatu Operator. Pemeriksaan ini akan terus
dilakukan sampai Stack telah kosong atau ketika kondisi Goal State telah
tercapai. Flowchart untuk Algoritma Perencanaan STRIPS pada proses
Temukan Solusi telah ditunjukkan pada gambar 2.8.
43
3.2.1.6. Fungsi Pangkas Solusi
Nomor proses : 1.6
Deskripsi : Proses menjadikan solusi menjadi lebih efisien
Algoritma :
Initial State:
Solusi terdefinisi
Final State:
Solusi optimal tercapai
Algoritma:
FOR banyak solusi
Hapus langkah yang tidak mengubah kondisi
Solusi optimal
Keluaran dari fungsi Temukan Solusi menjadi masukan fungsi Pangkas
Solusi. Flowchart pada proses Pangkas Solusi dapat dilihat pada gambar 3.8.
Gambar 3.8. Algoritma Proses Pangkas Solusi
Mulai
str1 = operator STACK
str1 = solusi ke-i
T
YY
str2 = operator UNSTACK
i = 1
i = jumlah solusi ?Selesai
str1 = operator PICKUP
str2 = operator PUTDOWN
j = i + 1
cek = false
(cek = false) & (j<jumlah solusi)
solusi ke-j = str2 ?
cek = true
j = j + 1
i = i + 1
hapus str1 dan str2 pada solusi
Y
T
T
T
T
Y
Y
baca Solusi
44
3.2.1.7. Fungsi Simpan Solusi
Nomor proses : 1.8
Deskripsi : Menyimpan solusi menjadi berkas bertipe Text Document (*.txt)
Algoritma :
Initial State:
Solusi terdefinisi
Final State:
Solusi tersimpan ke dalam berkas
Algoritma:
FOR jumlah solusi
Tulis teks
berkas berisi solusi
3.2.1.8. Fungsi Jalankan Simulasi
Nomor proses : 1.7
Deskripsi : Mensimulasikan pergerakan tangan robot yang mengubah
kondisi initial state menjadi goal state
Algoritma :
Initial State:
Initial state, Goal state, Jumlah balok, Tangan
robot dan Solusi terdefinisi
Final State:
Pergerakan animasi Tangan robot dalam mengubah
kondisi balok pada initial state menjadi goal state
Algoritma:
FOR jumlah solusi
Jalankan simulasi
Solusi yang berhasil ditemukan akan disimulasikan oleh proses Jalankan
Simulasi. Simulasi ini diperlihatkan ke pengguna dalam bentuk rangkaian
animasi pergerakan tangan robot dalam menata tumpukan-tumpukan balok.
Rangkaian pergerakan simulasi diperlihatkan pada gambar 3.9.
Variabel Kanan menggerakkan tangan robot pada sumbu 𝑥. Pergerakan
akan terhenti ketika tangan robot telah mencapai koordinat balok yang dituju.
Variabel Kiri menggerakkan tangan robot searah sumbu 𝑧. Variabel Atas dan
Bawah menggerakkan tangan robot searah sumbu 𝑦, dengan Atas menjauhi
koordinat 𝑦 = 0 dan Bawah mengarah ke koordinat 𝑦 = 0.
45
Gambar 3.9. Algoritma Proses Jalankan Simulasi
Mulai
SelesaiY
baca Solusi
Kontrol = Jumlah Solusi
Operator = ‘PICKUP’ atau
Operator =’UNSTACK’
T
Ketemu
Balok ?
Y T
Operator =
‘PUTDOWN’
T
Y
Y
cari lokasi
Balok Alas
T
bergerak pada
sumbu-X
Ketemu
lokasi ?
T
Y
Kanan, Kiri, Atas, Bawah = true
Kanan = false
Kanan = false
Kontrol = 1
bergerak pada
sumbu-X
Kanan = trueT
Kiri = trueKetemu
Balok ?
Y
Kiri = false
bergerak pada
sumbu-Z
T
Y
Y
Bawah = trueKetemu
Balok ?
Y
Bawah = false
bergerak pada
sumbu-Y
T
Y
T
Ambil Balok
T
Atas = trueKetemu
Puncak ?
Y
Atas = false
bergerak pada
sumbu-Y
T
Y
T
Kanan = true
Y
bergerak pada
sumbu-Z
Ketemu
lokasi ?
T
Y
Kiri = false
Kiri = true
Y
Tbergerak pada
sumbu-Y
Ketemu
lokasi ?
T
Y
Bawah = false
Bawah = true
Y
T
T
Taruh Balok
Atas = true
Ketemu
Puncak ?
bergerak pada
sumbu-Y
Atas = false
Y
T
T
Y
Kontrol = Kontrol + 1Kanan, Kiri,
Bawah, Atas = true
46
3.2.2. Perancangan Antarmuka
Antarmuka merupakan media komunikasi pengguna saat berinteraksi dengan
aplikasi. Perancangan antarmuka pada dasarnya adalah proses penggambaran
bagaimana sebuah bagian aplikasi dibentuk. Perancangan antarmuka pengguna
merupakan suatu proses yang kompleks, hal ini didasari karena antarmuka pengguna
merupakan bagian dari aplikasi yang akan dikendalikan oleh pengguna dan
merupakan tahap persiapan untuk rancang bangun implementasi.
Perancangan antarmuka untuk aplikasi simulasi dunia balok ditunjukkan pada
gambar 3.10. Rancangan antarmuka aplikasi terbagi menjadi enam bagian, yaitu:
rancangan menu, rancangan input, rancangan rendering, rancangan analisis hasil,
rancangan simulasi dan rancangan output. Dalam proses interaksi antara pengguna
dengan aplikasi dibutuhkan piranti masukan berupa keyboard dan mouse serta piranti
keluaran berupa monitor.
Gambar 3.10. Rancangan Antarmuka Simulasi Dunia Balok
47
3.2.2.1. Rancangan Menu
Ada beberapa menu yang ada dalam aplikasi simulasi dunia balok. Menu
utama terdiri atas tiga bagian, yaitu: Simulasi, Pengaturan dan Bantuan. Pada menu
Simulasi terdapat submenu Buat baru, Buka simulasi, Simpan simulasi dan Keluar.
Pada menu Pengaturan terdapat submenu Rendering dan Tumpukan. Submenu
Tumpukan ini masih memiliki dua submenu lagi, yaitu: Kondisi awal dan Kondisi
Akhir. Pada menu bantuan hanya memiliki dua submenu, yaitu: Topik bantuan dan
Tentang simulasi. Struktur menu aplikasi simulasi dunia balok dapat dilihat pada
gambar 3.11.
Gambar 3.11. Rancangan Menu Simulasi Dunia Balok
Simulasi
Buat baru
Buka Simulasi
Simpan Simulasi
Keluar
Pengaturan
Rendering
Tumpukan
Kondisi Awal
Kondisi Akhir
Bantuan
Topik Bantuan
Tentang Simulasi
Simulasi Dunia Balok
48
3.2.2.2. Rancangan Input
Rancangan Input merupakan masukan dari pengguna agar aplikasi simulasi
dunia balok dapat berjalan. Rancangan Input diperlihatkan gambar 3.12. Pada bagian
ini terdapat dua kotak isian (text field), satu tombol pilihan (radio button), dan lima
tombol perintah (bit button).
1. Kotak isian Jumlah balok
Digunakan sebagai masukan jumlah balok yang dibutuhkan oleh aplikasi untuk
menggambar balok dan labelnya (fungsi Gambar Balok, nomor proses 1.3)
2. Tombol pilihan Pilih state
Digunakan untuk memilih kondisi balok yang akan dimasukkan ke aplikasi.
3. Kotak isian Kondisi tumpukan
Digunakan untuk memasukkan kondisi balok. Pengguna dapat mengetik
langsung di sini ataupun memanfaatkan tombol Buka berkas.
4. Tombol perintah Buka berkas
Digunakan untuk membaca berkas bertipe Text Document (fungsi Buka Berkas,
nomor proses 1.1)
5. Tombol perintah Ubah
Digunakan untuk mengubah kotak isian Kondisi tumpukan.
6. Tombol perintah Bersihkan
Digunakan untuk membersihkan kotak isian Kondisi tumpukan.
7. Tombol perintah Proses
Digunakan untuk mengubah teks pada kotak isian Kondisi tumpukan menjadi
array (fungsi Konversi Berkas, nomor proses 1.2) kemudian menata balok
berdasarkan array tersebut (fungsi Susun Tumpukan, nomor proses 1.4)
8. Tombol perintah Temukan solusi
Digunakan untuk menemukan solusi yang mengubah initial state menjadi goal
state (fungsi Temukan Solusi, nomor proses 1.5)
Gambar 3.12. Rancangan Input
49
3.2.2.3. Rancangan Rendering
Rancangan Rendering merupakan bagian dari aplikasi yang menampilkan
informasi frame per second (FPS). FPS adalah jumlah gambar bergerak yang tersaji
di monitor dalam satu detik. Rancangan rendering diperlihatkan gambar 3.13.
Gambar 3.13. Rancangan Rendering
3.2.2.4. Rancangan Analisis Hasil
Hasil perhitungan yang diperoleh dari proses Temukan solusi ditampilkan pada
bagian rancangan Analisis Hasil. Rancangan analisis hasil diperlihatkan gambar
3.14. Poin-poin yang dihitung yaitu:
1. Lama pencarian solusi
Adalah waktu yang dibutuhkan prosesor untuk menemukan solusi.
2. Jumlah langkah
Adalah jumlah solusi yang mengubah initial state menjadi goal state sebelum
dilakukan proses Pangkas solusi.
3. Jumlah perulangan
Adalah jumlah perulangan yang dibutuhkan proses Temukan solusi.
4. Solusi setelah pruning
Adalah jumlah langkah solusi optimal setelah dilakukan proses Pangkas solusi
(nomor proses 1.6)
Gambar 3.14. Rancangan Analisis Hasil
50
3.2.2.5. Rancangan Simulasi
Rancangan Simulasi merupakan bagian dari aplikasi yang memungkinkan
pengguna melakukan proses Jalankan simulasi (nomor proses 1.7). Terdapat dua
tombol perintah untuk memulai dan menghentikan simulasi serta satu track bar
untuk mengubah kecepatan animasi. Rancangan simulasi diperlihatkan gambar 3.15.
Gambar 3.15. Rancangan Simulasi
3.2.2.6. Rancangan Output
Rancangan Output merupakan keluaran dari aplikasi. Pada bagian ini pengguna
dapat melihat solusi yang dihasilkan dan jalannya proses pencapaian dari goal state
menuju initial state. Solusi yang ditampilkan pada sebuah listbox dapat disimpan
melalui menu Simpan simulasi (nomor proses 1.8). Area simulasi memperlihatkan
permukaan meja, tumpukan balok dan tangan robot dalam pandangan tiga dimensi.
Rancangan output diperlihatkan gambar 3.16.
Gambar 3.16. Rancangan Output
51
3.2.3. Perancangan Area Simulasi
Rancangan Area Simulasi merupakan bagian dari aplikasi yang memungkinkan
pengguna untuk melihat dunia balok dalam pandangan tiga dimensi. Dalam dunia
balok terdapat tiga komponen utama, yaitu: permukaan meja, tumpukan balok dan
tangan robot. Selebihnya adalah komponen yang mendukung pembuatan dunia balok
tampak semakin realistis. Komponen pendukung ini terdiri atas pewarnaan,
pencahayaan, transformasi untuk memperoleh arah pandangan kamera, dan
penempatan posisi dengan memperhitungkan koordinat dalam tiga sumbu kartesian
(𝑠𝑢𝑚𝑏𝑢 𝑥, 𝑦, 𝑧). Rancangan Area Simulasi diperlihatkan gambar 3.17.
Gambar 3.17. Rancangan Area Simulasi
Tiga transformasi geometri yang dikenakan pada area simulasi ini adalah
translasi, rotasi dan penskalaan.
1. Translasi
Digunakan untuk memindahkan kamera dalam arah 𝑠𝑢𝑚𝑏𝑢 𝑥 dan 𝑦, sehingga
dapat diperoleh pandangan dunia balok dari berbagai sisi.
2. Rotasi
Digunakan untuk memutar kamera, sehingga target kamera selalu mengarah
pada koordinat (0,0,0).
3. Penskalaan
Digunakan untuk menimbulkan efek jauh-dekat pada area simulasi. Efek ini
bekerja pada 𝑠𝑢𝑚𝑏𝑢 𝑧 yang merupakan representasi kedalaman pada OpenGL.
52
3.2.3.1. Rancangan Meja
Definisi permukaan meja pada dunia balok adalah tempat meletakkan balok
beserta susunan tumpukannya. Permukaan meja yang dibuat pada aplikasi simulasi
dunia balok ini adalah sebuah bangun datar segi empat dengan efek pemberian
tekstur. Tekstur yang digunakan berupa gambar lantai bertipe jpg berukuran
256x256 pixel. Gambar ini diperoleh dari direktori Demos pada instalasi GLScene.
Tekstur diperlihatkan gambar 3.18.
Gambar 3.18. Tekstur Marbletiles untuk Permukaan Meja Dunia Balok
3.2.3.2. Rancangan Balok
Balok adalah bangun ruang tiga dimensi yang dibentuk oleh tiga pasang
persegi atau persegi panjang dengan minimal satu pasang di antaranya berukuran
berbeda. Balok yang dibentuk oleh enam persegi sama dan sebangun disebut sebagai
kubus. Dalam simulasi dunia balok ini, rancangan kubus yang telah dibuat memiliki
panjang, tinggi dan kedalaman yang sama.
Rancangan balok diperlihatkan gambar 3.19.
Gambar 3.19. Rancangan Balok dan Label
53
Untuk membedakan antara balok satu dengan lainnya, diberikan sebuah label
dan pewarnaan yang berbeda. Label berupa satu karakter ASCII (American Standard
Code for Information Interchange) diawali dari karakter A (huruf latin A kapital
dengan nilai desimal 65) sampai karakter Z (nilai desimal 90) dan dari karakter a
(nilai desimal 97) sampai karakter z (huruf latin z kecil, nilai desimal 122). Sehingga
total maksimal balok dalam simulasi yang dibuat berjumlah 52 buah.
Tabel karakter ASCII yang digunakan dalam pemberian label balok dapat
dilihat pada lampiran 2.
Warna yang digunakan oleh setiap balok diperoleh secara acak (random),
sehingga tidak akan didapatkan warna yang sama antara satu balok dengan lainnya.
Pada OpenGL, warna merupakan gabungan dari nilai-nilai Red, Green dan Blue
dengan rentang nilai antara 0 sampai 1. Untuk mendapatkan warna yang banyak dan
bervariasi, tiap nilai yang diperoleh secara acak dibagi dengan 1000. Warna akhir
diperoleh dari penjumlahan nilai acak dari masing-masing nilai R, G dan B. Rumus
untuk mendapatkan warna diperlihatkan pada persamaan 3.1.
𝑊 =𝑅𝑎𝑛𝑑𝑜𝑚 (𝑅)
1000+
𝑅𝑎𝑛𝑑𝑜𝑚 (𝐺)
1000+
𝑅𝑎𝑛𝑑𝑜𝑚 (𝐵)
1000 .................................................... (3.1)
3.2.3.3. Rancangan Tangan Robot
Definisi tangan robot pada dunia balok adalah sebuah komponen yang mampu
mengangkat, memindahkan dan menyusun balok ke dalam sebuah tumpukan. Pada
simulasi dunia balok ini, rancangan tangan robot disusun dari tiga bangun ruang,
yaitu: bola, silinder dan balok.
Rancangan tangan robot diperlihatkan gambar 3.20. Bangun bola (nomor 1)
dapat dianalogikan sebagai sebuah siku, bertugas mencari posisi balok yang akan
dipindahkan. Bola ini posisinya selalu konstan pada 𝑠𝑢𝑚𝑏𝑢 𝑦. Pergerakan bola pada
𝑠𝑢𝑚𝑏𝑢 𝑥 dan 𝑧.
54
Gambar 3.20. Rancangan Tangan Robot
Pada gambar 3.21 memperlihatkan rancangan silinder lengan robot. Bangun
silinder (nomor 2) dapat dianalogikan sebagai sebuah lengan. Lengan akan
memanjang ketika mengambil balok yang disimbolkan p2 pada gambar 3.21(b) dan
akan memendek ketika dalam keadaan kosong atau dalam posisi memindahkan balok
yang disimbolkan p1 pada gambar 3.21(a). Pertambahan nilai panjang silinder
didapatkan dari posisi bola pada 𝑠𝑢𝑚𝑏𝑢 𝑦 dikurangi posisi balok (bangun nomor 3)
pada 𝑠𝑢𝑚𝑏𝑢 𝑦.
(a) Panjang Silinder saat Idle
(b) Panjang Silinder saat Mendapatkan Balok
Gambar 3.21. Rancangan Silinder Lengan Robot
55
BAB IV
IMPLEMENTASI DAN PENGUJIAN
4.1. Implementasi
Tahap implementasi merupakan penerapan dari analisis dan perancangan
aplikasi yang telah dibuat menjadi bentuk yang lebih nyata meliputi implementasi
rancangan fungsi, dan implementasi rancangan antarmuka.
Spesifikasi perangkat keras yang digunakan dalam proses pengembangan
aplikasi simulasi dunia balok menggunakan algoritma perencanaan STRIPS adalah
sebagai berikut:
a. Netbook AMD® C60 APU up to 1.333 GHz
b. RAM DDR3 (memori 2 GB)
c. Kartu Grafis Radeon® HD 6290 (memori 256 MB)
Spesifikasi perangkat lunak yang digunakan dalam pengembangan aplikasi
adalah sebagai berikut:
a. Sistem Operasi Windows® 7 Professional Service Pack 1
b. Embarcadero®
Delphi®
2010
c. OpenGL versi 6.14
d. GLScene versi 1.1 rilis Maret 2011
4.1.1. Implementasi Fungsi
Berdasarkan perancangan fungsi yang telah dibuat, terdapat delapan buah
implementasi fungsi yang digunakan dalam aplikasi simulasi dunia balok ini, yaitu:
Buka Berkas, Konversi Berkas, Gambar Balok, Susun Tumpukan, Temukan Solusi,
Pangkas Solusi, Jalankan Simulasi dan Simpan Solusi.
56
4.1.1.1. Fungsi Buka Berkas
Fungsi Buka Berkas adalah fungsi untuk membaca berkas bertipe Text
Document (*.txt). Berkas ini berisi kondisi susunan balok dan tangan robot. Fungsi
Buka Berkas memakai fungsi bawaan Delphi, yaitu OpenDialog. OpenDialog akan
membuka berkas dengan FileName yang diisikan pengguna kemudian
menyimpannya ke dalam kotak isian Kondisi Tumpukan (mmInitial atau mmGoal,
berdasarkan Pilih State yang dipilih pengguna). Implementasi fungsi Buka Berkas
dapat dilihat pada kode 4.1.
if OpenDialog.Execute then
if rbInitial.Checked then
mmInitial.Lines.LoadFromFile(OpenDialog.FileName)
else if rbGoal.Checked then
mmGoal.Lines.LoadFromFile(OpenDialog.FileName);
Kode 4.1. Implementasi Fungsi Buka Berkas
4.1.1.2. Fungsi Konversi Berkas
Fungsi Konversi Berkas adalah fungsi yang memproses teks dari kotak isian
Kondisi Tumpukan dan menyimpan hasilnya ke dalam sebuah array. Fungsi
Konversi Berkas memanfaatkan fungsi bawaan Delphi, yaitu StringReplace.
StringReplace memisahkan teks berdasarkan karakter „^‟ (pada tabel ASCII bernilai
#94). Array hasil proses ini berisi kondisi-kondisi balok dan tangan robot, yaitu
ONTABLE(x), ON(x,y) dan HOLDING(x) dengan x,y adalah karakter label balok.
Implementasi fungsi Konversi Berkas dapat dilihat pada kode 4.2.
temp.Text := StringReplace(state, #94, #13#10, [rfReplaceAll]);
j := 0;
setlength(larik, 1);
for i := 0 to temp.Count-1 do
if (pos('ON', temp[i])<>0) or (pos('HOLDING', temp[i])<>0)
then
begin
larik[j] := temp[i];
inc(j);
setlength(larik, length(larik)+1);
end;
setlength(larik, length(larik)-1);
Kode 4.2. Implementasi Fungsi Konversi Berkas
57
4.1.1.3. Fungsi Gambar Balok
Fungsi Gambar Balok adalah fungsi yang memproses pembuatan (rendering)
balok dan labelnya. Balok dibuat dari fungsi TGLCube pada GLScene dan label
dibuat dari TGLSpaceText. Pemberian warna RGB pada balok diperoleh dari fungsi
random(1000)/1000. Implementasi fungsi Gambar Balok dapat dilihat pada kode 4.3.
for i := low(kotak3D) to high(kotak3D) do
begin
kotak3D[i] := TGLCube.Create(dcTumpukanBalok);
kotak3D[i].Parent := dcTumpukanBalok;
r := random(1000)/1000;
g := random(1000)/1000;
b := random(1000)/1000;
kotak3D[i].Material.FrontProperties.Emission.Alpha := 1;
kotak3D[i].Material.FrontProperties.Emission.Red := r;
kotak3D[i].Material.FrontProperties.Emission.Green := g;
kotak3D[i].Material.FrontProperties.Emission.Blue := b;
kotak3D[i].Parts := [cpTop,cpBottom,cpFront,cpBack,cpLeft,cpRight];
lbKotak3D[i] := TGLSpaceText(Kotak3D[i].AddNewChild(TGLSpaceText));
lbKotak3D[i].Material.FrontProperties.Emission.Color := clrBlack;
if i<26 then temp := chr(i+65) else temp := chr(i+71);
lbKotak3D[i].Text := temp
end;
Kode 4.3. Implementasi Fungsi Gambar Balok
Label pada balok diperoleh dari fungsi bawaan Delphi, yaitu chr(x), dengan x
adalah nilai integer. Chr(i+65) untuk mendapatkan karakter „A‟ – „Z‟ (kapital) dan
chr(i+71) untuk karakter „a‟ – „z‟ (huruf kecil). Pengaturan Emission.Color dengan
nilai clrBlack memberikan warna hitam pada label.
4.1.1.4. Fungsi Susun Tumpukan
Fungsi Susun Tumpukan adalah fungsi untuk menyusun tumpukan balok dan
tangan robot. Penyusunan dilakukan dengan mengubah posisi balok pada sumbu x, y,
dan z. Implementasi fungsi Susun Tumpukan dapat dilihat pada kode 4.4.
Kode 4.4. Implementasi Fungsi Susun Tumpukan
for i := low(kondisi) to high(kondisi) do
begin
str := kondisi[i];
j := pos('(', str);
v1 := str[j+1];
if ord(v1)<91 then k := ord(v1)-65 else k := ord(v1)-71;
if v1<>v then
if copy(str, 1, j-1)='HOLDING' then
holding := k
else
if copy(str, 1, j)='ONTABLE(' then
begin
...
58
...
kotak3D[k].Position.X := x;
kotak3D[k].Position.Y := -0.5;
kotak3D[k].Position.Z := z;
if rbGoal.Checked then
begin
ontable := pos(v1, otStrInit);
if ontable<>0 then
begin
kotak3D[k].Position.X := -otVektorInit[ontable-1].x;
kotak3D[k].Position.Z := otVektorInit[ontable-1].z
end;
otStr := otStr + v1;
setLength(otVektor, length(otVektor)+1);
j := length(otVektor)-1;
otVektor[j].x := kotak3D[k].Position.X;
otVektor[j].y := kotak3D[k].Position.Y;
otVektor[j].z := kotak3D[k].Position.Z
end
else
begin
otStrInit := otStrInit + v1;
setLength(otVektorInit, length(otVektorInit)+1);
j := length(otVektorInit)-1;
otVektorInit[j].x := kotak3D[k].Position.X;
otVektorInit[j].y := kotak3D[k].Position.Y;
otVektorInit[j].z := kotak3D[k].Position.Z
end;
inc(x);
if x=4 then
begin
x := 1;
inc(z)
end
end
else
begin
v2 := str[j+3];
if ord(v2)<91 then l := ord(v2)-65 else l := ord(v2)-71;
kotak3D[k].Position.X := kotak3D[l].Position.X;
kotak3D[k].Position.Y := kotak3D[l].Position.Y + 1;
kotak3D[k].Position.Z := kotak3D[l].Position.Z;
if kotak3D[k].Position.Y > puncak then puncak := kotak3D[k].Position.Y;
end;
end;
puncak := puncak + kotak3D[k].CubeHeight;
dcLengan.Position.Y := puncak; if holding<>-1 then
begin
dcLengan.Position.Y := dcLengan.Position.Y + 0.11;
kotak3D[holding].Position.X := dcLengan.Position.X;
kotak3D[holding].Position.Y := dcLengan.Position.Y + 0.49;
kotak3D[holding].Position.Z := dcLengan.Position.Z
end;
dcSiku.Position.Y := dcLengan.Position.Y + 2;
cylinderLengan.Height := dcSiku.Position.Y - dcLengan.Position.Y;
cylinderLengan.Position.Y := -(cylinderLengan.Height / 2)
Baris kode dcLengan.Position.Y := puncak untuk memastikan posisi
tangan robot selalu di atas puncak tertinggi susunan balok. Baris kode if
holding<>-1 then digunakan untuk memeriksa kondisi tangan robot, yaitu dalam
keadaan kosong atau memegang sebuah balok.
59
4.1.1.5. Fungsi Temukan Solusi
Fungsi Temukan Solusi merupakan fungsi untuk menemukan solusi yang
mengubah initial state menjadi goal state. Fungsi Temukan Solusi yang
menggunakan algoritma perencanaan STRIPS diimplementasikan ke dalam bentuk
baris kode dapat dilihat pada kode 4.5.
Kode 4.5. Implementasi Fungsi Temukan Solusi
while ((isEqual(goal, current)<>true) and (gsp.atas>0)) do
begin
if gsp.atas=1 then
begin
if isEqual(goal, current)<>true then inputGSP(goal, current, gsp);
end
else if ((not inArray(gsp.isi[gsp.atas], current)) and ((pos('^',
gsp.isi[gsp.atas])=0))) then
begin
popped := pop(gsp);
if pos('HOLDING(', popped)<>0 then
begin
key := pos(')', popped);
if not inArray('ONTABLE('+popped[key-1]+')', current) then popped :=
'CLEAR('+popped[key-1]+')';
end;
ubahNilai(popped, 'Kondisi 2', current, pad, idk, operators,
precondition);
if idk=0 then armempty(current, goal, gsp, pad, operators,
precondition);
push(gsp, operators);
push(gsp, precondition);
pisah(precondition, temp);
for j := low(temp) to high(temp) do push(gsp, temp[j]);
end
else if (pos('^', gsp.isi[gsp.atas])<>0) then
begin
// Cek Precondition apakah terpenuhi
ubahNilai(gsp.isi[gsp.atas-1], 'Kondisi 3', current, pad, idk, add,
delete);
ubahNilai(add, 'Kondisi 2', current, pad, idk, operators,
precondition);
key := 0;
pisah(precondition, temp);
for j := low(temp) to high(temp) do if inArray(temp[j], current) then
inc(key) else popped := temp[j];
// end of Cek Precondition apakah terpenuhi
if key<>length(temp) then
begin
if pos('HOLDING', popped)<>0 then
begin
v1 := cariNilai('HOLDING(', 9, current);
push(solusi, 'PUTDOWN('+v1+')');
ubahNilai('PUTDOWN('+v1+')', 'Kondisi 3', current, pad, idk, add,
delete);
pisah(add, temp);
tambah(current, temp);
pisah(delete, temp);
hapus(current, temp);
v1 := cariNilai('ON('+popped[9], 6, current);
push(solusi, 'UNSTACK('+popped[9]+','+v1+')');
ubahNilai('UNSTACK('+popped[9]+','+v1+')', 'Kondisi 3', current,
pad, idk, add, delete);
pisah(add, temp);
tambah(current, temp);
pisah(delete, temp);
hapus(current, temp);
end
...
60
...
else
begin
if pos('UNSTACK', operators)<>0 then key := 9 else key := 8;
v1 := cariNilai(','+operators[key], 4, current);
popped := 'UNSTACK('+v1+','+operators[key]+')';
push(solusi, popped);
ubahNilai(popped, 'Kondisi 3', current, pad, idk, add, delete);
pisah(add, temp);
tambah(current, temp);
pisah(delete, temp);
hapus(current, temp);
popped := 'PUTDOWN('+v1+')';
push(solusi, popped);
ubahNilai(popped, 'Kondisi 3', current, pad, idk, add, delete);
pisah(add, temp);
tambah(current, temp);
pisah(delete, temp);
hapus(current, temp);
end;
end;
popped := pop(gsp);
popped := pop(gsp);
push(solusi, popped);
ubahNilai(popped, 'Kondisi 3', current, pad, idk, add, delete);
pisah(add, temp);
tambah(current, temp);
pisah(delete, temp);
hapus(current, temp);
end
else popped := pop(gsp);
inc(perulangan);
end;
pangkas(solusi);
Kode pangkas(solusi) pada akhir baris digunakan untuk memanggil fungsi
Pangkas Solusi yang akan mengubah langkah solusi menjadi lebih efisien.
4.1.1.6. Fungsi Pangkas Solusi
Fungsi Pangkas Solusi memproses solusi yang dihasilkan dari Temukan Solusi
menjadi lebih optimal, dengan menghilangkan pasangan-pasangan solusi yang tidak
mengubah kondisi. Implementasi fungsi Pangkas Solusi dapat dilihat pada kode 4.6.
Kode 4.6. Implementasi Fungsi Pangkas Solusi
i := 0;
while i<=gsp.atas-1 do
begin
inc(i);
str1 := gsp.isi[i];
if (pos('UNSTACK', str1)=0) and (pos('STACK', str1)<>0) or (pos('PICKUP',
str1)<>0) then
begin
if pos('STACK', str1)<>0 then
begin
v1 := str1[7];
v2 := str1[9];
str2 := 'UNSTACK('+v1+','+v2+')';
end
else
begin
...
61
...
v1 := str1[8];
str2 := 'PUTDOWN('+v1+')';
end;
j := i+1;
cek := false;
while (j<=gsp.atas) and (cek<>true) do if gsp.isi[j]=str2 then cek :=
true else inc(j);
if cek=true then
begin
for k := i to gsp.atas-1 do gsp.isi[k] := gsp.isi[k+1];
gsp.atas := gsp.atas - 1;
dec(i);
for k := j-1 to gsp.atas-1 do gsp.isi[k] := gsp.isi[k+1];
gsp.atas := gsp.atas - 1;
dec(i);
end
end
end;
4.1.1.7. Fungsi Simpan Solusi
Fungsi Simpan Solusi adalah fungsi untuk menyimpan solusi menjadi berkas
bertipe Text Document (*.txt). Nama berkas tersimpan yaitu „Simulasi Dunia balok
{tanggal}.txt‟. Fungsi Simpan Solusi menggunakan fungsi bawaan Delphi, yaitu
SaveToFile. Implementasi fungsi Simpan Solusi dapat dilihat pada kode 4.7.
Kode 4.7. Implementasi Fungsi Simpan Solusi
temp.Add('[balok]:'+edJumlah.Text);
str := '[initial]:';
for i := 0 to mmInitial.Lines.Count-1 do str := str +
copy(mmInitial.Lines[i], 1, length(mmInitial.Lines[i]));
temp.Add(str);
str := '[goal]:';
for i := 0 to mmGoal.Lines.Count-1 do str := str + copy(mmGoal.Lines[i], 1,
length(mmGoal.Lines[i]));
temp.Add(str);
temp.Add('[solusi]:');
temp.AddStrings(mmSolusi.Lines);
str := datetimetostr(now);
str := stringreplace(str, '/', '-', [rfReplaceAll]);
str := stringreplace(str, ':', '-', [rfReplaceAll]);
str := 'Simulasi Dunia Balok (' + str + ').txt';
temp.SaveToFile(str);
4.1.1.8. Fungsi Jalankan Simulasi
Fungsi Jalankan Simulasi adalah fungsi untuk mensimulasikan pergerakan
tangan robot yang mengubah kondisi initial state menjadi goal state. Implementasi
fungsi Jalankan Simulasi dalam bentuk baris kode dapat dilihat pada kode 4.8.
62
Kode 4.8. Implementasi Fungsi Jalankan Simulasi
if (str='PICKUP') or (str='UNSTACK') then
begin
if Kanan then //Pergerakan lengan di sumbu-X
begin
if dcLengan.Position.X > kotak3D[k].Position.X then
dcLengan.Position.X := dcLengan.Position.X - 0.5
else if dcLengan.Position.X < kotak3D[k].Position.X then
dcLengan.Position.X := dcLengan.Position.X + 0.5;
Kanan := false;
dcSiku.Position.X := dcLengan.Position.X
end
else if Kiri then //Pergerakan lengan di sumbu-Z
begin
if dcLengan.Position.Z > kotak3D[k].Position.Z then
dcLengan.Position.Z := dcLengan.Position.Z - 0.5
else if dcLengan.Position.Z < kotak3D[k].Position.Z then
dcLengan.Position.Z := dcLengan.Position.Z + 0.5;
Kiri := false;
dcSiku.Position.Z := dcLengan.Position.Z
end
else if Bawah then //Pergerakan lengan di sumbu-Y ke bawah
begin
if round(dcLengan.Position.Y)>=kotak3D[k].Position.Y then
dcLengan.Position.Y := dcLengan.Position.Y - 0.5
else
begin
dcLengan.Position.Y := kotak3D[k].Position.Y - 0.49;
Bawah := false
end;
cylinderLengan.Height := dcSiku.Position.Y - dcLengan.Position.Y;
cylinderLengan.Position.Y := -(cylinderLengan.Height / 2)
end
else if Atas then //Pergerakan lengan di sumbu-Y ke atas
begin
if kotak3D[k].Position.Y<puncak then
begin
kotak3d[k].Position.Y := kotak3D[k].Position.Y + 0.1;
dcLengan.Position.Y := dcLengan.Position.Y + 0.1;
cylinderLengan.Height := dcSiku.Position.Y - dcLengan.Position.Y;
cylinderLengan.Position.Y := -(cylinderLengan.Height / 2)
end
else
begin
Kanan := true;
Kiri := true;
Bawah := true;
inc(iKontrol)
end
end
else //(str='PUTDOWN') or (str='STACK')
begin
if str='PUTDOWN' then
begin
j := xKontrol;
m := zKontrol;
ontable := pos(v1, otStr);
if ontable<>0 then
begin
j := -otVektor[ontable-1].x;
m := otVektor[ontable-1].z
end;
n := 0
end
63
4.1.2. Implementasi Antarmuka
Implementasi antarmuka aplikasi simulasi dunia balok terbagi menjadi enam
bagian, yaitu: implementasi menu, implementasi input, implementasi rendering,
implementasi analisis hasil, implementasi simulasi dan implementasi output.
Implementasi antarmuka simulasi dunia balok ditunjukkan gambar 4.1.
Gambar 4.1. Implementasi Antarmuka Simulasi Dunia Balok
4.1.2.1. Implementasi Menu
Implementasi menu utama aplikasi yang terdiri atas tiga bagian, yaitu:
Simulasi, Pengaturan dan Bantuan dapat dilihat pada gambar 4.2. Menu dapat
diakses menggunakan mouse dan shortcut (kombinasi tombol pada keyboard yang
tertera di samping pilihan menu).
64
Gambar 4.2. Implementasi Menu Simulasi Dunia Balok
4.1.2.2. Implementasi Input
Implementasi Input yang terdiri atas dua kotak isian (Jumlah Balok dan
Kondisi Balok), satu tombol pilihan (Pilih State), dan lima tombol perintah (Buka
Berkas, Ubah, Bersihkan, Proses, Temukan Solusi) dapat dilihat pada gambar 4.3.
Gambar 4.3. Implementasi Input
4.1.2.3. Implementasi Rendering
Implementasi Rendering yang menampilkan informasi frame per second (FPS)
dan resolusi area simulasi dapat dilihat pada gambar 4.4.
Gambar 4.4. Implementasi Rendering
4.1.2.4. Implementasi Analisis Hasil
Implementasi Analisis Hasil yang memperlihatkan hasil perhitungan dari
proses Temukan Solusi dapat dilihat pada gambar 4.5.
65
Gambar 4.5. Implementasi Analisis Hasil
4.1.2.5. Implementasi Simulasi
Implementasi Simulasi untuk memulai dan menghentikan simulasi serta satu
track bar untuk mengubah kecepatan animasi dapat dilihat pada gambar 4.6.
Gambar 4.6. Implementasi Simulasi
4.1.2.6. Implementasi Output
Implementasi Output terdiri atas satu buah listbox untuk menampung langkah-
langkah solusi dan satu buah panel Area Simulasi dapat dilihat pada gambar 4.7.
Gambar 4.7. Implementasi Output
66
4.1.3. Implementasi Area Simulasi
Implementasi Area Simulasi memungkinkan pengguna untuk melihat dunia
balok dalam pandangan tiga dimensi. Pengguna harus berinteraksi menggunakan
mouse untuk mengubah posisi pandangan kamera. Click and Drag akan merotasi dan
mentranslasi kamera. Scroll akan menimbulkan efek kamera yang menjauh atau
mendekat dari area simulasi. Implementasi Area Simulasi dengan tampilan awal
dapat dilihat pada gambar 4.8(a). Gambar 4.8(b) memperlihatkan perubahan letak
kamera yang diposisikan mendekat. Gambar 4.8(c) memperlihatkan kamera yang
dijauhkan dan diputar posisinya.
(a) Tampilan awal
(b) Kamera mendekat
(b) Kamera menjauh dan berputar
Gambar 4.8. Implementasi Area Simulasi
4.1.3.1. Implementasi Meja
Implementasi Meja dibuat dengan memanfaatkan fungsi TGLHeightField
pada GLScene. Posisi titik tengah meja pada koordinat (0, -2, 0). Tesktur diperoleh
dengan me-load gambar marbletiles.jpg pada folder res. Sintaksnya sebagai
berikut:
hfPermukaan.Material.Texture.Image.LoadFromFile('res/marbletiles.jpg')
Tekstur kemudian di-sampling 2 step pada XsamplingScale dan
YsamplingScale-nya. Sumber cahaya didapatkan dengan menempatkan
TGLLightSource pada koordinat (5,5,5). Hasil implementasi Meja diperlihatkan
gambar 4.9. Dari gambar terlihat sebagian area meja lebih terang intensitasnya
dibandingkan permukaan yang lain.
67
Gambar 4.9. Implementasi Permukaan Meja
4.1.3.2. Implementasi Balok
Balok diimplementasikan dengan memanfaatkan fungsi TGLDummyCube pada
GLScene. CubeSize diset dengan nilai 1, sehingga diperoleh balok dengan panjang,
lebar, dan tinggi yang sama.
Sintaks Parts := [cpTop,cpBottom,cpFront,cpBack,cpLeft,cpRight]
pada fungsi Gambar Balok menunjukkan bahwa Balok digambar secara utuh, yaitu
terdiri atas 6 sisi (atas, bawah, depan, belakang, kiri dan kanan).
Implementasi balok dan label dapat dilihat pada gambar 4.10.
Gambar 4.10. Implementasi Balok dan Label
68
4.1.3.3. Implementasi Tangan Robot
Implementasi Tangan Robot merupakan gabungan dari beberapa bangun ruang,
yaitu TGLSphere sebagai siku, TGLCylinder sebagai lengan yang dapat memanjang
dan memendek serta TGLCube sebagai „telapak‟ yang akan menempel pada balok
ketika terjadi proses pengambilan atau pemindahan suatu balok.
Implementasi Tangan Robot ketika dalam keadaan kosong dapat dilihat pada
gambar 4.11 dan Tangan Robot ketika mengambil balok (dengan lengan yang
bertambah panjang) dapat dilihat pada gambar 4.12.
Gambar 4.11. Implementasi Tangan Robot
Gambar 4.12. Implementasi Tangan Robot saat Memegang Balok
69
4.2. Pengujian
Pengujian dilakukan untuk mengetahui hasil yang didapat dari aplikasi
simulasi yang telah dibuat. Pengujian yang dilakukan dibagi menjadi tiga bagian,
yaitu pengujian aplikasi, pengujian algoritma perencanaan STRIPS dan pengujian
proses simulasi.
4.2.1. Lingkungan Pengujian
Lingkungan pengujian meliputi piranti masukan, spesifikasi perangkat keras
dan perangkat lunak yang digunakan dalam menguji aplikasi simulasi dunia balok
menggunakan algoritma perencanaan STRIPS.
Untuk berinteraksi dengan aplikasi, pengguna membutuhkan piranti masukan
berupa monitor, keyboard dan mouse. Spesifikasi perangkat keras dan perangkat
lunak yang digunakan untuk menguji aplikasi yaitu:
a. PC-Desktop AMD® Phenom™ II X2 550 Processor 2 GHz
b. RAM DDR3 (memori 3 GB)
c. Kartu Grafis NVIDIA® nForce 720a (memori 1024 MB)
d. Sistem Operasi Windows® XP Professional Service Pack 3
4.2.2. Perencanaan Pengujian
Proses pengujian aplikasi merunut pada Software Requirement Spesification
(SRS) yang telah dibuat dengan menggunakan butir-butir rencana pengujian.
Perencanaan pengujian menggunakan skenario pengujian yang tersaji dalam
Software Test Plan (STP) pada Tabel 4.1.
Pengujian algoritma perencanaan STRIPS adalah pengujian proses untuk
menemukan solusi (fungsi Temukan Solusi). Algoritma diuji dengan memasukkan
sejumlah initial state dengan jumlah balok berbeda. Pengujian proses simulasi diuji
dengan menjalankan fungsi Jalankan Simulasi. Pengujian dilakukan untuk
memastikan pergerakan tangan robot sesuai dengan operator pada listbox Solusi.
70
Tabel 4.1. Identifikasi dan Rencana Pengujian
Kategori Pengujian Butir-Butir Pengujian Identifikasi
SRS STP
Membuat simulasi baru Memilih menu Simulasi – Buat Baru SRS-F-001 STP-01
Menekan shortcut Ctrl + O SRS-F-001 STP-02
Membuka berkas simulasi Memilih menu Simulasi – Buka Simulasi SRS-F-002 STP-03
Menekan shortcut Ctrl + N SRS-F-002 STP-04
Menyimpan simulasi Memilih menu Simulasi – Simpan
Simulasi
SRS-F-003 STP-05
Menekan shortcut Ctrl + S SRS-F-003 STP-06
Menggambar area simulasi
dalam bentuk tiga dimensi
Menempatkan TGLLightSource pada
koordinat (5,5,5)
SRS-F-004 STP-07
Me-load gambar marbletiles.jpg sebagai
tekstur permukaan meja
SRS-F-004 STP-08
Mengubah arah pandangan kamera SRS-F-004 STP-09
Menjauh-dekatkan kamera SRS-F-004 STP-10
Menggambar dan menyusun
tumpukan balok
Memasukkan jumlah balok yang valid SRS-F-005 STP-11
Memasukkan jumlah balok yang tidak
valid
SRS-F-005 STP-12
Memasukkan jumlah balok < 1 atau jumlah
balok > 52
SRS-F-005 STP-13
Menekan tombol Ok SRS-F-005 STP-14
Memilih Initial State SRS-F-005 STP-15
Memilih Goal State SRS-F-005 STP-16
Mengisi text box Kondisi awal tumpukan
balok
SRS-F-005 STP-17
Mengisi text box Kondisi akhir tumpukan
yang ingin dicapai
SRS-F-005 STP-18
Menekan tombol Buka berkas SRS-F-005 STP-19
Menekan tombol Bersihkan SRS-F-005 STP-20
Menekan tombol Proses SRS-F-005 STP-21
Menekan tombol Ubah SRS-F-005 STP-22
Menggambar tangan robot Memilih menu Pengaturan – Tumpukan –
Kondisi Awal
SRS-F-006 STP-23
Memilih menu Pengaturan – Tumpukan –
Kondisi Akhir
SRS-F-006 STP-24
Menekan Armempty pada form Penyusun
Tumpukan Balok
SRS-F-006 STP-25
Menekan Holding dan memilih salah satu
balok pada Pilih Balok
SRS-F-006 STP-26
Menemukan solusi optimal Menekan tombol Temukan Solusi SRS-F-007 STP-27
Menampilkan dan
menganalisis hasil pencarian
solusi
Menampilkan langkah-langkah solusi pada
listbox Output
SRS-F-008 STP-28
Menampilkan Lama pencarian solusi SRS-F-008 STP-29
Menampilkan Jumlah perulangan SRS-F-008 STP-30
Menampilkan Jumlah langkah solusi SRS-F-008 STP-31
Menampilkan Solusi setelah Prunning SRS-F-008 STP-32
71
Kategori Pengujian Butir-Butir Pengujian Identifikasi
SRS STP
Mensimulasikan solusi yang
ditemukan
Menekan tombol Jalankan Simulasi SRS-F-009 STP-33
Menampilkan animasi pergerakan tangan
robot memindahkan balok
SRS-F-009 STP-34
Menekan tombol Berhenti SRS-F-009 STP-35
Menekan tombol Akhiri Simulasi SRS-F-009 STP-36
Mengubah kecepatan simulasi Menggeser track bar Kecepatan Simulasi SRS-NF-01 STP-37
Menampilkan informasi kecepatan
simulasi
SRS-NF-01 STP-38
Mengubah ukuran area
simulasi
Menekan tombol Rendering 640x480 SRS-NF-02 STP-39
Menekan tombol Rendering 480x320 SRS-NF-02 STP-40
Mengubah dan menyimpan
pengaturan rendering
Memilih menu Pengaturan – Rendering SRS-NF-03 STP-41
Menekan Render permukaan simulasi SRS-NF-03 STP-42
Menekan Render lengan robot SRS-NF-03 STP-43
Menekan Tunjukkan sumbu cartesian SRS-NF-03 STP-44
Menekan Putar balok -90o SRS-NF-03 STP-45
Menekan Putar balok 180o SRS-NF-03 STP-46
Menekan Simpan pengaturan SRS-NF-03 STP-47
Menampilkan bantuan
penggunaan simulasi
Memilih menu Bantuan – Topik bantuan SRS-NF-04 STP-48
Memilih menu Bantuan – Tentang simulasi SRS-NF-04 STP-49
4.2.3. Proses Pengujian
Pengujian aplikasi simulasi dunia balok menggunakan metode black-box, yaitu
berfokus pada persyaratan fungsional aplikasi. Pengujian dilakukan terhadap
sembilan SRS fungsional dan empat SRS non fungsional yang menghasilkan empat
puluh sembilan STP (tabel 4.1).
Pengujian selanjutnya yang dilakukan adalah pengujian untuk menemukan
solusi dan pengujian proses simulasi. Pengujian untuk menemukan solusi meliputi
proses input masukan (initial state dan goal state) melalui kotak isian ataupun fungsi
Buka Berkas, proses penggambaran balok (fungsi Gambar Balok), proses
penyusunan tumpukan balok (fungsi Susun Tumpukan) dan proses menemukan
solusi (fungsi Temukan Solusi).
Pengujian simulasi meliputi tampilan animasi pergerakan tangan robot yang
mengubah kondisi balok (fungsi Jalankan Simulasi, Berhenti, dan Akhiri Simulasi),
pengujian non fungsional, yaitu mengubah kecepatan dan ukuran area simulasi.
72
4.2.3.1. Pengujian Temukan Solusi
Langkah-langkah yang dilakukan pengguna untuk menemukan solusi dari
sebuah initial state menjadi goal state adalah sebagai berikut:
1. Memasukkan jumlah balok
Pengguna memasukkan jumlah balok (n) dan menekan tombol Ok. Tombol Ok
akan menjalankan fungsi Gambar Balok dan sebagai hasilnya balok dengan
jumlah n akan tergambar pada area simulasi. Hasil pengujian memasukkan
jumlah balok dapat dilihat pada gambar 4.14. Apabila isian jumlah balok tidak
valid, akan muncul pesan kesalahan yang diperlihatkan gambar 4.13 (a). Apabila
isian jumlah balok lebih kecil dari 0 atau lebih besar dari 52 akan muncul pesan
kesalahan yang diperlihatkan gambar 4.13 (b).
(a) Pesan Kesalahan 1
(b) Pesan Kesalahan 2
Gambar 4.13. Pesan Kesalahan Jumlah Balok Tidak Valid
Gambar 4.14. Pengujian Memasukkan Jumlah Balok
73
2. Memasukkan initial state (kondisi awal tumpukan balok)
Pengguna memilih initial state dan memasukkan kondisi balok pada kotak isian
“Kondisi awal tumpukan balok”. Untuk memasukkan kondisi balok, pengguna
diberikan dua pilihan, dengan langsung mengetik pada kotak isian yang sudah
disediakan atau menekan tombol Buka berkas. Tombol Buka berkas akan
menjalankan fungsi Buka Berkas. Hasil pengujian memasukkan kondisi awal
tumpukan balok dapat dilihat pada gambar 4.15.
Gambar 4.15. Pengujian Memasukkan Initial State
3. Menekan tombol Proses
Ketika pengguna menekan tombol Proses, aplikasi akan menjalankan fungsi
Susun Tumpukan. Sebagai hasilnya, gambar tumpukan balok pada area simulasi
akan menyesuaikan kondisi pada kotak isian. Hasil pengujian menekan tombol
proses dapat dilihat pada gambar 4.17. Apabila kondisi pada kotak isian tidak
sesuai dengan jumlah balok, akan muncul pesan kesalahan (gambar 4.16).
Gambar 4.16. Pesan Kesalahan Jumlah Balok pada Kotak Isian Tidak Valid
Gambar 4.17. Pengujian Tombol Proses Initial State
74
4. Memasukkan goal state (kondisi akhir tumpukan yang ingin dicapai)
Prosesnya seperti pada langkah 2, memasukkan initial state. Hasil pengujian
memasukkan goal state dapat dilihat pada gambar 4.18.
Gambar 4.18. Pengujian Memasukkan Goal State
5. Menekan tombol Proses
Tombol Proses kali ini untuk menyusun tumpukan balok pada goal state. Hasil
pengujian menekan tombol proses dapat dilihat pada gambar 4.19.
Gambar 4.19. Pengujian Tombol Proses Goal State
6. Menekan tombol Temukan Solusi
Langkah terakhir yang dilakukan pengguna untuk menemukan solusi yaitu
menekan tombol Temukan Solusi. Aplikasi akan menjalankan fungsi Temukan
Solusi dan Pangkas Solusi. Sebagai hasilnya, akan keluar langkah solusi
penyelesaian masalah dunia balok pada kotak Output. Hasil pengujian menekan
tombol temukan solusi dapat dilihat pada gambar 4.20.
Gambar 4.20. Pengujian Menekan Tombol Temukan Solusi
75
7. Menyimpan simulasi
Pengguna dapat menyimpan proses simulasi yang baru saja dijalankan melalui
menu Simulasi – Simpan Simulasi atau dengan menekan tombol Ctrl+S.
Sebagai hasilnya, akan muncul kotak pemberitahuan simulasi telah berhasil
disimpan. Hasil pengujian menyimpan simulasi dapat dilihat pada gambar 4.21.
Gambar 4.21. Pengujian Menyimpan Simulasi
Simulasi disimpan ke berkas eksternal bertipe Text Document (*.txt). Isi berkas
simpanan mencakup jumlah balok, initial state, goal state dan solusi. Isi berkas
tersebut dapat dilihat pada gambar 4.22.
Gambar 4.22. Berkas Hasil Pengujian Simpan Simulasi
Berkas simulasi yang telah tersimpan ini dapat dipakai kembali di
kemudian hari menggunakan menu Simulasi – Buka Simulasi atau dengan
menekan tombol Ctrl+O.
4.2.3.2. Pengujian Jalankan Simulasi
Pengujian simulasi menampilkan proses animasi pergerakan tangan robot
ketika memindahkan posisi balok. Gambar 4.23 berikut memperlihatkan contoh
output langkah-langkah sebuah Solusi. Pergerakan animasi berurut dari langkah
solusi pertama sampai langkah solusi ke-n. Pada kasus ini n=4 sehingga ada empat
pergerakan animasi. Langkah pertama UNSTACK(B,A) menganimasikan tangan
robot yang mengambil balok A dari atas balok B, gambar 4.24 (a). Langkah kedua
76
STACK(B,D) menganimasikan tangan robot yang menaruh balok B ke atas balok D,
gambar 4.24 (b). Proses animasi akan terus berlanjut sampai langkah-langkah solusi
telah selesai dijalankan seluruhnya.
Gambar 4.23. Contoh Output Sebuah Solusi
(a) UNSTACK(B,A)
(b) STACK(B,D)
Gambar 4.24. Tangan Robot Memindahkan Balok Berdasarkan Langkah Solusi
Pada implementasi simulasi, terdapat kontrol untuk menjalankan,
menghentikan, mengakhiri dan mengubah kecepatan animasi. Secara default,
tampilan tampak seperti diperlihatkan gambar 4.25 (a). Saat pengguna menjalankan
animasi, tombol Jalankan Simulasi akan digantikan oleh tombol Berhenti,
diperlihatkan gambar 4.25 (b). Pengguna dapat mengakhiri animasi yang sedang
berjalan dengan menekan tombol Akhiri Simulasi.
(a) Simulasi Dihentikan
(b) Simulasi Dijalankan
Gambar 4.25. Pengujian Tombol untuk Menjalankan dan Menghentikan Simulasi
Kecepatan simulasi dapat diubah-ubah dengan menggeser track bar ke kanan
atau ke kiri. Semakin besar nilai kecepatan simulasi, pergerakan tangan robot ketika
memindahkan balok akan semakin cepat. Nilai kecepatan simulasi yang ada yaitu
77
0.5x, 1x, 1.5x dan 2x. Nilai 0.5x mengeset timer dengan interval 60 miliseconds
(ms), 1x dengan interval 30 ms, 1.5x dengan interval 15 ms dan 2x dengan
interval 1 ms.
Informasi FPS pada implementasi Rendering memperlihatkan hasil yang
berbeda ketika simulasi berjalan dan berhenti. Pada saat aplikasi dalam keadaan idle,
FPS bernilai 0, diperlihatkan gambar 4.26 (a). Ketika pengguna menggerakkan
mouse untuk mengganti sudut pandang kamera dan menjalankan simulasi, FPS
bernilai 33.3, diperlihatkan gambar 4.26 (b). Nilai FPS dipengaruhi oleh perangkat
keras komputer. Semakin bagus graphics card yang digunakan, FPS akan semakin
besar nilainya dan animasi yang ditampilkan akan semakin halus.
(a) Saat Idle
(b) Saat Simulasi
Gambar 4.26. Hasil Pengujian Frame Per Second
Pengujian selanjutnya yaitu mengubah luas area simulasi. Tombol untuk
mengubah area simulasi pada implementasi Rendering (gambar 4.26). Terdapat dua
pilihan, yaitu 480 x 320 diperlihatkan gambar 4.27 (a) dan 640 x 480 diperlihatkan
gambar 4.27 (b). Resolusi yang lebih besar memberikan tampilan yang lebih luas.
(a) Resolusi 480 x 320
(b) Resolusi 640 x 480
Gambar 4.27. Hasil Pengujian Mengubah Luas Area Simulasi
78
4.2.3.3. Hasil proses pengujian
Pengujian aplikasi yang dilakukan berhasil memastikan bahwa masukan yang
tepat akan menghasilkan keluaran yang tepat sesuai dengan apa yang diharapkan.
Hasil proses pengujian dari semua SRS aplikasi simulasi dunia balok dapat dilihat
pada lampiran 3.
Pengujian algoritma perencanaan STRIPS berhasil memperlihatkan kinerja
aplikasi ketika diuji terhadap berbagai jumlah balok. Hasil pengujian algoritma
perencanaan STRIPS dapat dilihat pada tabel 4.2.
Pengujian simulasi berhasil memperlihatkan tampilan animasi pergerakan
tangan robot yang mengubah kondisi balok pada initial state menjadi goal state.
Fungsi-fungsi minor yang diharapkan (mengubah kecepatan simulasi, mengubah luas
area simulasi dan informasi rendering) juga berhasil diperlihatkan oleh aplikasi.
4.2.4. Analisis Hasil Pengujian Algoritma Perencanaan STRIPS
Algoritma perencanaan STRIPS yang dilengkapi dengan pruning pada aplikasi
simulasi dunia balok diuji dengan memasukkan sejumlah kasus dengan jumlah balok
berbeda. Jumlah balok yang diujikan yaitu: 2, 4, 6, 9, 16, 26, 29, 36, 46, 48, 50 dan
52. Terdapat total dua belas (12) initial state dan goal state. Tabel initial dan goal
state yang digunakan untuk proses pengujian dapat dilihat pada lampiran 1.
Pengujian nomor 1 dengan kasus dua buah balok, dibutuhkan sejumlah lima
belas (15) perulangan untuk dapat menemukan solusi. Waktu yang dibutuhkan yaitu
0 miliseconds (ms) dengan jumlah solusi dan solusi optimal bernilai empat (4). Nilai
yang sama antara solusi optimal dan jumlah solusi memberikan pengertian bahwa
solusi yang ditemukan sudah merupakan solusi optimal. Hasil yang sama didapatkan
pada pengujian nomor 2 (empat balok) dan nomor 3 (enam balok).
Pengujian nomor 4 dengan kasus sembilan buah balok, dibutuhkan sejumlah
107 perulangan. Jumlah solusi yang ditemukan adalah 33 dengan solusi optimal
adalah 19. Hal ini menunjukkan terdapat 14 langkah solusi yang dipangkas. Nilai 14
didapat dari jumlah solusi (33) dikurangi dengan jumlah solusi optimal (19).
79
Pengujian nomor 5 (dengan kasus 16 balok) dan nomor 6 (dengan 26 balok)
memperlihatkan jumlah perulangan yang semakin besar. Hal tersebut berbanding
lurus dengan lama waktu yang dibutuhkan untuk menemukan solusi. Grafik
hubungan antara jumlah balok terhadap waktu pencarian (dalam milisecond)
ditunjukkan gambar 4.28. Jumlah solusi pada pengujian nomor 5 adalah 64 langkah
(dengan solusi optimal 38 langkah) dan semakin bertambah pada pengujian nomor 6
yang mendapatkan sejumlah 132 solusi (dengan solusi optimal adalah 72). Grafik
perbandingan antara jumlah solusi dengan solusi optimal (solusi setelah pruning)
ditunjukkan gambar 4.29.
Gambar 4.28. Grafik Hubungan Jumlah Balok Terhadap Lama Pencarian
Gambar 4.29. Grafik Perbandingan Antara Jumlah Solusi dengan Solusi Optimal
0
10
20
30
40
50
60
70
2 4 6 9 16 26 29 36 46 48 50 52
Lama Pencarian
0
100
200
300
400
2 4 6 9 16 26 29 36 46 48 50 52
Jumlah Solusi
Solusi Optimal
Jumlah Balok
Jumlah Balok
waktu (ms)
80
Tabel 4.2. Hasil Pengujian Algoritma Perencanaan STRIPS
No Jumlah
Balok Initial State Goal State Hasil Simulasi
Jumlah
Perulangan
Lama
Pencarian
Jumlah
Solusi
Solusi
Optimal
1 2
15 0 ms 4 4
2 4
15 0 ms 4 4
3 6
39 0 ms 11 11
4 9
107 0 ms 33 19
81
No Jumlah
Balok Initial State Goal State Hasil Simulasi
Jumlah
Perulangan
Lama
Pencarian
Jumlah
Solusi
Solusi
Optimal
5 16
197 15 ms 64 38
6 26
407 20 ms 132 72
7 29
265 10 ms 83 55
82
No Jumlah
Balok Initial State Goal State Hasil Simulasi
Jumlah
Perulangan
Lama
Pencarian
Jumlah
Solusi
Solusi
Optimal
8 36
492 30 ms 160 82
9 46
694 32 ms 225 125
10 48
847 46 ms 286 136
83
No Jumlah
Balok Initial State Goal State Hasil Simulasi
Jumlah
Perulangan
Lama
Pencarian
Jumlah
Solusi
Solusi
Optimal
11 50
1024 63 ms 354 150
12 52
985 47 ms 327 145
84
BAB V
PENUTUP
5.1. Kesimpulan
Kesimpulan yang dapat diambil dari pembuatan tugas akhir ini adalah:
1. Aplikasi yang dibangun menggunakan algoritma perencanaan STRIPS dengan
Delphi dan OpenGL berhasil mensimulasikan penyelesaian dunia balok.
2. Aplikasi menghasilkan keluaran berupa solusi penyelesaian dan tampilan
simulasi dalam pandangan tiga dimensi.
3. Algoritma perencanaan STRIPS mampu menghasilkan solusi lebih optimal
ketika digabungkan dengan prosedur pruning (pemangkasan).
5.2. Saran
Berikut adalah saran-saran dari penulis untuk pengembangan lebih lanjut
penelitian dengan tema penyelesaian masalah dunia balok:
1. Pengembangan aplikasi dengan algoritma perencanaan lain, misalnya Constraint
Posting, untuk membandingkan kelebihan dan kekurangan masing-masing
algoritma perencanaan ketika dihadapkan pada kasus penyelesaian masalah
dunia balok.
2. Penamaan balok tidak menggunakan satu karakter ASCII, sehingga dapat
diujikan balok dengan jumlah lebih banyak.
3. Penambahan fitur yang memungkinkan pengguna berinteraksi langsung (click
and drag) balok-balok untuk menyusun sebuah tumpukan.
85
DAFTAR PUSTAKA
[1] Desiani A. dan Arhami M., 2006, “Konsep Kecerdasan Buatan”, Penerbit ANDI,
Yogyakarta.
[2] Dinther P. V., 2003, “GLScene: OpenGL Solution for Delphi (Help File)”.
[3] Dunn F. dan Parberry I., 2002, “3D Math primer for Graphic and Game
Development”, Wordware Publishing, Texas.
[4] Fikes R. E. dan Nilsson N. J., 1971, “STRIPS: a New Approach to the Application of
Theorem Proving to Problem Solving”, Presented at the 2nd IJCAI, Imperial
College, London, England.
[5] Fikes R. E. dan Nilsson N. J., 1993, “STRIPS, a Retrospective”, Elsevier Science
Publisher.
[6] Kakiay T. J., 2004, “Pengantar Sistem Simulasi”, Penerbit Andi, Yogyakarta.
[7] Kusumadewi S, 2003, “Artificial Intelligence (Teknik dan Aplikasinya)”, Penerbit
Graha Ilmu, Yogyakarta.
[8] Ladjamudin A. B., 2005, “Analisis dan Desain Sistem Informasi”, Penerbit Graha
Ilmu, Yogyakarta.
[9] Malik J. J., 2010, “Mudah Belajar Membuat Aplikasi Pemrograman Delphi 2010”,
Penerbit ANDI, Yogyakarta.
[10] Nugroho E., 2005, “Teori dan Praktek Grafika Komputer Menggunakan Delphi dan
OpenGL”, Penerbit Graha Ilmu, Yogyakarta.
[11] Pressman R. S., 2001, “Software Engineering: a Practitioner’s Approach”, Fifth
Edition, McGraw-Hill, New York.
[12] Russel S. dan Norvig P., 1995, “Artificial Intelligence a Modern Approach”, First
Edition, Prentice Hall, New Jersey.
[13] Shreiner D., 2009, “OpenGL Programming Guide”, Seventh Edition, Addison-
Wesley.
[14] Slavova S., 2005, “Block World Documentation”, diakses dari
http://homepage.usask.ca/~sds797/862/Assignment1/BlockWorldDocumentation.htm
l, pada tanggal 23 Desember 2010, pukul 10:01 WIB.
86
[15] Soenarsihanto P. dan Hidayati M., 2004, “Studi Perbandingan Beberapa Algoritma
Teknik Pencarian Heuristic untuk Menyelesaikan Problem Block World”, pada
Lokakarya Komputasi Dalam Sains dan Teknologi Nuklir V.
[16] Suyanto, 2011, “Artificial Intelligence: Searching, Reasoning, Planning dan
Learning”, Penerbit Informatika, Bandung.
[17] Suyoto, 2003, “Teori dan Pemrograman Grafika Komputer dengan Visual C++ V.6
dan OpenGL”, Gava Media, Yogyakarta.
[18] Winston P. H., 1992, “Artificial Intelligence”, Third Edition, Addison-Wesley.
[19] Wright R. S., dkk, 2010, “OpenGL SuperBible: Comprehensive Tutorial and
Reference”, Fifth Edition, Addison-Wesley.
[20] Zizka J., 2005, “GLScene Beginner's Guide”, Prague, diakses dari
http://www.skinhat.com/GLSceneDemos/janzizka/GLScene/html/GLScene_1.php,
pada tanggal 12 September 2012, pukul 21:37 WIB.
87
LAMPIRAN
Lampiran 1 : Tabel Initial State dan Goal State Proses Pengujian
No JB Initial State Goal State
1 2 ONTABLE(B)^ON(A,B)^CLEAR(A)^ARMEMPTY ONTABLE(A)^ON(B,A)^CLEAR(B)^ARMEMPTY
2 4 ONTABLE(A)^ONTABLE(C)^ONTABLE(D)^ON(B,A)^CLEAR(B)^CLEAR(
C)^CLEAR(D)^ARMEMPTY
ONTABLE(A)^ONTABLE(D)^ON(B,D)^ON(C,A)^CLEAR(B)^CLEAR(C)^ARMEM
PTY
3 6 ONTABLE(A)^ONTABLE(E)^ONTABLE(F)^ON(B,A)^ON(C,F)^CLEAR(B)^
CLEAR(C)^CLEAR(E)^HOLDING(D)
ONTABLE(D)^ONTABLE(F)^ONTABLE(B)^ON(A,D)^ON(C,A)^ON(E,F)^CLEAR(
C)^CLEAR(E)^CLEAR(B)^ARMEMPTY
4 9 ONTABLE(A)^ONTABLE(B)^ONTABLE(E)^ONTABLE(I)^ON(C,B)^ON(F,I
)^ON(G,A)^ON(H,C)^CLEAR(E)^CLEAR(F)^CLEAR(G)^CLEAR(H)^HOLDI
NG(D)
ONTABLE(C)^ONTABLE(D)^ONTABLE(G)^ONTABLE(H)^ON(A,D)^ON(B,E)^O
N(E,F)^ON(F,I)^ON(I,G)^CLEAR(A)^CLEAR(B)^CLEAR(C)^CLEAR(H)^ARMEM
PTY
5 16 ONTABLE(K)^ONTABLE(P)^ONTABLE(D)^ONTABLE(C)^ONTABLE(E)^
ONTABLE(B)^ONTABLE(G)^ON(N,M)^ON(M,P)^ON(O,D)^ON(A,F)^ON(F,
C)^ON(I,H)^ON(H,J)^ON(J,E)^ON(L,B)^CLEAR(K)^CLEAR(N)^CLEAR(O)^
CLEAR(A)^CLEAR(I)^CLEAR(L)^CLEAR(G)^ARMEMPTY
ONTABLE(F)^ONTABLE(K)^ONTABLE(M)^ONTABLE(G)^ONTABLE(J)^ON(L,
O)^ON(O,G)^ON(I,P)^ON(P,D)^ON(D,E)^ON(B,F)^ON(E,K)^ON(A,C)^ON(C,H)^O
N(N,J)^ON(H,M)^CLEAR(B)^CLEAR(I)^CLEAR(A)^CLEAR(L)^CLEAR(N)^ARM
EMPTY
6 26 ONTABLE(K)^ONTABLE(P)^ONTABLE(D)^ONTABLE(U)^ONTABLE(E)^
ONTABLE(T)^ONTABLE(G)^ON(N,M)^ON(M,P)^ON(O,D)^ON(A,S)^ON(S,
F)^ON(F,R)^ON(R,C)^ON(C,U)^ON(I,Q)^ON(Q,H)^ON(H,J)^ON(J,E)^ON(L,
V)^ON(V,B)^ON(B,T)^ON(Z,W)^ON(W,Y)^ON(Y,X)^ON(X,G)^CLEAR(K)^
CLEAR(N)^CLEAR(O)^CLEAR(A)^CLEAR(I)^CLEAR(L)^CLEAR(Z)^ARM
EMPTY
ONTABLE(R)^ONTABLE(J)^ONTABLE(Y)^ONTABLE(V)^ONTABLE(M)^ONTA
BLE(Q)^ON(L,O)^ON(O,G)^ON(G,R)^ON(I,P)^ON(P,D)^ON(D,E)^ON(X,T)^ON(B,
W)^ON(E,K)^ON(A,C)^ON(T,Z)^ON(W,F)^ON(K,S)^ON(C,H)^ON(Z,U)^ON(N,J)^
ON(F,Y)^ON(S,V)^ON(H,M)^ON(U,Q)^CLEAR(L)^CLEAR(N)^CLEAR(B)^CLEAR
(I)^CLEAR(A)^CLEAR(X)^ARMEMPTY
7 29 ONTABLE(A)^ONTABLE(b)^ONTABLE(D)^ONTABLE(F)^ONTABLE(G)^
ONTABLE(I)^ONTABLE(K)^ONTABLE(R)^ONTABLE(S)^ONTABLE(U)^O
NTABLE(W)^ONTABLE(X)^ONTABLE(Z)^ON(T,G)^ON(N,T)^ON(a,N)^ON
(B,a)^ON(C,Z)^ON(E,P)^ON(H,F)^ON(J,S)^ON(L,J)^ON(M,b)^ON(O,C)^ON(
P,K)^ON(Q,W)^ON(V,I)^ON(Y,A)^CLEAR(B)^CLEAR(D)^CLEAR(E)^CLE
AR(H)^CLEAR(L)^CLEAR(M)^CLEAR(O)^CLEAR(Q)^CLEAR(R)^CLEAR(
U)^CLEAR(V)^CLEAR(X)^CLEAR(Y)^HOLDING(c)
ONTABLE(a)^ONTABLE(B)^ONTABLE(c)^ONTABLE(D)^ONTABLE(F)^ONTAB
LE(G)^ONTABLE(H)^ONTABLE(I)^ONTABLE(K)^ONTABLE(M)^ONTABLE(O)^
ONTABLE(P)^ONTABLE(S)^ONTABLE(U)^ONTABLE(W)^ONTABLE(Z)^ON(A,
c)^ON(b,F)^ON(C,R)^ON(E,S)^ON(J,K)^ON(L,D)^ON(N,G)^ON(Q,B)^ON(R,H)^O
N(T,N)^ON(V,O)^ON(X,Y)^ON(Y,Z)^CLEAR(A)^CLEAR(a)^CLEAR(b)^CLEAR(C
)^CLEAR(E)^CLEAR(I)^CLEAR(J)^CLEAR(L)^CLEAR(M)^CLEAR(P)^CLEAR(Q)
^CLEAR(T)^CLEAR(U)^CLEAR(V)^CLEAR(W)^CLEAR(X)^ARMEMPTY
*JB = Jumlah Balok
88
No JB Initial State Goal State
8 36 ONTABLE(a)^ONTABLE(B)^ONTABLE(c)^ONTABLE(D)^ONTABLE(F)^O
NTABLE(G)^ONTABLE(H)^ONTABLE(I)^ONTABLE(K)^ONTABLE(M)^O
NTABLE(O)^ONTABLE(P)^ONTABLE(S)^ONTABLE(U)^ONTABLE(W)^O
NTABLE(Z)^ONTABLE(i)^ONTABLE(f)^ON(A,c)^ON(b,F)^ON(C,R)^ON(E,
S)^ON(N,f)^ON(e,N)^ON(J,e)^ON(L,D)^ON(h,G)^ON(Q,B)^ON(R,H)^ON(T,h
)^ON(V,O)^ON(X,d)^ON(Y,i)^ON(d,Z)^ON(g,Y)^ON(j,K)^CLEAR(j)^CLEAR
(g)^CLEAR(A)^CLEAR(a)^CLEAR(b)^CLEAR(C)^CLEAR(E)^CLEAR(I)^CL
EAR(J)^CLEAR(L)^CLEAR(M)^CLEAR(P)^CLEAR(Q)^CLEAR(T)^CLEAR(
U)^CLEAR(V)^CLEAR(W)^CLEAR(X)^ARMEMPTY
ONTABLE(b)^ONTABLE(c)^ONTABLE(E)^ONTABLE(f)^ONTABLE(G)^ONTAB
LE(J)^ONTABLE(P)^ONTABLE(W)^ONTABLE(X)^ON(A,X)^ON(j,A)^ON(a,j)^ON
(i,E)^ON(B,W)^ON(O,c)^ON(C,f)^ON(Q,C)^ON(d,O)^ON(D,J)^ON(N,b)^ON(V,Q)^
ON(Z,i)^ON(e,B)^ON(g,a)^ON(K,e)^ON(Y,G)^ON(F,P)^ON(M,D)^ON(H,Y)^ON(U,
d)^ON(h,U)^ON(I,H)^ON(L,Z)^ON(R,N)^ON(T,g)^ON(S,K)^CLEAR(F)^CLEAR(h)^
CLEAR(I)^CLEAR(L)^CLEAR(M)^CLEAR(V)^CLEAR(R)^CLEAR(S)^CLEAR(T)^
ARMEMPTY
9 46 ONTABLE(b)^ONTABLE(f)^ONTABLE(G)^ONTABLE(l)^ONTABLE(n)^O
NTABLE(Q)^ONTABLE(r)^ONTABLE(t)^ONTABLE(U)^ONTABLE(Z)^ON(
D,Q)^ON(F,G)^ON(B,t)^ON(j,f)^ON(A,Z)^ON(K,B)^ON(C,U)^ON(L,b)^ON(c
,n)^ON(M,j)^ON(o,L)^ON(E,r)^ON(p,o)^ON(g,M)^ON(P,K)^ON(e,g)^ON(d,C)
^ON(H,e)^ON(h,E)^ON(Y,d)^ON(J,h)^ON(q,D)^ON(I,l)^ON(V,J)^ON(i,I)^ON
(N,q)^ON(X,H)^ON(k,N)^ON(W,F)^ON(m,P)^ON(R,V)^ON(O,A)^ON(s,W)^
ON(T,O)^ON(S,c)^CLEAR(i)^CLEAR(k)^CLEAR(m)^CLEAR(p)^CLEAR(R)
^CLEAR(S)^CLEAR(s)^CLEAR(T)^CLEAR(X)^CLEAR(Y)^HOLDING(a)
ONTABLE(a)^ONTABLE(d)^ONTABLE(g)^ONTABLE(H)^ONTABLE(J)^ONTAB
LE(k)^ONTABLE(o)^ONTABLE(q)^ONTABLE(S)^ONTABLE(X)^ONTABLE(Z)^O
N(N,a)^ON(i,N)^ON(L,i)^ON(R,L)^ON(A,R)^ON(M,A)^ON(B,d)^ON(Y,B)^ON(s,Y)
^ON(U,s)^ON(m,g)^ON(n,m)^ON(r,n)^ON(W,H)^ON(P,o)^ON(V,q)^ON(I,P)^ON(t,X
)^ON(O,W)^ON(T,S)^ON(Q,V)^ON(h,I)^ON(p,t)^ON(b,J)^ON(l,b)^ON(E,l)^ON(K,Z
)^ON(C,K)^ON(D,C)^ON(j,D)^ON(c,j)^ON(G,c)^ON(f,O)^ON(e,f)^ON(F,e)^CLEAR
(E)^CLEAR(F)^CLEAR(G)^CLEAR(h)^CLEAR(k)^CLEAR(M)^CLEAR(p)^CLEAR
(Q)^CLEAR(r)^CLEAR(T)^CLEAR(U)^ARMEMPTY
10 48 ONTABLE(b)^ONTABLE(f)^ONTABLE(G)^ONTABLE(l)^ONTABLE(n)^O
NTABLE(Q)^ONTABLE(r)^ONTABLE(t)^ONTABLE(U)^ONTABLE(Z)^ON
TABLE(v)^ON(D,Q)^ON(F,G)^ON(B,t)^ON(j,f)^ON(A,Z)^ON(K,B)^ON(C,U)
^ON(L,b)^ON(c,n)^ON(M,j)^ON(o,L)^ON(E,r)^ON(p,o)^ON(g,M)^ON(P,K)^O
N(e,g)^ON(d,C)^ON(H,e)^ON(h,E)^ON(Y,d)^ON(J,h)^ON(q,D)^ON(I,l)^ON(V
,J)^ON(i,I)^ON(N,q)^ON(X,H)^ON(k,N)^ON(W,F)^ON(m,P)^ON(R,V)^ON(O,
A)^ON(s,W)^ON(T,O)^ON(S,c)^ON(a,u)^ON(u,v)^CLEAR(i)^CLEAR(k)^CLE
AR(m)^CLEAR(p)^CLEAR(R)^CLEAR(S)^CLEAR(s)^CLEAR(T)^CLEAR(X)
^CLEAR(Y)^CLEAR(a)^ARMEMPTY
ONTABLE(d)^ONTABLE(g)^ONTABLE(H)^ONTABLE(J)^ONTABLE(k)^ONTAB
LE(o)^ONTABLE(q)^ONTABLE(S)^ONTABLE(X)^ONTABLE(Z)^ONTABLE(u)^O
NTABLE(Q)^ON(a,Q)^ON(N,a)^ON(i,N)^ON(L,i)^ON(R,L)^ON(A,R)^ON(M,A)^O
N(B,d)^ON(Y,B)^ON(s,Y)^ON(U,s)^ON(m,g)^ON(n,m)^ON(r,n)^ON(W,H)^ON(P,o)
^ON(T,q)^ON(I,P)^ON(t,X)^ON(O,W)^ON(V,S)^ON(v,T)^ON(h,I)^ON(p,t)^ON(b,J)^
ON(l,b)^ON(E,l)^ON(K,Z)^ON(C,K)^ON(D,C)^ON(j,D)^ON(c,j)^ON(G,c)^ON(f,O)^
ON(e,f)^ON(F,e)^CLEAR(E)^CLEAR(F)^CLEAR(G)^CLEAR(h)^CLEAR(k)^CLEA
R(M)^CLEAR(p)^CLEAR(v)^CLEAR(r)^CLEAR(V)^CLEAR(U)^CLEAR(u)^ARME
MPTY
89
N
o
J
B Initial State Goal State
11 50 ONTABLE(b)^ONTABLE(C)^ONTABLE(d)^ONTABLE(f)^ONTABLE(Q)^O
NTABLE(r)^ONTABLE(D)^ONTABLE(T)^ONTABLE(w)^ONTABLE(Y)^O
N(n,Y)^ON(u,n)^ON(g,u)^ON(G,g)^ON(N,G)^ON(A,N)^ON(E,R)^ON(V,E)^O
N(O,V)^ON(L,O)^ON(Z,b)^ON(o,C)^ON(m,o)^ON(t,Q)^ON(X,d)^ON(k,m)^O
N(M,r)^ON(J,t)^ON(I,T)^ON(h,f)^ON(j,k)^ON(F,Z)^ON(R,w)^ON(c,D)^ON(H
,I)^ON(a,c)^ON(x,J)^ON(B,X)^ON(W,j)^ON(e,B)^ON(K,F)^ON(U,M)^ON(P,
U)^ON(i,a)^ON(v,e)^ON(l,h)^ON(s,i)^ON(p,K)^ON(S,p)^ON(q,W)^CLEAR(A
)^CLEAR(H)^CLEAR(l)^CLEAR(L)^CLEAR(P)^CLEAR(q)^CLEAR(S)^CLE
AR(s)^CLEAR(v)^CLEAR(x)^ARMEMPTY
ONTABLE(B)^ONTABLE(c)^ONTABLE(f)^ONTABLE(F)^ONTABLE(G)^ONTAB
LE(J)^ONTABLE(M)^ONTABLE(S)^ONTABLE(U)^ONTABLE(x)^ONTABLE(Z)^
ON(K,Z)^ON(O,K)^ON(L,O)^ON(A,L)^ON(b,A)^ON(a,x)^ON(i,a)^ON(n,i)^ON(u,n)
^ON(D,u)^ON(T,f)^ON(I,T)^ON(V,I)^ON(H,V)^ON(X,U)^ON(l,X)^ON(v,l)^ON(o,v)
^ON(R,o)^ON(d,B)^ON(C,d)^ON(E,G)^ON(e,J)^ON(P,M)^ON(g,S)^ON(h,c)^ON(k,C
)^ON(j,e)^ON(r,E)^ON(Y,r)^ON(w,P)^ON(m,k)^ON(N,F)^ON(t,w)^ON(p,j)^ON(W,
m)^ON(Q,g)^ON(s,Q)^ON(q,N)^CLEAR(b)^CLEAR(D)^CLEAR(H)^CLEAR(h)^CL
EAR(p)^CLEAR(q)^CLEAR(R)^CLEAR(s)^CLEAR(t)^CLEAR(W)^CLEAR(Y)^AR
MEMPTY
12 52 ONTABLE(A)^ONTABLE(B)^ONTABLE(C)^ONTABLE(D)^ONTABLE(E)^
ONTABLE(F)^ONTABLE(G)^ONTABLE(H)^ONTABLE(I)^ONTABLE(J)^O
NTABLE(K)^ONTABLE(L)^ONTABLE(M)^ON(a,A)^ON(b,B)^ON(c,C)^ON(
d,D)^ON(e,E)^ON(f,F)^ON(g,G)^ON(h,H)^ON(i,I)^ON(j,J)^ON(k,K)^ON(l,L)^
ON(m,M)^ON(z,m)^ON(Z,l)^ON(y,k)^ON(Y,j)^ON(x,i)^ON(X,h)^ON(w,g)^O
N(W,f)^ON(v,e)^ON(V,d)^ON(u,c)^ON(U,b)^ON(t,a)^ON(N,U)^ON(n,V)^ON(
o,v)^ON(O,w)^ON(Q,X)^ON(s,z)^ON(P,y)^ON(q,s)^ON(p,o)^ON(R,O)^ON(r,
q)^ON(S,x)^ON(T,n)^CLEAR(N)^CLEAR(p)^CLEAR(P)^CLEAR(Q)^CLEAR
(r)^CLEAR(R)^CLEAR(S)^CLEAR(T)^CLEAR(t)^CLEAR(u)^CLEAR(W)^C
LEAR(Y)^CLEAR(Z)^ARMEMPTY
ONTABLE(J)^ONTABLE(K)^ONTABLE(L)^ONTABLE(M)^ONTABLE(N)^ONTA
BLE(O)^ONTABLE(P)^ONTABLE(Q)^ONTABLE(R)^ONTABLE(S)^ONTABLE(T)
^ONTABLE(U)^ONTABLE(V)^ONTABLE(W)^ONTABLE(X)^ONTABLE(Y)^ONT
ABLE(Z)^ON(A,J)^ON(a,K)^ON(B,L)^ON(b,M)^ON(C,N)^ON(c,O)^ON(D,Q)^ON(d
,R)^ON(E,P)^ON(e,S)^ON(F,T)^ON(f,U)^ON(G,V)^ON(g,W)^ON(H,X)^ON(h,Y)^O
N(I,Z)^ON(z,I)^ON(y,H)^ON(x,h)^ON(w,G)^ON(v,g)^ON(u,F)^ON(t,f)^ON(s,E)^ON
(r,e)^ON(q,D)^ON(p,d)^ON(o,C)^ON(n,c)^ON(m,B)^ON(i,t)^ON(l,v)^ON(j,m)^ON(k,
o)^CLEAR(a)^CLEAR(A)^CLEAR(b)^CLEAR(i)^CLEAR(j)^CLEAR(k)^CLEAR(l)^
CLEAR(n)^CLEAR(p)^CLEAR(q)^CLEAR(r)^CLEAR(s)^CLEAR(u)^CLEAR(w)^C
LEAR(x)^CLEAR(y)^CLEAR(z)^ARMEMPTY
90
Lampiran 2 : Tabel ASCII (American Standard Code for Information Interchange)
91
Lampiran 3 : Tabel Hasil Proses Pengujian
Identifikasi Deskripsi Prosedur Pengujian Keluaran yang Diharapkan Hasil yang Didapatkan Kesimpulan
STP-01 Membuat simulasi baru Memilih menu Simulasi – Buat
Baru
Form input, output dan analisis hasil
kembali bersih. Balok menjadi 0
Form input, output dan analisis hasil kembali bersih.
Jumlah balok kembali menjadi 0 (nol) Diterima
STP-02 Membuat simulasi baru Menekan shortcut Ctrl + O Form input, output dan analisis hasil
kembali bersih. Balok menjadi 0
Form input, output dan analisis hasil kembali bersih.
Jumlah balok kembali menjadi 0 (nol) Diterima
STP-03 Membuka simulasi Memilih menu Simulasi – Buka
Simulasi
Tampilan form untuk membuka
berkas simulasi
Tampilan dialog box untuk membuka berkas
simulasi Diterima
STP-04 Membuka simulasi Menekan shortcut Ctrl + N Tampil form untuk membuka berkas
simulasi
Tampilan dialog box untuk membuka berkas
simulasi Diterima
STP-05 Menyimpan simulasi Memilih menu Simulasi –
Simpan Simulasi
Simulasi tersimpan pada berkas
„Simulasi Dunia Balok {waktu}.txt‟
Muncul pesan „simulasi berhasil disimpan‟ dan
simulasi berhasil tersimpan pada berkas „Simulasi
Dunia Balok (7-20-2012 4-14-49 PM).txt‟
Diterima
STP-06 Menyimpan simulasi Menekan shortcut Ctrl + S Simulasi tersimpan pada berkas
„Simulasi Dunia Balok {waktu}.txt‟
Muncul pesan „simulasi berhasil disimpan‟ dan
simulasi berhasil tersimpan pada berkas „Simulasi
Dunia Balok (7-21-2012 9-05-06 PM).txt‟
Diterima
STP-07 Memberi pencahayaan
pada area simulasi
Menempatkan TGLLightSource
pada koordinat (5,5,5)
Terdapat perbedaan gelap-terang
pada area simulasi
TGLLightSource berhasil memberikan efek
pencahayaan gelap-terang Diterima
STP-08 Memberi tekstur pada
permukaan meja
Me-load gambar marbletiles.jpg Permukaan meja mempunyai tekstur Permukaan meja berhasil diberi tekstur dari file
marbletiles.jpg Diterima
STP-09 Mengubah arah
pandangan kamera
Click and drag mouse pada area
simulasi
Sudut pandang area simulasi
berubah-ubah
Kamera berhasil mendapatkan gambar area simulasi
dari depan, belakang, atas dan bawah Diterima
STP-10 Menjauh-dekatkan
kamera
Men-scroll mouse pada area
simulasi
Efek area simulasi yang membesar
dan mengecil
Tampilan area simulasi tampak mengecil ketika
kamera menjauh dan sebaliknya Diterima
STP-11 Memasukkan jumlah
balok yang valid
Mengisi jumlah balok dengan
angka 10
Aplikasi tidak mengeluarkan pesan
kesalahan
Aplikasi tidak mengeluarkan pesan kesalahan Diterima
STP-12 Memasukkan jumlah
balok yang tidak valid
Mengisi jumlah balok dengan
huruf „ab‟
Aplikasi menampilkan pesan
kesalahan
Aplikasi menampilkan pesan kesalahan „Jumlah
balok tidak valid‟ Diterima
STP-13 Memasukkan jumlah
balok > 52
Mengisi jumlah balok dengan
angka 69
Aplikasi menampilkan pesan
kesalahan
Aplikasi menampilkan pesan kesalahan „Jumlah
balok minimal = 1 dan maksimal = 52‟ Diterima
STP-14 Memproses jumlah
balok
Menekan tombol Ok Gambar balok muncul pada area
simulasi
Balok berhasil di-render sesuai jumlah balok yang
didefinisikan Diterima
STP-15 Memilih state Memilih Initial State Tampilan kotak isian initial state Tampilan kotak isian „kondisi awal tumpukan balok‟ Diterima
STP-16 Memilih state Memilih Goal State Tampilan kotak isian goal state Tampilan isian „kondisi akhir yang ingin dicapai‟ Diterima
STP-17 Mengisi initial state Mengisi text box Kondisi awal
tumpukan balok
Isian kondisi awal sebagai initial
state
Isian kondisi awal sebagai initial state Diterima
92
Identifikasi Deskripsi Prosedur Pengujian Keluaran yang Diharapkan Hasil yang Didapatkan Kesimpulan
STP-18 Mengisi goal state Mengisi text box Kondisi akhir
tumpukan yang ingin dicapai
Isian kondisi akhir masuk sebagai
goal state
Isian kondisi akhir masuk sebagai goal state Diterima
STP-19 Mengisi melalui file
*.txt
Menekan tombol Buka berkas Tampil form untuk membuka berkas
teks
Muncul dialog box untuk membuka berkas teks
berisi kondisi tumpukan balok Diterima
STP-20 Membersihkan state Menekan tombol Bersihkan Area isian kondisi kembali kosong Kotak isian kondisi tumpukan balok kembali kosong Diterima
STP-21 Menyusun tumpukan
balok dan tangan robot
Menekan tombol Proses Balok tersusun sesuai kondisi pada
kotak isian kondisi susunan balok
Balok berhasil tersusun berdasarkan kondisi pada
kotak isian kondisi susunan balok Diterima
STP-22 Mengubah state Menekan tombol Ubah Meng-enabled isian susunan balok Kotak isian kondisi kembali menjadi enabled Diterima
STP-23 Menyusun kondisi awal Memilih menu Pengaturan –
Tumpukan – Kondisi Awal
Tampilan form untuk menyusun
Kondisi Awal tumpukan balok
Tampilan form Penyusun Tumpukan Balok Diterima
STP-24 Menyusun kondisi
akhir
Memilih menu Pengaturan –
Tumpukan – Kondisi Akhir
Tampilan form untuk menyusun
Kondisi Akhir tumpukan balok
Tampilan form Penyusun Tumpukan Balok Diterima
STP-25 Menggambar tangan
robot
Menekan Armempty pada form
Penyusun Tumpukan Balok
Tangan robot dalam keadaan kosong Tangan robot tidak memegang balok Diterima
STP-26 Menggambar tangan
robot memegang balok
Menekan Holding dan memilih
balok pada Pilih Balok
Tangan robot dalam keadaan
memegang balok
Tangan robot memegang balok sesuai balok yang
dipilih Diterima
STP-27 Mencari solusi Menekan tombol Temukan
Solusi
Solusi berhasil ditemukan Berhasil menemukan solusi dan menjadikan optimal Diterima
STP-28 Menampilkan solusi Menampilkan langkah-langkah
solusi pada listbox Output
Tampilan output solusi Output langkah-langkah solusi berhasil ditampilkan Diterima
STP-29 Analisis hasil solusi Menampilkan Lama pencarian
solusi
Tampilan waktu pencarian solusi Berhasil menampilkan lama pencarian solusi Diterima
STP-30 Analisis hasil solusi Menampilkan Jumlah
perulangan
Tampilan jumlah perulangan Berhasil menampilkan informasi jumlah perulangan Diterima
STP-31 Analisis hasil solusi Menampilkan Jumlah langkah
solusi
Tampilan jumlah langkah solusi Berhasil menampilkan jumlah langkah solusi Diterima
STP-32 Analisis hasil solusi Menampilkan Solusi setelah
Pruning
Tampilan jumlah langkah solusi
optimal
Berhasil menampilkan jumlah langkah solusi
optimal (setelah dilakukan proses pruning) Diterima
STP-33 Menjalankan simulasi Menekan tombol Jalankan
Simulasi
Animasi simulasi mulai berjalan Animasi simulasi mulai berjalan Diterima
STP-34 Menjalankan simulasi Menampilkan animasi
pergerakan tangan robot
memindahkan balok
Tampilan simulasi, pergerakan
tangan robot
Berhasil mensimulasikan langkah-langkah solusi,
pergerakan tangan robot memindahkan balok Diterima
STP-35 Menghentikan simulasi Menekan tombol Berhenti Animasi simulasi berhenti Animasi simulasi berhenti Diterima
STP-36 Mengakhiri simulasi Menekan tombol Akhiri
Simulasi
Animasi simulasi berakhir Animasi simulasi berakhir, posisi balok kembali
sesuai kondisi initial state Diterima
93
Identifikasi Deskripsi Prosedur Pengujian Keluaran yang Diharapkan Hasil yang Didapatkan Kesimpulan
STP-37 Mengubah kecepatan
simulasi
Menggeser track bar Kecepatan
Simulasi
Kecepatan simulasi berubah-ubah Berhasil mengubah kecepatan simulasi bertambah
cepat atau menjadi lambat Diterima
STP-38 Menampilkan
kecepatan
Menampilkan informasi
kecepatan simulasi
Tampilan kecepatan simulasi Berhasil menampilkan informasi kecepatan simulasi
sesuai posisi track bar kecepatan simulasi Diterima
STP-39 Mengubah area
simulasi
Menekan tombol Rendering
640x480
Tampilan area simulasi seluas
640x480
Berhasil menampilkan area simulasi seluas 640x480 Diterima
STP-40 Mengubah area
simulasi
Menekan tombol Rendering
480x320
Tampilan area simulasi seluas
480x320
Berhasil menampilkan area simulasi seluas 480x320 Diterima
STP-41 Mengatur rendering Memilih menu Pengaturan –
Rendering
Tampilan form pengaturan
rendering
Tampilan form pengaturan rendering dan tombol
Simpan Pengaturan Diterima
STP-42 Opsi permukaan
simulasi
Menekan Render permukaan
simulasi
Permukaan simulasi menjadi visible
atau invisible
Permukaan simulasi menjadi visible ketika pilihan
dicentang, dan invisible ketika tidak dicentang Diterima
STP-43 Opsi lengan robot Menekan Render lengan robot Lengan robot menjadi visible atau
invisible
Lengan robot menjadi visible ketika pilihan
dicentang, dan invisible ketika tidak dicentang Diterima
STP-44 Opsi sumbu kartesian Menekan Tunjukkan sumbu
cartesian
Sumbu kartesian menjadi visible
atau invisible
Sumbu kartesian menjadi visible ketika pilihan
dicentang, dan invisible ketika tidak dicentang Diterima
STP-45 Memutar balok -90o Menekan Putar balok -90
o Balok yang dipilih berputar -90
o Balok yang dipilih berputar -90
o Diterima
STP-46 Memutar balok 180o Menekan Putar balok 180
o Balok yang dipilih berputar 180
o Balok yang dipilih berputar 180
o Diterima
STP-47 Menyimpan pengaturan Menekan Simpan pengaturan Pengaturan tersimpan Pengaturan tersimpan pada berkas „pDBalok.sav‟ Diterima
STP-48 Menampilkan bantuan Memilih menu Bantuan – Topik
bantuan
Tampilan form Bantuan Berhasil menampilkan form Bantuan berisi tutorial
singkat penggunaan aplikasi Diterima
STP-49 Menampilkan
informasi aplikasi
Memilih menu Bantuan –
Tentang simulasi
Tampilan form Tentang simulasi Berhasil menampilkan form Tentang aplikasi berisi
nama pembuat Diterima
