[Type your address]  [Type your phone number]  [Type your e-mail address]

Admin
KELOMPOK V
1. Ade Mas Bagus :
52007002
2. Aksa Badi : 52007003
3. Edwin Wirencius : 52007012
4. Ferdinand Magaline :
52007020
5. Herry Yusuf :
52007027

i
 Kata Pengantar
Pertama-tama kami ingin mengucapkan terima kasih kepada Tuhan
Yang Maha Esa, karena hanya dengan bimbingannya maka kami dapat
segera menyeleisaikan makalah ini dengan judul : “Perubahan Point 3D
Menjadi Vektor 3D dan Implementasi”.

Tugas ini merupakan tugas wajib untuk diselesaikan, demi

kelancaran pembelajaran tentang grafika komputer. Grafika komputer
pada dasarnya adalah suatu ilmu bidang komputer yang mempelajari
cara-cara meningkatkan dan memudahkan komunikasi antara manusia
dengan mesin (komputer) dengan membangkitkan, menyimpan, dan
memanipulasi gambar model suatu objek menggunakan komputer. Grafika
komputer memungkinkan kita untuk berkomunikasi lewat gambar-gambar,
bagan-bagan dan diagram-diagram. Adapun tujuan akhir dari tugas ini
adalah agar pembaca dapat mempelajari system koordinat 3D, konversi
point 3D menjadi vector 3D dan sebaliknya serta
mengimplementasikannya.

Kami menyadari masih banyak kekurangan pada makalah ini, maka

dari itu kami meminta bantuan dari pembaca sekalian untuk bisa
mengkritik makalah untuk pengembangan yang lebih baik lagi. Akhirnya,
kami mengucapkan terima kasih pada semua pihak yang telah membantu
kami menyeleisaikan makalah ini.

Makassar, April 2009

ii
 KELOMPOK V

Daftar Isi
Kata Pengantar ..................................................................... i

Daftar Isi ................................................................................ ii

Bab I. Pendahuluan ................................................................ 1

Bab II. Pembahasan

A. Sistem koordinat 3D................................................... 4
B. Titik 3D...................................................................... 4
C. Vector 3D................................................................... 5
D. Matriks 3D................................................................. 5
E. Proses Transformasi Objek 3D.................................. 6
F. Perubahan Titik Menjadi Vektor................................ 7
G. Perubahan Vektor Menjadi Titik................................ 7
H. Titling......................................................................... 8
I. Visible dan Invisible................................................... 9
J. Implementasi.............................................................. 11

Bab III. Kesimpulan................................................................ 18

Daftar Pustaka........................................................................ 19

iii
 Bab I. Pendahuluan
Grafika komputer pada dasarnya adalah suatu bidang ilmu komputer
yang mempelajari cara-cara untuk meningkatkan dan memudahkan
komunikasi antara manusia dengan mesin (komputer) dengan jalan
membangkitkan, menyimpan, dan memanipulasi gambar model suatu
objek menggunakan komputer. Grafika komputer memungkinkan kita
untuk berkomunikasi lewat gambar-gambar, bagan-bagan, dan diagram-
diagram.

Grafika komputer dikembangkan melalui suatu sistem operasi yang

berbasis GUI (Graphical User Interface). Graphical User Interface (GUI),
dalam hubungannya dengan sains komputer, adalah suatu antarmuka
berbentuk tampilan yang memungkinkan seorang user untuk memilih
perintah, menjalankan program, melihat serangkaian file dan memilih opsi
lain dengan menunjukkan representasi gambar (icon) ataupun melalui
sejumlah menu pada layar komputer.

Beberapa kemajuan utama dalam computer grafik 3D:

 Flat shading : suatu teknik shades masing-masing polygon dari suatu
objek berdasarkan pada polygon “normal” dan posisi serta intensitas
sumber cahaya.
 Gouraud shading : ditemukan oleh Henri Gouraud pada tahun 1971
dengan teknik resource-conscious yang digunakan untuk menirukan
shade dengan permukaan lembut dan penyisipan warna puncak
antarpermukaan polygon.
 Texture mapping : suatu teknik untuk menirukan detail permukaan
