model kurva

Model Kurva
Kurva Spline
• Memudahkan untuk menggambar bentuk kurva yang
kompleks
• Caranya dengan memasukkan rangkaian titik, dan kurva
akan terbentuk mengikuti rangkaian titik tersebut
• Titik-titik tersebut disebut titik kendali (control points)
• Kurva yang melewati tiap titik kendali disebut interpolasi
kurva spline (interpolating curve)
• Kurva yang melewati di dekat titik kendali namun tidak
melewati titik kendali disebut pendekatan kurva spline
(approximating curve)
• Untuk mengubah bentuk kurva, caranya dengan
memindahkan posisi titik kendali
Kurva Spline
Kurva Spline
• Contoh sederhana untuk pemahaman
cara kerja kurva spline : y = x2 (fungsi
polynomial)
Polynomial
• Y = a + bx + cx2 + dx3 + …
• Tingkat polynomial ditentukan oleh
koefisien tertinggi yang nilainya tidak nol
• Sebagai contoh, c nilainya tidak nol, d
bernilai nol, berarti fungsi polynomial
tingkat 2
Polynomial
• Tingkat 0 - Konstan - hanya a yang tidak
nol
• Konstan, didefinisikan dengan 1 titik
• Contoh : y = 3
Polynomial
• Tingkat 1 – Linear – b adalah koefisien
tertinggi yang nilainya tidak nol
• Garis, didefinisikan dengan 2 titik
• Contoh : y = 1 + 2x
Polynomial
• Tingkat 2 – Kuadrat – c adalah koefisien
tertinggi yang nilainya tidak nol
• Parabola, didefinisikan dengan 3 titik
• Contoh : y = 1 – 2x + x2
Polynomial
• Tingkat 3 – Kubik – d adalah koefisien
tertinggi yang nilainya tidak nol
• Kurva kubik, didefinisikan dengan 4 titik
• Paling banyak digunakan untuk membuat
kurva di komputer
• Contoh : y = -1 – 7/2x + 3/2x3
Contoh
• Titik kendali : (-1,2), (0,0), (1,-2), (2,0)
Kurva Bezier
• Banyak digunakan untuk desain kurva
• Mudah diimplementasikan
• Digunakan pada software CAD (contoh :
Corel Draw, GIMP, dll)
• Terdiri dari titik ujung dan titik kendali
• Interpolasi kurva pada titik ujung
• Kurva yang terbentuk berbasis pada posisi
titik ujung dan titik kendali
Kurva Bezier
• Dapat terdiri atas 4 titik, 2 titik sebagai titik
ujung (endpoints), 2 titik sebagai titik
kendali (control points)
• Pada contoh berikut, P0 dan P3 adalah
titik ujung, P1 dan P2 adalah titik kendali
Contoh
Contoh
• Contoh kurva bezier yang terdiri atas 3, 4 dan 5
titik
• Pada gambar a terdiri dari 3 titik, P0 dan P2
adalah titik ujung, P1 titik kendali
• Pada gambar b, c dan d terdiri dari 4 titik, P0
dan P3 sebagai titik ujung, P1 dan P2 sebagai
titik kendali
• Pada gambar e terdiri dari 5 titik, P0 dan P4
adalah titik ujung, P1, P2 dan P3 adalah titik
kendali
Kurva Bézier Linear
• Diketahui P0 and P1, kurva bezier linear
adalah garis lurus diantara kedua titik
tersebut
Ilustrasi: kurva linier
• Simbol t dalam fungsi
mendeskripsikan
seberapa jauh B(t)
dari P0 ke P1.
• Sebagai contoh
t=0.25, B(t) kira-kira
seperempat jalan dari
P0 ke P1.
• t bervariasi dari 0
sampai 1, B(t)
mendeskripsikan kurva
dari P0 ke P1.
Quadratic Bézier curves
• Dapat dirumuskan pada fungsi B(t),
dengan titik P0, P1, and P2,
• Berbentuk parabola
Kurva Bezier Kuadratik
• Ada tiga titik P0, P1, and P2, Kurva Bezier
Kuadratik dapat dirumuskan :
dimana 0 1
( ) (1 ) 2 (1 ) 2
1 2
2
0
£ £
= - + - +
t
x t P t Pt t P t
Kurva Bezier Kuadratik
• Titik P0, P1,
P2.
0
0.5
1
1.5
2
2.5
0 0.5 1 1.5 2 2.5 3 3.5
P0
P1
P2
Kurva Bezier Kuadratik
• Titik P0, P1,
P2.
• Buat garis
dari :
• (1-t)P0 + tP1 ke
(1-t)P1 + tP2
0
0.5
1
1.5
2
2.5
0 0.5 1 1.5 2 2.5 3 3.5
P0
P1
P2
(1-t)P0 + tP1
(1-t)P1 + tP2
Kurva Bezier Kuadratik
• Titik P0, P1,
P2.
• Buat garis
dari :
• (1-t)P0 + tP1 to
(1-t)P1 + tP2
• Titik x pada
kurva
(1-t)2P0 + 2t(1-t)P1 + t2P2
0
0.5
1
1.5
2
2.5
0 0.5 1 1.5 2 2.5 3 3.5
P0
P1
P2
(1-t)P0 + tP1
(1-t)P1 + tP2
(1-t)2P0 + 2t(1-t)P1 + t2P2
Kurva Bezier Kuadratik
• Titik P0, P1,
P2.
• Buat garis
dari :
• (1-t)P0 + tP1 to
(1-t)P1 + tP2
• Titik x pada
kurva
(1-t)2P0 + 2t(1-t)P1 + t2P2
0
0.5
1
1.5
2
2.5
0 0.5 1 1.5 2 2.5 3 3.5
P0
P1
P2
(1-t)P0 + tP1
(1-t)P1 + tP2
(1-t)2P0 + 2t(1-t)P1 + t2P2
Ilustrasi: kurva kuadratik
Kurva Bezier Kubik
• Bila menggunakan 4 titik, kita dapat membentuk
kurva kubik
0
0.2
0.4
0.6
0.8
1
1.2
0 0.5 1 1.5 2 2.5 3 3.5
P0
P1
P2
P3
(1-t)3P0 + 3t(1-t)2P1 + 3t2(1-t)P2 + t3P3
Kurva Bezier Kubik
• Empat titik P0, P1, P2 and P3 dalam sebuah
bidang atau ruang 3 dimensi mendefinisikan
Kurva Bezier Kubik
• Kurva mulai dari P0 menuju ke P1 dan tiba
di P3 berdasarkan arah dari P2. Umumnya,
P1 dan P2 tidak dilewati; titik-titik ini hanya
menyediakan informasi arah kurva.
• Jarak P0 and P1 menentukan seberapa jauh
kurva bergerak ke arah P2 sebelum berbelok
ke P3.
• Dapat dirumuskan dengan persamaan :
Ilustrasi : Kurva Cubic
Ilustrasi: Fourth-order curve
• Bezier kubik didefinisikan dengan 4 titik
• Ada 2 titik ujung
– (x0,y0) – titik ujung awal
– (x3,y3) – titik ujung akhir/tujuan
• (x1,y1) dan (x2,y2) adalah titik kendali
(X2, Y2)
• Dua persamaan berikut mendefinisikan
titik-titik pada kurva. Nilai t antara 0
sampai 1
• Nilai t semakin meningkat, titik yang
didefinisikan oleh x(t) dan y(t) bergerak
dari titik awal menuju titik tujuan
• x(t) = axt3 + bxt2 + cxt + x0
• y(t) = ayt3 + byt2 + cyt + y0
x(t) = axt3 + bxt2 + cxt + x0
x1 = x0 + cx / 3
x2 = x1 + (cx + bx) / 3
x3 = x0 + cx + bx + ax
y(t) = ayt3 + byt2 + cyt + y0
y1 = y0 + cy / 3
y2 = y1 + (cy + by) / 3
y3 = y0 + cy + by + ay
cx = 3 (x1 - x0)
bx = 3 (x2 - x1) – cx
ax = x3 - x0 - cx - bx
cy = 3 (y1 - y0)
b= 3 (y- y) – c(X2, Y2)
cx = 3 (105 - 140) = -105
bx = 3 (281 - 105) – (-105) = 633
ax = 375 - 140 - (-105) - 633 = -293
cy = 3 (42 - 262) = -660
by = 3 (30 - 42) – (-660) = 624
ay = 181 - 262 - (-660) - 624 = -45
(X2, Y2)