dengan pemetaan gambar (tekstur) menjadi polygons.
 Phong shading : ditemukan oleh Bui Tuong Phong; suatu teknik
shading yang lembut yang mendekati pencahayaan curved-surface

1
 dengan penyisipan puncak normal dari polygon antarpermukaan;
model pencahayaan meliputi glossy reflection dengan suatu tingkatan
permukaan yang halus.
 Bump mapping : ditemukan oleh Jim Blinn, suatu teknik normal-
perturbation yang digunakan untuk menirukan permukaan yang tidak
rata atau mengerut.
 Ray Tracing : suatu metode berdasarkan pada prinsip fisik dari ilmu
optic geometris yang bisa menirukan pantulan berulang dan
transparan.
 Radiosity : suatu teknik untuk global illumination yang menggunakan
teori perpindahan radiatif untuk menirukan iluminasi secara tidak
langsung (yang dicerminkan).
Sampai saat ini, kita hanya membahas grafik dua dimensi (grafik
2D). Pada kenyataannya, objek yang ingin ditampilkan pada layar
tampilan harus bisa menunjukkan keadaaan objek sebenarnya. Dengan
kata lain, kita harus berurusan dengan grafik tiga dimensi (grafik 3D).
sebagai contoh, system perancangan terbantu computer (Computer Aided
Design = CAD) memungkinkan pemakai untuk memanipulasi model
komponen-komponen mesinm badan mesin, pesawat terbang, dan lain-
lain, yang secara keseluruhan harus dinyatakan seperti apa yang akan
terbentuk. Terapan-terapan grafik 3D berbeda dengan terapan-terapan
grafik 2D, tidak hanya karena penambahan dimensi dari dua menjadi tiga,
tetapi yang lebih utama adalah cara menampilkan suatu realita (realism)
dari objek yang sebenarnya ke layar tampilan. Dalam program simulasi,
misalnya, semakin tinggi derajat realita yang bisa disajikan, program
simulasi tersebut menjadi lebih menarik.

Penampilan citra yang realities dari objek 3D pada layar tampilan

2D menimbulkan beberapa persoalan yang harus ditangani. Beberapa
persoalan yang segera terlihat, antara lain adalah bagaimana kedalaman,
yaitu dimensi ketiga bisa ditampilkan pada layar tampilan, perubahan point

2
ke vector dan sebaliknya. Pertanyaan lain yang mungkin timbul adalah
bagaimana membuat permodelan dari objek 3D sehingga computer bisa
membangkitkan citra yang diinginkan. Beberapa teknik telah
dikembangkan untuk menjawab pertanyaan-pertanyaan di atas, dan
beberapa di antaranya akan dijelaskan di bagian berikut.

3
 Bab II. Pembahasan
A. Sistem Koordinat 3D
Sistem koordinat 3D, atau lebih dikenal dengan system koordinat
ruang, mempunyai 3 parameter. Yaitu x, y dan z yang dapat dilihat
seperti gambar berikut :

P(x,y,z)

Hadirnya sumbu z menyebabkan system koordinat ini menjadi lebih

hidup karena efek jauh dekat menjadi semakin terlihat. Hal ini bias di
lihat dari gambar diatas yang menunjukkan bahwa nilai z yang
semakin besar akan membuat objek akan semakin jauh dari
pengamat.

B. Titik 3D
Elemen dasar dari grafika computer dalam grafik 3D adalah titik 3D.
Titik 3D mempunyai tiga nilai, yaitu x, y, dan z dan dinyatakan
P(x,y,
z)

4
 Struktur data dari titik 3D
didefinisikan
struct Point { dengan :
float x, y,
z;
};

C. Vector 3D
Elemen dasar lainnya adalah vector 3D, dimana vector 3D berupa
array mempunyai 4 elemenV[0]
v[0], =
v[1], V[2], v[3], dimana :
x
V[1] =
y
V[2] =

Struktur struct vector { data dari vector 3D

didefenisikan float v[4]; dengan :
};

D.Matriks 3D
Elemen dasar untuk operasi
objek dalam struct matriks { grafika computer adalah
matriks. float Dimana pada objek 3D
m[4][4]; menggunakan matriks
berukuran 4X4.
};
Struktur data dari matrik 3D didefenisikan dengan :