segmentasi

Segmentasi
Segmentasi
• Proses pembagian gambar menjadi
banyak segmen
• Untuk menyederhanakan atau mengubah
representasi sebuah gambar menjadi lebih
mudah dianalisa
• Umumnya digunakan untuk menentukan
lokasi objek atau batasan
(gambar,kurva,dll) dalam sebuah gambar
• Memberi label tiap pixel pada sebuah
gambar, pixel dengan label yang sama
mempunyai karakteristik visual tertentu
Segmentasi
• Hasil dari segmentasi gambar adalah
kelompok segmen yang secara kolektif
meliputi seluruh gambar, atau suatu
kelompok garis/kurva yang diekstrak dari
gambar
• Tiap pixel mempunyai karakteristik yang
sama, misalnya warna, intensitas atau
tekstur.
• Salah satu metode untuk segmentasi
adalah Region Growing
Region/Segmen
• Region/segmen – kumpulan pixel
• Properti – nilai gray-scale, warna, tekstur,
bentuk
• Properti digunakan untuk identifikasi
region, kesamaan properti digunakan
untuk membentuk region tertentu
Region/Segmen
• Dalam bentuk matematika, jika suatu
gambar/image I dibagi dalam n
Region/Segmen, maka I adalah
union/gabungan dari semua Region (Rn)
• I = R1 U R2 U R3 U …. U Rn
Penerapan Segmentasi
• Medis
– Menentukan lokasi tumor
– Mengukur ketebalan jaringan otot
– Studi struktur anatomi
– Bedah yang dipandu computer
• Menentukan lokasi objek pada suatu
gambar satelit (jalan, hutan, dll)
• Pengenalan wajah
• Pengenalan sidik jari
Contoh Segmentasi
Gambar Asli Hasil Segmentasi
Contoh Segmentasi
Gambar Asli Hasil Segmentasi
Contoh Segmentasi
Gambar Asli Hasil Segmentasi
Region Growing
• Salah satu metode segmentasi gambar
yang berbasis region
• Diklasifikasikan juga sebagai salah satu
metode segmentasi gambar yang berbasis
pixel
• Tujuan utama dari metode segmentasi
gambar berbasis region adalah membagi
gambar menjadi region-region/daerahdaerah
Region Growing
• Dimulai dengan menentukan kelompok
titik awal (seed points)
• Kemudian berkembang menjadi sebuah
region
• Dengan cara mendeteksi apakah pixel
terdekat mempunyai properti yang sama.
• Jika sama maka tambahkan ke seed
points sampai membentuk sebuah region
Contoh
• Misalnya sebuah gambar petir gray-scale
• Tujuan untuk menandai bagian dari
gambar petir tersebut yang paling kuat
Gambar Asli
Contoh
• Kita tentukan titik-titik yang mempunyai
nilai gray-scale paling tinggi (255) sebagai
seed point/titik awal
Contoh
• Setelah menentukan seed points, kita menentukan
range/kisarannya.
• Pada gambar di atas ditentukan range/kisarannya
adalah 225-255
• Artinya yang ditandai adalah yang mempunyai nilai grayscale
diatas 225
Range 190-255
Range 155-255
Contoh
• Makin lebar range/kisarannya, makin besar area
yang didapatkan
• Pada contoh gambar tersebut masih banyak
area yang mempunyai nilai gray-scale diatas
155 yang tidak ditampilkan
• Yang digambarkan adalah yang mempunyai
hubungan dengan seed points
• Manfaatnya adalah mengurangi noise
• Dalam contoh kasus di atas, manfaatnya adalah
selain bagian dari petir tidak akan digambarkan
karena tidak berhubungan dengan seed points
Kelebihan Region Growing
• Dapat memisahkan region yang mempunyai properti
yang sama seperti yang kita kehendaki
• Menyediakan hasil segmentasi yang bagus bagi gambar
yang memiliki batas yang jelas
• Konsep yang sederhana. Kita hanya perlu menentukan
sejumlah seed point untuk menunjukkan properti yang
kita kehendaki, lalu region sudah dapat dibentuk
• Kita dapat menentukan seed points dan kriteria yang
ingin kita buat
• Kita dapat menentukan beberapa kriteria dalam waktu
yang sama
• Berperan baik dalam menangani noise
Kekurangan Region Growing
• Proses komputasi/perhitungan yang berat
• Tidak dapat membedakan bayangan dari
gambar nyata
Histogram
• Untuk menentukan tingkat/nilai gray-scale
atau warna dapat menggunakan
histogram
• Merupakan suatu grafik distribusi
intensitas warna pada citra.
• Histogram dibuat dengan cara
menghitung jumlah tiap intensitas pada
tiap warna pada suatu gambar.
Contoh
Contoh
• Gambar b menunjukkan histogram dari
gambar a
• Gambar d menunjukkan histogram dari
gambar c
• Pada gambar a, distribusi intensitas warna
sedikit terpusat ke warna dengan intensitas
sedang. Dengan kisaran intensitas antara 150
sampai 255.
• Sedang gambar c, mempunyai distribusi dengan
kecenderungan terletak pada daerah-daerah
gelap pada kisaran warna antara 0 sampai 150.
Gambar
Histogram

animasi

Animasi
Animasi
• Teknik untuk membuat gambar bergerak
buatan
• Berbeda dengan video yang merupakan
rekaman dari kejadian di dunia nyata
• Animasi sepenuhnya buatan manusia
• Animasi pada dasarnya adalah
penampilan gambar secara berganti-ganti
dengan cepat (umumnya 24-30 frame per
detik)
Animasi
Animasi
• Bisa dibuat predefined – setiap frame
sudah digambar sebelumnya, dan hanya
ditampilkan secara bergantian
• Secara dinamis – setiap frame digambar
secara dinamis oleh program
Algoritma Dasar Animasi
While (not done) {
hapus_layar();
gambar_frame_ke(i);
delay(n);
i = i + 1;
}
Algoritma Dasar Animasi
• Kelemahan - penggambaran perlu
dilakukan dengan menghapus seluruh
layar lebih dulu – lambat dan
menyebabkan flicker (kedipan) pada
animasi
Dirty Rectangle Animation
• Cara yang lebih baik – menghapus
gambar sebesar gambar yang berubah
saja
• Kelemahan – jika gambar yang berubah
banyak (mendekati/sebesar ukuran layar,
terutama pada animasi dengan banyak
gerakan) maka tetap saja seluruh layar
perlu digambar ulang sehingga
menyebabkan kedipan
Double Buffering
• Menggambar latar belakang, dan gambar
baru di sebuah kanvas, dan langsung
mengcopy isi kanvas tersebut ke layar
setelah semua selesai tergambar
Triple Buffering
• Serupa dengan double buffering,
memanfaatkan kanvas tambahan yang
sudah berisi latar belakang animasi
• Salin latar belakang ke kanvas sementara
• Gambar kanvas
• Salin kanvas ke layar
• Penggambaran bisa dilakukan dengan
cepat
Animasi Interaktif
• Ada input dari pengguna
• Animasi sesuai input pengguna
• Algoritma sederhana :
While (not done) {
proses_input_user();
hasilkan_frame();
hapus_layar();
gambar_frame();
delay(n);
i = i + 1;
}
Animasi Tradisional
• Menggunakan teknik celluloid
• Masing-masing frame digambar pada kertas
terlebih dahulu
• Untuk memberi efek bergerak, tiap gambar
dibuat sedikit berbeda dengan sebelumnya
• Gambar-gambar tersebut dipindah ke kertas
transparan (cel) kemudian diwarnai
• Direkam dengan kamera khusus,
yaitu multiplane camera didalam ruangan
khusus
Beberapa Prinsip Animasi
• Squash and stretch
• Slow In and out
• Anticipation
• Exaggeration
Squash And Stretch
• Memberi kesan berat dan fleksibilitas pada
objek
• Contoh : animasi bola pantul
Slow In and Slow Out
• Gerakan dari objek memerlukan waktu
untuk percepatan dan perlambatan
• Contoh : animasi mobil
Anticipation
• Digunakan untuk mempersiapkan sebuah
aksi dan membuat sebuah aksi menjadi
lebih realistis
• Contoh :
– Animasi orang melompat
– Animasi karakter yang melihat kedatangan
orang lain
Exaggeration
• Penggambaran karakter yang sama persis
dengan kenyataan akan tampak kaku pada
animasi
• Ada karakter yang digambar tampak “dilebihlebihkan”
• Contoh : karikatur, bentuk tikus (Mickey Mouse)
pada kartun walt disney
Animasi Komputer
• Disebut juga CGI (computer generated imagery)
• Membuat gambar bergerak dengan
menggunakan komputer
• Untuk membuat gerakan, gambar dimunculkan
ke layar kemudian diganti dengan gambar yang
baru
• Untuk mendapatkan animasi yang halus,
gambar harus dimunculkan sekitar 12 frame per
second (fps) atau lebih cepat
Keyframing
• Keyframe – gambar yang mendefinisikan
titik awal dan titik akhir sebuah transisi
gambar
• Animation variable / avar – variabel yang
mengendalikan posisi dari bagian-bagian
objek animasi
• Inbetween / tweening – proses pembuatan
frame diantara 2 gambar untuk
menganimasikan perubahan gambar
pertama ke gambar kedua
Keyframing
• Meletakkan avar pada titik-titik strategis
(frame) pada suatu waktu dan komputer
akan membuat tween diantara mereka
• Metode yang lebih baru – motion capture
Motion Capture
• Menggunakan gerakan manusia asli untuk
menghasilkan gerakan animasi yang
natural
• Gerakan direkam menggunakan kamera
dan marker, kemudian hasilnya diaplikasi
pada animasi
Motion Capture
Jenis Animasi
• Animasi 2 Dimensi (2D), menggunakan 2 aksis
(sudut pandang) yaitu X mewakili lebar dan
gerak kanan-kiri, dan Y mewakili tinggi dan
gerakan atas bawah.  tidak ada ketebalan
pada animasi 2D
• Animasi 3 Dimensi (3D), Menggunakan 3 aksis
(sudut pandang), yaitu X, Y dan Z. Aksis Z
mewakili ketebalan dan gerakan maju mundur.
 Dengan 3 aksis maka objek dan gerakan