5
E. Proses Transformasi Objek 3D
Struktur data titik 3D digunakan untuk keperluan menggambar
objek ke layar computer karena nilainya sudah disesuaikan dengan
system koordinat pada layar computer. Sedangkan struktur data
vector digunakan untuk melakukan transformasi terhadap objek.

Sehingga bila objek gambar di transformasikan, hal yang harus

dilakukan adalah :
1. Menggubah struktur data titik ke struktur data vector.
2. Menentukan dan menghitung transformasi.
3. Mengubah kembali struktur data vector ke struktur data titik.
Pada langkah ini, kita dapat menggunakan 2 cara, yaitu :
a. Mengubah struktur data vector 3D menjadi titik 3D.
b. Mengubah Struktur data vector 3D menjadi titik 2D, dengan
mengabaikan sumbu z.
4. Menggambar objek.

Skema Perubahan Struktur Data Titik dan Vektor :

TITIK 3D

v[0] ← x
v[1] ← y
v[2] ← z
v[3] ← 1

VEKTOR
6 3D
F. Perubahan Titik Menjadi Vector
Seperti telah di bahas diatas, proses transformasi tidak dapat
dilakukan terhadap data titik, tetapi dilakukan terhadap data vector
sehingga untuk mengolah atau melakukan transformasi terlebih
dahulu data titik 3D diubah menjadi vector 3D dan kemudian
ditransformasikan. Implementasi :

vektor point2vektor(point
pnt) {
vektor vec;
vec.v[0] = pnt.x;
vec.v[1] = pnt.y;
vec.v[2] = pnt.z;
vec.v[3] = 1;
return vec;
G. }
Perubahan Vector Menjadi Titik

1. Vector 3D Menjadi Titik 3D

Konversi vector 3D menjadi titik 3D adalah perubahan struktur
data dari vector 3D yang sudah diolah dengan transformasi menjadi
struktur data titik 3D agar siap di gambar kelayar computer.
Implementasi :

point vektor2point(vektor
vec) {
point pnt;
pnt.x = vec.v[0];
pnt.y = vec.v[1];
pnt.z = vec.v[2];
return pnt;
}

7
 2. Vector 3D menjadi Titik 2D
Konversi vector 3D menjadi titik 2D adalah perubahan struktur
data dari vector 3D yang sudah diolah dengan transformasi menjadi
struktur data titik 2D agar siap di gambar kelayar computer. Hal ini
karena bagaimanapun juga layar computer adalah 2D.

point2D vektor2point2D(vektor
vec) {
point2D pnt;
pnt.x = vec.v[0];
pnt.y = vec.v[1];
return pnt;
}

H.Titling
Seperti yang kita ketahui bersama bahwa layar computer
merupakan 2D, maka untuk menggambar objek 3D maka harus
dilakukan rotasi. Sumbu Z adalah sumbu yang searah dengan garis
mata sehingga di perlukan transformasi untuk menampilkan sumbu
ini. Untuk hal itu maka di perlukan rotasi sumbu.

Dalam titling, kita harus melakukan rotasi sebesar θ (theta)

terhadap sumbu X dan rotasi sebesar - θ (theta) terhadap sumbu Y.
Sehingga untuk menggunakan titling ini, kita harus mengetahui
terlebih dahulu matriks rotasi terhadap sumbu X.

Matriks rotasi terhadap sumbu X :

8
 Matriks rotasi terhadap sumbu Y :

Sehingga untuk menggunakan titling, harus mengalikan matriks

rotasi tersebut. Untuk contoh penggunaan titling dapat di lihat pada
pembahasan implementasi.

I. Visible dan Invisible

Visible dan invisible menyatakan apakah suatu face terlihat (visible)
atau tidak terlihat (invisible). Pada objek 3D tidak semua face dapat
terlihat, karena terdapat beberapa face yang berada di bagian
belakang dan terhalang oleh face lainnya. Untuk menyatakan face
visible dan invisible digunakan vector normal pada face tersebut.
Suatu face visible jika arah z pada vector normal positif, dan face
invisible jika arah z pada vector normal adalah negative.