lebih realistis.
• Pada animasi 3 dimensi dapat dikreasi efek-efek
seperti pencahayaan dan bayangan.
Animasi 2D
• Dibuat menggunakan gambar 2 dimensi /
grafik vektor 2 dimensi
• Contoh software untuk animasi 2D :
Adobe Flash
• Terdiri dari :
– Tweening
– Morphing
Fungsi Animasi
• Film animasi
• Iklan
• Dalam bidang pendidikan
• Presentasi
• dll

matriks transformasi

Matriks Transformasi
Transformasi Linear
• Transformasi di titik pusat (0,0) maupun di
sembarang titik
Transfomasi Homogen
• Dilakukan dengan menggunakan matriks
transformasi yang menggabungkan
transformasi translasi, penskalaan dan
rotasi ke dalam satu model matriks
• Isi dari matriks transformasi bergantung
pada jenis transformasi yang dilakukan
Grafika Komputer TRANSFORMASI 2D
A. Matriks Transformasi dan Koordinat Homogen
• Kombinasi bentuk perkalian dan translasi untuk transformasi geometri 2D ke
dalam suatu matriks dilakukan dengan mengubah matriks 2 x 2 menjadi
matriks 3 x 3.
• Untuk itu maka koordinat cartesian (x,y) dinyatakan dalam bentuk koordinat
homogen (xh, yh, h), dimana :
x = xh / h y = yh / h
• Dimana untuk geometri 2D parameter h ≠ 0 atau biasanya h = 1, sehingga
setiap posisi koordinat 2D dapat dinyatakan dengan (x, y, 1).
• Untuk transformasi 3D biasanya parameter h ≠ 1.
• Dengan menyatakan posisi titik dalam koordinat homogen, semua transformasi
geometri dinyatakan dalam bentuk matriks.
• Koordinat dinyatakan dalam tiga elemen vektor kolom dan operasi transformasi
ditulis dengan matriks 3 x 3.
Grafika Komputer TRANSFORMASI 2D
A1. Matriks Translasi
ú ú ú
û
ù
ê ê ê
ë
é
ú ú ú
û
ù
ê ê ê
ë
é
=
ú ú ú
û
ù
ê ê ê
ë
é
1
y
x
t .
t
y'
x'
y
x
0 0 1
0 1
1 0
1
A2. Matriks Rotasi
ú ú ú
û
ù
ê ê ê
ë
é
ú ú ú
û
ù
ê ê ê
ë
é -
=
ú ú ú
û
ù
ê ê ê
ë
é
1
y
x
.
0 0 1
sin cos 0
cos sin 0
1
'
'
q q
q q
y
x
A3. Matriks Skala
ú ú ú
û
ù
ê ê ê
ë
é
ú ú ú
û
ù
ê ê ê
ë
é
=
ú ú ú
û
ù
ê ê ê
ë
é
1
y
x
s .
s
y'
x'
y
x
0 0 1
0 0
0 0
1
atau P’ = T(tx, ty) . P
atau P’ = R(θ) . P
atau P’ = S(sx, sy) . P

translasi