1. Vektor Normal
Vektor normal adalah vector yang arahnya tegak lurus dari
face. Vektor normal dapat diperoleh dari hasil perkalian silang
(cross product) dua vector tepi dari face.

c=a χ
b

9
2. Cross Product
Perkalian silang (cross product) merupakan perkalian dari
vector a=(ax, ay, az) dan vector b=(bx, by, bz), dimana :
• Cross Product disimbolkan dengan operator ^
• a=(ax, ay, az) diubah sesuai struktur data vector 3D menjadi
(a.v[0], a.v[1], a.v[2])
• b=(bx, by, bz) diubah sesuai struktur data vector 3D menjadi
(b.v[0], b.v[1], b.v[2])
• Di defenisikan dengan :

. .

Sehingga :
• c.v[0] = ay bz - az by
• c.v[1] = az bx - ax bz
• c.v[2] = ax by - ay bx
• c.v[3] = 1

vektor cross (vektor a, vektor b) {

vektor c;
c.v[0] = a.v[1]*b.v[2]-
a.v[2]*b.v[1];
c.v[1] = a.v[2]*b.v[0]-
a.v[0]*b.v[2];
c.v[2] = a.v[0]*b.v[1]-
a.v[1]*b.v[0];
c.v[3] = 1;
Implementasi Cross Product :

10
 3. Cara Menggambar Face Visible dan Invisible
Untuk menggambarkan face visible dan face invisible maka
harus dilakukan penggambaran sebanyak dua kali, yaitu :
 Pertama, digambar terlebih dahulu face-face yang invisible
yaitu arah z pada vector normal adalah positif, dengan
menggunakan warna yang redup.
 Kedua, digambar face-face yang visible yaitu arah z pada
vector normal adalah negative, dengan menggunakan warna
yang lebih terang.

J. Implementasi Program
#include "glut.h"
#include <math.h>

struct point {
float x,y,z;
};

struct vektor {
float v[4];
};

struct matriks {
float m[4][4];
};

struct face {
int jumtitikons;
int indextitik[40];
};

struct objek {
int jumtitik;
point titik[40];
int jumsisi;
face sisi[30];
};

matriks mat;
float theta=0.5;

vektor point2vektor(objek balok, int i) {

vektor vec;
vec.v[0] = balok.titik[i].x;
vec.v[1] = balok.titik[i].y;
vec.v[2] = balok.titik[i].z;
vec.v[3] = 1;
return vec;

11
}

point vektor2point(vektor vec) {

point pnt;
pnt.x = vec.v[0];
pnt.y = vec.v[1];
pnt.z = vec.v[2];
return pnt;
}

matriks identitas(void) {
int i,j;
matriks mat;
for (i=0;i<4;i++) {
for (j=0;j<4;j++) {
if (i==j)
mat.m[i][j] = 1;
else
mat.m[i][j] = 0;
}
}
return mat;
}

matriks translasi(float dx, float dy, float dz) {

matriks trans = identitas();
trans.m[0][3] = dx;
trans.m[1][3] = dx;
trans.m[2][3] = dx;
return trans;
}

matriks rotasiX(float theta) {

matriks rotate = identitas();
float cs = cos(theta);
float sn = sin(theta);

rotate.m[1][1] = cs;
rotate.m[1][2] = -sn;
rotate.m[2][1] = sn;
rotate.m[2][2] = cs;

return rotate;
}

matriks rotasiY(float theta) {

matriks rotate = identitas();
float cs = cos(theta);
float sn = sin(theta);

rotate.m[0][0] = cs;
rotate.m[0][2] = sn;
rotate.m[2][0] = -sn;
rotate.m[2][2] = cs;

return rotate;

12
}

matriks rotasiZ(float theta) {

matriks rotate = identitas();
float cs = cos(theta);
float sn = sin(theta);

rotate.m[0][0] = cs;
rotate.m[0][1] = -sn;
rotate.m[1][0] = sn;
rotate.m[1][2] = cs;

return rotate;
}

vektor kali (matriks mat, vektor b) {

int i,j;
vektor c;
for (i=0;i<4;i++) {
c.v[i] = 0;
for (j=0;j<4;j++) {
c.v[i]+= mat.m[i][j] * b.v[j];
}
}
return c;
}

matriks kalim (matriks a, matriks b) {

int i,j,k;
matriks c;
for (i=0;i<4;i++) {
for (j=0;j<4;j++) {
c.m[i][j] = 0;
for (k=0;k<4;k++) {
c.m[i][j]+=a.m[i][k] * b.m[k][j];
}
}
}
return c;
}

matriks titling = kalim(rotasiX(theta),rotasiY(-theta));

vektor cross (vektor a, vektor b) {

vektor c;
c.v[0] = a.v[1]*b.v[2]-a.v[2]*b.v[1];
c.v[1] = a.v[2]*b.v[0]-a.v[0]*b.v[2];
c.v[2] = a.v[0]*b.v[1]-a.v[1]*b.v[0];
c.v[3] = 1;
return c;
}

void DrawPolygon(objek obj)

{
int i,j;
float r,g,b;

13
 for(i=0;i<obj.jumsisi;i++)
{
r=1.0f; g=0.0f; b=0.0f;
glBegin(GL_LINE_LOOP);
if (i==0) { r=1.0f; g=0.0f; b=0.0f; }
if (i==1) { r=0.0f; g=1.0f; b=0.0f; }
if (i==2) { r=0.0f; g=0.0f; b=1.0f; }
if (i==3) { r=1.0f; g=1.0f; b=0.0f; }
if (i==4) { r=1.0f; g=0.0f; b=1.0f; }
if (i==5) { r=0.0f; g=1.0f; b=1.0f; }
if (i==6) { r=0.5f; g=0.0f; b=1.0f; }
if (i==7) { r=0.5f; g=0.5f; b=0.5f; }

glColor3f(r,g,b);
for(j=0;j<obj.sisi[i].jumtitikons;j++)
{
glVertex3f(obj.titik[obj.sisi[i].indextitik[j]].x,

obj.titik[obj.sisi[i].indextitik[j]].y,
obj.titik[obj.sisi[i].indextitik[j]].z);
}
glEnd();
}
}

void DrawPolygon2D(objek obj)

{
int i,j;
float r,g,b;

for(i=0;i<obj.jumsisi;i++)
{
r=1.0f; g=0.0f; b=0.0f;
glBegin(GL_LINE_LOOP);
if (i==0) { r=1.0f; g=0.0f; b=0.0f; }
if (i==1) { r=0.0f; g=1.0f; b=0.0f; }
if (i==2) { r=0.0f; g=0.0f; b=1.0f; }
if (i==3) { r=1.0f; g=1.0f; b=0.0f; }
if (i==4) { r=1.0f; g=0.0f; b=1.0f; }
if (i==5) { r=0.0f; g=1.0f; b=1.0f; }
if (i==6) { r=0.5f; g=0.0f; b=1.0f; }
if (i==7) { r=0.5f; g=0.5f; b=0.5f; }

glColor3f(r,g,b);
for(j=0;j<obj.sisi[i].jumtitikons;j++)
{

glVertex2f(obj.titik[obj.sisi[i].indextitik[j]].x,

obj.titik[obj.sisi[i].indextitik[j]].y);
}
glEnd();
}
}

14
void gambarbalok() {
int i;
vektor hasil,HslKali;
objek Tbalok;
point HslTitik;
mat = titling;

objek balok =
{8,{{10,15,30},{30,15,30},{30,15,10},{10,15,10},{10,30,30},{30
,30,30},{30,30,10},{10,30,10}},

6,{{4,{0,1,5,4}},{4,{3,2,6,7}},{4,{0,3,7,4}},{4,{1,2,6,5}},{4,
{0,1,2,3}},{4,{4,5,6,7}}}};

for (i=0;i<8;i++) {
hasil = point2vektor(balok,i);
HslKali = kali(mat,hasil);
HslTitik = vektor2point(HslKali);
balok.titik[i] = HslTitik;
}

DrawPolygon(balok);
// DrawPolygon2D(balok);

Tbalok = balok;

for (i=0;i<8;i++) {
hasil = point2vektor(balok,i);
// HslKali = kali(rotasiZ(theta),hasil);
// HslKali = kali(rotasiY(-theta),hasil);
// HslKali = kali(rotasiX(theta),HslKali);
// HslKali = kali(mat,hasil);
// HslKali = kali(translasi(50,50,50),HslKali);
HslKali = kali(translasi(50,50,50),hasil);
HslTitik = vektor2point(HslKali);
Tbalok.titik[i] = HslTitik;
}

DrawPolygon2D(Tbalok);
// DrawPolygon(Tbalok);

void gambarprisma() {
int i;
vektor hasil,HslKali;
objek Tprisma;
point HslTitik;
mat = titling;

objek prisma = {5,{{0,100,0},{100,0,0},{0,0,100},{-

100,0,0},{0,0,-100}}, 5, {{3,{0,1,2}},{3,{0,2,3}},

{3,{0,3,4}},{3,{0,4,1}},{4,{1,4,3,2}}}};

/* for (i=0;i<8;i++) {

15
 hasil = point2vektor(prisma,i);
HslKali = kali(mat,hasil);
HslTitik = vektor2point(HslKali);
prisma.titik[i] = HslTitik;
} */

// DrawPolygon(prisma);

Tprisma = prisma;

for (i=0;i<8;i++) {
hasil = point2vektor(prisma,i);
HslKali = kali(translasi(100,100,100),hasil);
HslTitik = vektor2point(HslKali);
Tprisma.titik[i] = HslTitik;
}

// DrawPolygon(Tprisma);
}

void UserDraw() {
glClearColor(1.0f,1.0f,1.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT);

// glRotatef(0.1f,0.0f,1.0f,0.0f);

gambarbalok();
// gambarprisma();

glutSwapBuffers();
}

void main(int argc,char **argv) {

glutInit(&argc,argv);

glutInitWindowPosition(20,20);
glutInitWindowSize(640,640);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);

glutCreateWindow("Point To Vektor");
glOrtho(-200.0f,200.0f,-200.0f,200.0f,-200.0f,200.0f);

glutIdleFunc(UserDraw);

glutDisplayFunc(UserDraw);

glutMainLoop();
}

16
Output Program :

17
 Bab III. Kesimpulan
Dari pembahasan tersebut, dapat di tarik kesimpulan :

1. Objek 3D di bangun oleh titik 3D, vector 3D dan matriks 3D.

2. Untuk melakukan transformasi terhadap sebuah objek 3D,

diperlukan perubahan struktur data titik 3D menjadi vector 3D
kemudian di operasikan dengan matriks transformasi.

3. Untuk menggambar hasil transformasi maka harus dilakukan

kembali perubahan struktur data vector menjadi titik. Ada dua cara
untuk melakukan perubahan struktur data tersebut, yaitu :

a) Perubahan vector 3D menjadi titik 3D.

b) Perubahan vector 3D menjadi titik 2D.

4. Pada penggambaran objek 3D terdapat face yang kelihatan

(visible) dan face yang tidak kelihatan (invisible).

5. Face visible dan invisible dapat diketahui dengan mencari vector

normal dari face tersebut. Jika arah sumbu z dari vector normal
adalah positif, maka face tersebut visible. Jika arah sumbu z dari
vector normal adalah negative, maka face tersebut invisible.

6. Cara penggambaran face visible dan invisible, yaitu :

a) Face invisible digambar terlebih dahulu dengan menggunakan

warna yang lebih redup.

b) Setelah itu face visible digambar dengan menggunakan warna

yang lebih cerah.

18
 Daftar Pustaka
Irawan. P. B, Dipl Informatika. 2003. Grafika Komputer dengan C.
Yogyakarta: Penerbit Andi

http://www.wiki.gamedevid.org/wiki/Tutorials. 20 April 2009. Tutorial

OpenGL 2

http://www.scribd.com/doc/8370653 20 April 2009. Grafika KomputerIn

Editing2

http://www.id.wikipedia.org/wiki/Perkalian_vektor. 25 April 2009. Perkalian

vector

19