Translasi
ú ú ú ú
û
ù
ê ê ê ê
ë
é
×
ú ú ú ú
û
ù
ê ê ê ê
ë
é
=
ú ú ú ú
û
ù
ê ê ê ê
ë
é
0 0 0 1 1
0 0 1
0 1 0
1 0 0
1
'
'
'
z
y
x
t
t
t
z
y
x
z
y
x
(x’,y’,z’)
(x,y,z) T=(tx,ty,tz)
Skala
ú ú ú ú
û
ù
ê ê ê ê
ë
é
×
ú ú ú ú û
ù
ê ê ê ê
ë
é
=
ú ú ú ú
û
ù
ê ê ê ê
ë
é
0 0 0 1 1
0 0 0
0 0 0
0 0 0
1
'
'
'
z
y
x
s
s
s
z
y
x
z
y
x
Rotasi
ú ú ú ú
û
ù
ê ê ê ê
ë
é
×
ú ú ú ú
û
ù
ê ê ê ê
ë
é -
=
ú ú ú ú
û
ù
ê ê ê ê
ë
é
0 0 0 1 1
0 0 1 0
sin cos 0 0
cos sin 0 0
1
'
'
'
z
y
x
z
y
x
q q
q q
ú ú ú ú
û
ù
ê ê ê ê
ë
é
×
ú ú ú ú
û
ù
ê ê ê ê
ë
é
-
=
ú ú ú ú
û
ù
ê ê ê ê
ë
é
0 0 0 1 1
sin 0 cos 0
0 1 0 0
cos 0 sin 0
1
'
'
'
z
y
x
z
y
x
q q
q q
ú ú ú ú
û
ù
ê ê ê ê
ë
é
×
ú ú ú ú
û
ù
ê ê ê ê
ë
é
-
=
ú ú ú ú
û
ù
ê ê ê ê
ë
é
0 0 0 1 1
0 sin cos 0
0 cos sin 0
1 0 0 0
1
'
'
'
z
y
x
z
y
x
q q
q q
Terhadap sumbu z (Rz)
Terhadap sumbu y (Ry)
Terhadap sumbu x (Rx)

warna

Warna
• Warna adalah karakteristik cahaya yang
dapat dipersepsi/dilihat dan disebutkan
berdasarkan namanya.
• Mata manusia memiliki reseptor untuk 3
warna (merah, hijau, biru)
• Warna dideskripsikan melalui 3 cara :
– Dari namanya
– Tingkat kemurnian atau saturasinya
– Nilai atau kecerahannya
Istilah Warna
• Intensitas/intensity : tingkat seberapa terang suatu
warna
• Saturasi/saturation : tingkat kemurnian suatu warna
• Luminansi/luminance : ukuran jumlah cahaya yang
dipantulkan dari suatu warna
• Shade : warna yang dihasilkan dengan penambahan
warna hitam
• Tint : warna yang dihasilkan dengan penambahan warna
putih
• Warna primer : warna yang tidak bisa dibuat dengan
mencampurkan warna lain
• Warna sekunder : warna yang merupakan campuran
dari warna primer
Warna Aditif
• Sistem warna yang dimulai dari hitam,
berakhir dengan putih
• Untuk membentuk warna putih kita
memerlukan semua warna primer
• Contoh : RGB pada monitor
Warna Substraktif
• Sistem warna yang dimulai dari putih,
berakhir dengan hitam
• Untuk membentuk warna hitam kita
mencampurkan semua warna
• Contoh : CMYK pada tinta printer
Representasi dan Manipulasi
Warna di Komputer
• Berhubungan dengan sistem warna RGB
• Komputer akan mengatur konversi ke
sistem CMYK
• Dalam kondisi ideal, ada jumlah bit
tertentu untuk warna merah, hijau dan biru
• Pada sistem yang mendukung 16.7 juta
warna (24bit), 8 bit dialokasikan untuk
masing-masing warna
Representasi dan Manipulasi
Warna di Komputer
• Pada sistem yang memiliki jumlah warna
kurang dari itu (65k warna = 16bit, 256
warna = 8bit, 4096 warna = 12 bit, 16
warna = 4 bit), maka jumlah RGB yang
bisa direpresentasikan terbatas
• Beberapa manipulasi warna yang bisa
dilakukan adalah :
– Mengambil komponen warna tertentu
– Mempergelap/memperterang gambar
– Membuat efek transparan
Memori Untuk Warna
• Sebesar resolusi layar dikalikan dengan
jumlah bit per pixel.
• Contoh : layar 1024 x 768 24 bit (true
color)
• 24bit = 3byte
• Jumlah bit per pixel = 3 byte
• membutuhkan memori 768 x 1024 x 3byte
= 2359296 byte = 2304 kb = 2.25 mb
• Memori untuk gambar berwarna > gambar
hitam putih
Iluminasi dan Shading
• Iluminasi
– Proses pemberian cahaya pada objek
– Proses menghitung intensitas titik pada suatu
permukaan
• Shading
– Proses untuk memperhitungkan bayangan
objek
– Penggunaan intensitas untuk memberi
bayangan pada polygon
Iluminasi
• Pencahayaan – lokal atau global
• Lokal – tidak memperhitungkan objek lain di
sekitar yang mungkin akan memberikan
pengaruh cahaya pada gambar (refleksi, cahaya
tambahan) jadi seolah-olah setiap benda hanya
terpengaruh oleh sumber cahaya
• Global – satu sumber cahaya untuk semua
objek yang terlihat yang menyinari semua objek.
Model ini lebih kompleks karena
memperhitungkan refleksi dari objek lain
Model Iluminasi
• Menyatakan komponen cahaya yang
dipantulkan atau diterima oleh sebuah
permukaan
• Tiga komponen warna dasar :
– Ambient
– Diffuse
– Specular
Ambient Reflected Light
• Sumber cahaya tidak berarah
• Hasil dari pemantulan berulang dari lingkungan
sekitar
• Konstanta refleksi ambient
– besarnya antara 0 sampai 1
– menentukan besarnya cahaya ambient yang
dipantulkan oleh objek
– 0 – menyerap semua, 1 – memantulkan semua
– Merupakan property atau sifat dari suatu bahan
Ambient Reflected Light
• Persamaan iluminasi ambient :
– I = Ka.Ia
– I : intensitas cahaya yang dipantulkan
– Ka : koefisien
– Ia : intensitas ambient
Diffuse Light
• Cahaya yang dipantulkan atau dipancarkan dari
suatu titik dengan intensitas yang sama ke
segala arah
• Contoh : cahaya yang dipantulkan dari
permukaan polos seperti kertas atau dinding
• Refleksi difusi dimodelkan dengan hukum
Lambert yang menyatakan bahwa kecerahan
hanya bergantung pada sudut antara arah
sumber cahaya dan bidang normal permukaan
Hukum Lambert
• Hukum I : Iluminasi suatu permukaan yang
diterangi oleh cahaya vertikal terhadap sumber
cahaya sebanding dengan akar kuadrat antara
permukaan dan sumber cahaya
• Hukum II : JIka cahaya bertemu di permukaan
pada sudut tertentu, maka iluminasinya
sebanding dengan kosinus antara sudut itu
dengan permukaan normal
• Hukum III : intensitas iluminasi berkurang secara
eksponensial selaras dengan jarak jika melewati
medium yang menyerap
Hukum Lambert
I k I θ d p = × cos
θ = sudut antara normal permukaan dan
vektor cahaya
Ip = intensitas sumber cahaya
Kd = koefisien diffuse reflection
Cahaya Specular
• Menghasilkan efek highlight akibat refleksi
• Memberi efek mengkilap pada objek

titik

/*Program : Tititk.c*/

#include
typedef struct {int absis; int ordinat;}Titik;

/*Prototipe*/
void setTitik (int x,int y,Titik *T);

main () {
Titik A,B;

/*Algoritma*/
clrscr();
setTitik(3,4,&A);
printf("ordinat : %d\n",A.ordinat);
setTitik(7,8,&B);
printf("absis : %d",B.absis);
getch();
}
/*Body Prototipe*/
void setTitik (int x,int y,Titik *T)
{ /*kamus lokal*/

/*algoritma*/
(*T).absis = x;
(*T).ordinat = y;
}

tabint

#include
typedef struct
{ int isi[101]; /*penampung elemen tabel*/
int len; /*banyak elemen yang dipakai*/
}TabInt;
typedef enum {
false,
true
}boolean;

/*procedure Buat(output T:TabInt)*/
void Buat(TabInt *T);
/*procedure Entri(input/output T:TabInt, input N:integer)*/
void Entri(TabInt *T, int N);
/*procedure Cetak(input T:TabInt)*/
void Cetak(TabInt T);
/*procedure SeqSearchX1(input T : TabInt, input x : integer, outpout IX : integer)*/
void SeqSearchX1(TabInt T, int x, int *IX);

void SeqSearch2(TabInt T, int x, int *IX);




main()
{ /*kamus*/
TabInt A;
int posisi;
/*ALGORITMA*/
clrscr();
Buat(&A);
Entri(&A,5);
Cetak(A);
SeqSearchX1(A, 2, &posisi);
printf("\nSeqSearchX1");
printf("\nindeks pencarian = %d", posisi);
SeqSearch2(A, 4, &posisi);
printf("\nSeqSearch2");
printf("\nindeks pencarian = %d", posisi);
getch();
return 0;
}
/*BODY PROTOTIPE*/
void Buat(TabInt *T)
{ /*kamus lokal*/
int i;
/*algoritma*/
for(i=1;i<=100;i++)
{ (*T).isi[i] = 0;
}
}
void Entri(TabInt *T, int N)
{ /*kamus lokal*/
int i;
/*algoritma*/
(*T).len = N;
for(i=1;i<=(*T).len;i++)
{ printf("\nelemen ke-%d : ",i);
scanf("%d",&(*T).isi[i]);
}
}
void Cetak(TabInt T)
{ /*kamus lokal*/
int i;
/*algoritma*/
for(i=1;i<=(T).len;i++)
{ printf("\nelemen ke-%d = %d",i,(T).isi[i]);
}
}

void SeqSearchX1(TabInt T, int x, int *IX)
{ /*kamus lokal*/
int i;
/*algoritma*/
i=1;
while(i {
i++;
}
/**/
if(T.isi[i]==x)
{
*IX=i;
}
else
{
*IX=0;
}
}
void SeqSearch2(TabInt T, int x, int *IX)
{
/*kamus lokal*/
int i;
boolean ketemu;
/*algoritma*/
ketemu=false;
i=1;

while(i<=T.len && !ketemu)
{
if(T.isi[i]==x)
{ ketemu = true;
}
else
{i++;}
}
if(ketemu)
{*IX=i;}
else
{*IX=0;}
}










tabint

/*Nama File :*/
/*Deskripsi :*/
/*Pembuat :*/
/*Tanggal Buat :*/
#include
typedef struct
{ int isi[101]; /*penampung elemen tabel*/
int len; /*banyak elemen yang dipakai*/
}TabInt;
/*procedure Buat(output T:TabInt)*/
void Buat(TabInt *T);
/*procedure Entri(input/output T:TabInt, input N:integer)*/
void Entri(TabInt *T, int N);
/*procedure Cetak(input T:TabInt)*/
void Cetak(TabInt T);
/*procedur MaxSort (input/output T : TabInt)*/
void MaxSort(TabInt *T);
/*procedur MinSort (input/output T : TabInt)*/
void MinSort(TabInt *T);

void BubbleSort(TabInt *T);



main()
{ /*kamus*/
TabInt A;

clrscr();
Buat(&A);
Entri(&A,5);
Cetak(A);
MaxSort(&A);
printf("\nMaxSort");
Cetak(A);
MinSort(&A);
printf("\nMinSort");
Cetak(A);
BubbleSort(&A);
printf("\nBubbleSort");
Cetak(A);
getch();
}
/*BODY PROTOTIPE*/
void Buat(TabInt *T)
{ /*kamus lokal*/
int i;
/*algoritma*/
for(i=1;i<=100;i++)
{ (*T).isi[i] = 0;
}
}
void Entri(TabInt *T, int N)
{ /*kamus lokal*/
int i;
/*algoritma*/
(*T).len = N;
for(i=1;i<=(*T).len;i++)
{ printf("\nelemen ke-%d : ",i);
scanf("%d",&(*T).isi[i]);
}
}
void Cetak(TabInt T)
{ /*kamus lokal*/
int i;
/*algoritma*/
for(i=1;i<=(T).len;i++)
{ printf("\nelemen ke-%d = %d",i,(T).isi[i]);
}
}
void MaxSort(TabInt *T)
{ /*kamus lokal*/
int pass, i, imax, temp;
/*algoritma*/
for(pass=1;pass<=(*T).len-1;pass++)
{
imax = pass;

for(i=pass+1;i<=(*T).len;i++)
{ if ((*T).isi[i] > (*T).isi[imax])
imax = i;
}

temp=(*T).isi[pass];
(*T).isi[pass] = (*T).isi[imax];
(*T).isi[imax] = temp;
}
}
void MinSort(TabInt *T)
{ /*kamus lokal*/
int pass, i, imin, temp;
/*algoritma*/
for(pass=1;pass<=(*T).len-1;pass++)
{
imin = pass;

for(i=pass+1;i<=(*T).len;i++)
{ if ((*T).isi[i] < (*T).isi[imin])
imin = i;
}

temp=(*T).isi[pass];
(*T).isi[pass] = (*T).isi[imin];
(*T).isi[imin] = temp;
}
}

void BubbleSort(TabInt *T)
{ /*kamus lokal*/
int pass, i, temp;
/*algoritma*/
for(pass=1;pass<=(*T).len-1;pass++)
{
for(i=2;i<=(*T).len;i++)
{ if((*T).isi[i]< (*T).isi[i-1])
{ temp = (*T).isi[i];
(*T).isi[i]=(*T).isi[i-1];
(*T).isi[i-1]=temp;
}
}
}
}

stack

#include
#include

typedef struct
{ int wadah [5];
int Top; }Stack;
typedef enum
{ false,
true }boolean;
void CreateStack(Stack *S);
boolean IsFullStack(Stack S);
boolean IsEmptyStack(Stack S);
void push(Stack *S, char E);
void pop(Stack *S, char *E);

main()
{ /*kamus*/
Stack A; char x;

/*ALGORITMA*/
clrscr();
CreateStack(&A);
push(&A,'D');
push(&A,'C');
pop(&A,&x);
printf("%c",x);

getch();

}


/*BODY PROTOTIPE*/
void CreateStack(Stack *S)
{/**/
int i;
/**/
Top(*S)==0;
for(i=1;i<=5;i++)
{(*S).wadah[i]=0;}
}

boolean IsFullStack(Stack S)
{ if(Top(S)==5)
{return true;}
else
{return false;}
}

boolean IsEmptyStack(Stack S)
{return Top(S)==0;}

void push(Stack *S, char E)
{ if(!IsFullStack(*S))
{Top(*S)==Top(*S)+1;}

(*S).wadah[Top(*S)]=E;
}

void pop(Stack *S, char *E)
{ if(!IsEmptyStack(*S))
{E=(*S).wadah[Top(*S)];}

(*S).wadah[Top(*S)]=0;
Top(*S)==Top(*S)-1;
}

queue

#include
#include
#define Head(Q) (Q).Head
#define Tail(Q) (Q).Tail

typedef struct
{ int Head; int Tail;
int Isi [6]; }Queue;
typedef enum
{ false,
true }boolean;
void CreateQueue (Queue *Q);
/*membentuk antrian kosong*/
boolean IsEmptyQueue (Queue Q);
/*mengecek apakah antrian kosong*/
boolean IsFullQueue (Queue Q);
/*mengecek apakah antrian penuh*/
void EnQueue (Queue *Q, int E);
/*memasukkan elemen E ke dalam antrian Q*/
void DeQueue (Queue *Q, int *E);
/*mengeluarkan elemen E dari antrian Q*/
void PrintQueue (Queue Q);

main()
{/*kamus*/
Queue A; int x;
/*algoritma*/
clrscr();
CreateQueue(&A);
PrintQueue(A);
printf("\n\nEnQueue\n");
EnQueue(&A,1); PrintQueue(A);
EnQueue(&A,3); PrintQueue(A);
EnQueue(&A,6); PrintQueue(A);
EnQueue(&A,2); PrintQueue(A);
EnQueue(&A,8); PrintQueue(A);
printf("\n\nDeQueue\n");
DeQueue(&A,&x); PrintQueue(A);
DeQueue(&A,&x); PrintQueue(A);
DeQueue(&A,&x); PrintQueue(A);
DeQueue(&A,&x); PrintQueue(A);
DeQueue(&A,&x); PrintQueue(A);

getch();
}

/*Body Prototipe*/
void CreateQueue (Queue *Q )
{ /*kamus lokal*/
int i;
/*algoritma*/
Head(*Q)=0;
Tail(*Q)=0;
for(i=1;i<=5;i++)
{(*Q).Isi[i]=0;}
}
boolean IsEmptyQueue (Queue Q)
{ return((Head(Q)==0) && (Tail(Q)==0));

}
boolean IsFullQueue (Queue Q)
{ return((Head(Q)==1) && (Tail(Q)==5));

}
void EnQueue (Queue *Q, int E)
{ if (IsEmptyQueue(*Q))
{Head(*Q)=1;}
if (!IsFullQueue(*Q))
{Tail(*Q)++;
(*Q).Isi[Tail(*Q)]=E;
}
}
void DeQueue (Queue *Q, int *E)
{ /*kamus lokal*/
int i;
/*algoritma*/
if(!IsEmptyQueue(*Q))
{ (*E)=(*Q).Isi[Head(*Q)];
for(i=1;i {(*Q).Isi[i]=(*Q).Isi[i+1];}
(*Q).Isi[Tail(*Q)]=0;
Tail(*Q)=Tail(*Q)-1;
}
if(Tail(*Q)==0)
{Head(*Q)==0;}
}
void PrintQueue (Queue Q)
{/*kamus lokal*/
int i;
/*algoritma*/
printf("\ncetak antrian\n");
for(i=1;i<=5;i++)
{printf("\t%d",Q.Isi[i]);}
}


dlist

#include

#define first(L) (L).first
#define info(P) (P)->info
#define prev(P) (P)->prev
#define next(P) (P)->next
#define nil NULL

typedef int InfoType;
typedef struct tNode *address;
typedef struct tNode {address prev; InfoType info; address next;} Node;
typedef struct {address first;} DList;
typedef enum {false, true} boolean;

void CreateDList (DList *L)
{ first(*L)=nil; }
boolean IsEmptyDList (DList L)
{ return (first(L)==nil); }
void PrintList (DList L)
{ address P;
if(IsEmptyDList(L))
{printf("\nlist kosong");}
else
{ printf("\nCetak List");
P=first(L);
do
{printf("\t%d",info(P));
P=next(P);
}while(P!=nil);
}
}
void Alokasi (address *P)
{(*P) = (address) malloc(sizeof(Node));}
void Dealokasi (address P)
{free(P);}

void Insertfirst (DList *L, InfoType E)
{ address P;
Alokasi(&P);
if(P!=nil)
{ info(P)=E;
prev(P)=nil;
if(IsEmptyDList(*L))
{ next(P)=nil; }
else
{ next(P)=first(*L);
prev(first(*L))=P;
}
first(*L)=P;
}
}
void Insertlast (DList *L, InfoType E)
{ address P, last;
Alokasi(&P);
if(P!=nil)
{ info(P)=E;
prev(P)=nil;
if(IsEmptyDList(*L))
{ next(P)=nil; }
else
{ next(P)=first(*L);
last=first(*L);
while(next(last)!=nil)
{ last=next(last); }
prev(first(*L))=P;
}

}

}
void Deletefirst (DList *L, InfoType *E)
{ address P;
if(IsEmptyDList(*L))
{ (*E)=0; }
else
{ P=first(*L);
(*E)=info(P);
first(*L)=next(P);
if(first(*L)!=nil)
{ prev(first(*L))=nil; }
next(P)=nil;
Dealokasi(P);
}

printf("\n\nhapuslist");
}
void Deletelast (DList *L, InfoType *E)
{ address P;
if(IsEmptyDList(*L))
{ (*E)=0; }
else
{ P=first(*L);
while(next(P)!=nil)
{ P=next(P); }
(*E)=info(P);
next(prev(P))=nil;
prev(P)=nil;
Dealokasi(P);
}

printf("\n\nhapuslist");
}


/*ALGORITMA*/
main()
{ DList A; int x;
clrscr();
CreateDList(&A); PrintList(A);
Insertfirst(&A,8); PrintList(A);
Insertfirst(&A,1); PrintList(A);
Insertfirst(&A,5); PrintList(A);
Insertlast(&A,7); PrintList(A);
Deletefirst(&A,&x); PrintList(A);
Deletelast(&A,&x); PrintList(A);
Deletefirst(&A,&x); PrintList(A);
getch();
}

list

#include

#define first(L) (L).first
#define info(P) (P)->info
#define next(P) (P)->next
#define nil NULL

typedef int InfoType;
typedef struct tNode *address;
typedef struct tNode {InfoType info; address next;} Node;
typedef struct {address first;} List;
typedef enum {false, true} boolean;

void CreateList (List *L)
{ first(*L)=nil; }
boolean IsEmptyList (List L)
{ return (first(L)==nil); }
void PrintList (List L)
{ address P;
if(IsEmptyList(L))
{printf("\nlist kosong");}
else
{ printf("\nCetak List");
P=first(L);
do
{printf("\t%d",info(P));
P=next(P);
}while(P!=nil);
}
}
void Alokasi (address *P)
{(*P) = (address) malloc(sizeof(Node));}
void Dealokasi (address P)
{free(P);}

void InsertList (List *L, InfoType E)
{ address P;
Alokasi(&P);
if(P!=nil)
{ info(P)=E;
next(P)=first(*L);
first(*L)=P;
}
}
void DeleteList (List *L, InfoType *E)
{ address P;
if(!IsEmptyList(*L))
{ P=first(*L);
(*E)=info(P);
first(*L)=next(P);
Dealokasi(P);
printf("\n\nhapus list");
}
}


/*ALGORITMA*/
main()
{ List A; int x;
clrscr();
CreateList(&A); PrintList(A);
InsertList(&A,8); PrintList(A);
InsertList(&A,1); PrintList(A);
InsertList(&A,5); PrintList(A);
DeleteList(&A,&x); PrintList(A);
DeleteList(&A,&x); PrintList(A);
DeleteList(&A,&x); PrintList(A);
getch();
}