Posted by bibil23 on November 03, 2016 in C++ | No comments
Download Filenya di sini 
Kompetensi
Dasar :
Ø
Memahami Grafik Komputer &
Pemakainya …………………………………………………. 2
Ø
Memahami Konsep Dasar Library
Grafik………………………………………………………… 9
Ø
Memahami Pembuatan Primitif
Drawing……………………………………………………….. 12
Ø
Memahami Grafik 2
Dimensi…………………………………………………………………………. 17
Ø
Menerapkan Tranformasi Objek 2
Dimensi……………………………………………………. 21
Ø
Menerapkan Pembuatan Model Objek 2
Dimensi…………………………………………. 28
Dewasa ini perkembangan computer begitu pesat yang didukung dari
beberapa prosesor dan kartu grafis yang canggih untuk mendukung kebutuhan
manusia khususnya dalam bidang teknologi. Salah satunya adalah dalam bidang
grafik computer dan pengolahan citra.
Secara garis besar grafik computer merupakan proses untuk
menciptakan suatu gambar bersadarkan ide atau deskripsi menjadi sebuah
gambar, sedangkan pengolahan citra (Image Prosesing) merupakan suatu
perbaikan kualitas agar mudah di interpretasi oleh manusia atau computer.
Pada pengolahan citra dan grafik computer penerapannya tidak
hanya pada teknik informasi saja, akan tetapi hampir semua bindang ilmu
pengetahuan khususnya teknologi mengunakan grafik computer dan pengolahan citra
seperti arsitektur, desain, simulasi dan lain-lain
Dalam makalah ini, saya selaku penulis akan mengulas
sedikit mengenai pengolahan citra dan grafik computer, serta penerapannya dalam
kedua bidang ilmu tersebut.
GRAFIKA KOMPUTER
Grafika Komputer adalah proses untuk
menciptakan suatu gambar berdasarkan deskripsi obyek maupun latar belakang yang
terkandung pada gambar tersebut. Grafika komputer merupakan teknik untuk
membuat gambar obyek sesuai dengan obyek tersebut di alam nyata (realism).
Grafika komputer bertujuan menghasilkan gambar/citra (lebih tepat disebut grafik/picture) dengan primitif-primitif geometri seperti garis, lingkaran, dsb. Primitif-primitif geometri tersebut memerlukan data deskriptif untuk melukis elemen-elemen gambar. Data deskriptif : koordinat titik, panjang garis, jari-jari lingkaran, tebal garis, warna, dsb. Grafika komputer berperan dalam visualisasi dan virtual reality.
Grafika komputer bertujuan menghasilkan gambar/citra (lebih tepat disebut grafik/picture) dengan primitif-primitif geometri seperti garis, lingkaran, dsb. Primitif-primitif geometri tersebut memerlukan data deskriptif untuk melukis elemen-elemen gambar. Data deskriptif : koordinat titik, panjang garis, jari-jari lingkaran, tebal garis, warna, dsb. Grafika komputer berperan dalam visualisasi dan virtual reality.
Semakin canggih paralatan pendukung grafik komputer yang beredar
di pasaran maka semakin banyak bidang yang memanfaatkan grafik komputer. Pada
kehidupan sehari-hari semakin sering memanfaatkan grafik komputer dalam
memvisualisasikan kegiatan-kegiatan yang sedang berlangsung di lingkungan
tersebut. Berikut ini adalah
beberapa contoh penerapan grafik computer berbagai bidang:
1. Video Game
Video games merupakan permainan yang melibatkan interaksi dengan
user interface untuk menghasilkan umpan balik berupa visualisasi pada perangkat
video. Video games yang beredar di pasaran ada yang 2D dan ada yang 3D.
Dengan adanya kemajuan yang pesat dibidang grafik computer,
video games saat ini kebanyak adalah 3D dan detail gambar yang dihasilkan
sangat halus dan mirip dengan objek asli. Tapi tentunya untuk memainkan video
games yang seperti ini diperlukan pula kemampuan computer yang bagus agar tidak
terjadi lagging saat games ini dimainkan
2. Dalam computer-aided design (CAD)
Grafika komputer bisa digunakan untuk merancang
komponen-komponen dari sistem mekanis, elektris, elektro-mekanis maupun piranti
lainnya. Sistem-sistem tersebut mencakup struktur bangunan, badan-badan mobil,
pesawat terbang dan sebagainya. Penekanan di bidang tersebut adalah
dihasilkannya citra dengan ketelitian yang sangat tinggi. Selain itu citra yang
dihasilkan dari CAD bisa dipakai sebagai masukan bagi suatu sistem yang akan
mengevaluasi model yang digambar sesuai kebutuhan.
CAD sangat membantu bagi para arsitek, karena jika dia melakukan
kesalahan dalam pembuatan sebuah desain, dia tinggal mengeditnya supaya benar.
Jika arsitek mengerjakan desain dengan cara primitive, jika terdapat kesalahan
maka dia akan membuatnya dari ulang. Dalam hal perhitungannya pun, angka yang
dihasilkan CAD pasti lebih absolute. Contohnya adalah Autocad, 3ds Max, dan
lain-lain.
3. Dalam bidang antarmuka grafis (Graphical User Interface/GUI)
grafika komputer seolah-olah menyediakan suatu bahasa antarmuka
pemakai (user interface) yang baru. Hal itu dikarenakan dialog
antara pemakai dan komputer tidak lagi hanya dilakukan melalui suatu perintah
yang harus diketikkan, tetapi pemakai juga bisa memilih suatu simbol atau icon
yang tersedia untuk mengerjakan aktivitas yang diinginkan. Pemilihan icon bisa
dilakukan menggunakan piranti pembantu seperti mouse, lighpen dan lainnya.
4. Virtual Reality
Virtual Reality adalah lingkungan virtual yang seakan-akan
begitu nyata di mana user dapat Berinteraksi dengan objek-objek dalam suasana
atau lingkungan 3 dimensi. Perangkat keras khusus digunakan untuk memberikan
efek pemadangan 3 dimensi dan memampukan user beriteraksi dengan objek-objek
yang ada dalam lingkungan. Contoh: Simulasi SIM, Simulasi pesawat terbang
aplikasi VR parachute trainer yang digunakan oleh U.S. Navy untuk latihan
terjun payung. Aplikasi ini dapat memberikan keutungan berupa mengurangi resiko
cedera selama latihan, mengurangi biaya penerbangan, melatih perwira sebelum
melakukan terjun payung sesungguhnya.
PENGOLAHAN CITRA
Pengolahan citra adalah pemrosesan citra, khususnya menggunakan
komputer, menjadi citra yang kualitasnya lebih baik dan sesuai dengan keinginan
pemakai. Pengolahan citra bertujuan untuk memperbaiki kualitas citra agar mudah
diinterpretasi oleh manusia atau mesin (dalam hal ini komputer).
Teknik-teknik pengolahan citra mentransformasikan citra ke citra
yang lain. Jadi masukannya adalah citra dan keluarannya juga citra, namun citra
keluaran atau hasil dari pengolahan citra mempunyai kualitas lebih baik dari
pada citra masukan.
Berikut ini adalah contoh penerapan pengolahan citra dalam
berbagai bidang:
1. Identifikasi Objek
Yaitu pengolahan citra digital yang mampu mengidentifikasi jenis
atau banyaknya objek dalam suatu citra contohnya adalah Aplikasi face
detection, aplikasi ini mampu mengidentifikasi wajah seseorang
2. Bidang Kesehatan
Disini bidang kesehatan bertujuan untuk rontgen
tubuh manusia yang berfungsi untuk mengetahui penyakit yang ada didalam
tubuh manusia. Dengan mengunakan sinar x yang di tembakan ke tubuh manusia
sehingga menjadi protret tubuh manusia bagian dalam dan kemudian diolah untuk
mempermudah para medis untuk melakukan analias terhadap penyakit.
3. Teknologi Pengamanan
Suatu system mengalami kemajuan pesat akibat pesatnya
perkembangan pengolahan citra pada bidang biometrika. Sebagai contoh
pemanfaatan sidik jari, retina mata, wajah dan biometrika yang lainnya itu
semua dipergunakan untuk mengidentifikasi seseorang pada sytem keamanan
4. Mikroskop Eletron
Adalah salah satu contoh dari pengolahan citra
dalam bidang kedokteran, yang di maksud dengan mikroskop elektron adalah sebuah
mikroskop yang dapat memperbesar detail sangat kecil dengan kekutan sehingga
menyelesaikan tinggi akibat penggunaan elektron sebagai sumber penerangannya.
Pembesaran dalam hal ini di tingkat hingga 2.000.000 kali. Adapun kegunaan dari
mikroskop elektron yaitu digunakan dalam patologi anatomi. Patologi anatomi ini
berfungsi untuk mengindentifikasi organel dalam sel namun kegunaanya telah
sangat dikurangi dengan immunhistochemistry tetapi masih tak tergantikan untuk
diagnosis penyakit ginjal, identifikasi sindrom silia immotile
Memahami Konsep Dasar
Library Grafik
- OpenGL adalah suatu library grafis standard yang
digunakan untuk keperluan-keperluan pemrograman grafis, Selain OpenGL, library
grafis yang banyak digunakan adalah DirectX.
- OpenGL bersifat Open-Source, multi-platform dan
multi-language. Saat ini semua bahasa pemrograman mendukung OpenGL. Dan OpenGL
bisa bekerja dalam lingkungan Windows, Unix, SGI, Linux, free BSD dll.
4.1 LIBRARY
OpenGL-GLUT
- Library dasar dari OpenGL adalah GLUT, dengan
fasilitas yang bisa dikembangkan.
- Untuk sistem operasi Windows, library ini terdiri
dari 3 files yaitu:
a. glut.h
b. glut32.lib
c. glut32.dll
5. Instalasi GLUT OpenGL
- Copykanfile glut.h didalam folder c:\Program
Files\Microsoft Visual Studio\VC98\Include\GL
- Copykanfile glut32.lib didalamfolder c:\Program
Files\Microsoft Visual Studio\VC98\lib
- Copykanfile glut32.dll didalam folder
c:\Windows\System32
6. Mengenal Pemrograman Grafis
- Pemrograman grafis adalah pemrograman yang
digunakan untuk menghasilkan gambar pada komputer menggunakan library yang ada.
- Teknik-teknik pemrograman grafis ini didasari oleh
teknik-teknik menggambar dengan pemakaian geometri sebagai dasar struktur
datanya
- Hasil pemrograman grafis adalah visualisasi
grafis.
7. Struktur dasar Pemrograman Grafika menggunakan
OpenGL
#include <GL/glut.h>
void userdraw(void)
{// Disinitempatuntukmenggambar}
void display(void) {
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
intmain(intargc,char**argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
glutCreateWindow(“Drawing by AchmadBasuki");
glClearColor(0.0,0.0,0.0,0.0);
gluOrtho2D(-320.,320.,-240.0,240.0);
glutIdleFunc(display); glutDisplayFunc(display);
glutMainLoop();
return 0;
}
7.1 #INCLUDE
<GL/glut.h>
a. Pemrograman grafis menggunakan OpenGL-GLUT
membutuhkan header glut.h yang ada di folder
c:\Program
Files\Microsoft Visual Studio\VC98\bin\GL
7.2 GLvoid
userdraw(void) {// Disini tempat untuk menggambar}
a. Fungsi userdraw adalah suatu fungsi untuk membuat
kode program untuk menghasilkan suatu gambar #include <GL/glut.h>void userdraw(void) {//
Disinitempatuntukmenggambar}
7.3 Glut
InitWindowPosition(100,100); glut InitWindowSize(640,480);
a. Membuat windows dengan ukuran(640,480) dengan
titik kiri atas jendela diletakkan pada posisi(100,100) dilayar komputer
7.4 Glut
CreateWindow(“DrawingBy Rizky keyvin andrey");
a. Memberi judul pada windows dengan“Drawing By Rizky
keyvin andrey”
7.5 glClearColor(1.0,1.0,1.0,0.0);
a. Mendefinisikan warna dari windows yang dibuat
dengan warna(1,1,1) yaitu warna putih
7.6 gluOrtho2D(-320.,320.,-240.,240.);
a. Mendefinisikan besarnya sistem koordinat dengan
range sumbux adalah[-320,320] dan range untuk sumbuy adalah[-240,240]
Memahami Pembuatan Primitif Drawing
MATERI
•Sistem Koordinat 2D
•Menggambar Titik
•Menggambar Garis
•Menggambar Polyline
•Menggambar Polygon
•Mengubah Warna
1. SIMTEM KOORDINAT 2D
1.1 CONTOH SISTEM
KOORDINAT DALAM OpenGL
glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
gluOrtho2D(-320.,320.,-240.,240.);
2. MENGGAMBAR TITIK
a. glVertex2i(x,y)
Untuk
menggambar titik diposisi(x,y) dimana x dan y didefinisikan sebagai bilangan
bulat(integer)
b. glVertex2f(x,y)
glVertex2d(x,y)
Untuk
menggambar titik diposisi(x,y) dimana x dan y didefinisikan sebagai bilangan
pecahan(float/double)
Menggunakan
library glBegin(GL_POINTS)
2.1 CONTOH MENGGAMBAR
TITIK
a. glBegin(GL_POINTS);
glVertex2i(100,50);
glVertex2i(100,130);
glVertex2i(150,130);
glEnd();
b. drawDot(100,50);
drawDot(100,130);
drawDot(150,130);
2.2 FUNGSI UNTUK
MENGGAMBAR TITIK
a. void drawDot(intx, inty)
{ glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
}
Fungsi
ini digunakan bila x dan y didefinisikan sebagai integer
b. void drawDot(floatx, float y)
{ glBegin(GL_POINTS);
glVertex2f(x,y);
glEnd();
}
Fungsi
ini digunakan bila x dan y didefinisikan sebagai float
2.3 MENGUBAH UKURAN
TITK
a. drawDot(100,50);
drawDot(100,130);
glPointSize(4);
drawDot(150,130);
3. MENGGAMBAR GARIS
Untuk membuat garis diperlukan libraryGL_LINES dengan menyatakan titik awal dan titik akhir dari
garis.
a. glBegin(GL_LINES);
glVertex2f(100,100);
glVertex2f(200,150);
glEnd();
3.1 FUNGSI UNTUK
MENGGAMBAR GARIS
a. void drawLine(intx1,int y1,int x2,int y2)
{ glBegin(GL_LINES);
glVertex2i(x1,y1);
glVertex2i(x2,y2);
glEnd();
}
b. void drawLine(floatx1,float y1,float x2,float y2)
{ glBegin(GL_LINES);
glVertex2f(x1,y1);
glVertex2f(x2,y2);
glEnd();
}
3.2 CONTOH MENGGAMBAR
GARIS
a. drawLine(100,100,200,150);
4. MENGGAMBAR POLYLINE
Polyline adalah sekumpulan garis yang terhubung
satu dengan yang lainnya hingga membentuk sebuah obyek gambar
a. glBegin(GL_LINE_STRIP);
glVertex2f(x1,y1);
glVertex2f(x2,y2);
glVertex2f(x3,y3);
……………………………………………
glVertex2f(xn,yn);
glEnd();
4.1 CONTOH MENGGAMBAR
POLYLINE
a. glBegin(GL_LINE_STRIP);
glVertex2f(100,100);
glVertex2f(200,150);
glVertex2f(300,50);
glEnd();
5. MENGGAMBAR POLYGON
Polygon adalah sekumpulan garis yang terhubung
satu dengan yang lainnya dan berbentuk kurva tertutup hingga membentuk sebuah obyek
gambar.
a. glBegin(GL_LINE_LOOP);
glVertex2f(x1,y1);
glVertex2f(x2,y2);
glVertex2f(x3,y3);
……………………………………………
glVertex2f(xn,yn);
glEnd();
5.1 CONTOH MENGGAMBAR
POLYGON
a. glBegin(GL_LINE_LOOP);
glVertex2f(100,100);
glVertex2f(200,150);
glVertex2f(300,50);
glEnd();
6. MENGUBAH WARNA
a. glColor3f(red,green,blue);
red,
green, blue nilainya antara 0 sampai dengan 1, letaknya sebelum obyek digambar
b. glColor3f(0.,0.,0.);//black
glColor3f(0.,0.,1.);//blue glColor3f(0.,1.,0.);//green
glColor3f(0.,1.,1.);//cyan glColor3f(1.,0.,0.);//red
glColor3f(1.,0.,1.);//magenta glColor3f(1.,1.,0.);//yellow
glColor3f(1.,1.,1.);//white
6.1 CONTOH MENGUBAH
WARNA
a. glColor3f(0,0,0);
drawDot(100,50);
glColor3f(1,0,0);
drawDot(100,130);
glColor3f(0,0,1);
drawDot(150,130);
6.2 CONTOH GAMBAR
•Buatlah
latar belakang windows menjadi hitam dengan mengubah afungsi glClearColor
menjadi glClearColor(0.0,0.0,0.0,0.0); pada main()
•Isikanprogram berikutpadauserdraw()
a. float x,y;
for(inti=0;i<1000;i++){ x=640*(float)rand()/RAND_MAX-320;
y=480*(float)rand()/RAND_MAX-240;
drawDot(x,y);
}
Memahami Grafik 2 Dimensi
Objek grafik 2 dimensi adalah
sekumpulan titik-titik 2 dimensi yang dihubungkan dengan garis lurus, baik
berupa polyline, polygon atau kurva. Objek grafik 2 dimensi didefinisikan
sebagai kumpulan titik 2dimensi yang secara komputasi dinyatakan sebagai array
1D, atau linkedlist sesuai dengan struktur data yang digunakan dalam menyatakan
kumpulan titik 2D ini.
Objek grafik dimensi juga adalah
gambar 2 dimensi yang sumbu x dan sumbu y, atau sumbu koordinat cartesius
dua dimensi. Dua sumbu yang saling bertegak lurus antar satu dengan yang lain,
yang keduanya terletak dalam satu bidang (bidang xy).
Sedangkan Grafik komputer 2D
adalah sebuah generasi gambar digital berbasis komputer, yang kebanyakan
mengambil objek-objek dua dimensi (2D). Model Grafik 2D merupakan kombinasi
dari model geometri (juga disebut sebagai grafik vektor), gambar digital
(raster graphics), fungsi matematika, dan sebagainya. Komponen-komponen ini
dapat dimodifikasi dan dimanipulasi oleh transformasi geometri dua dimensi,
seperti translasi, rotasi, dan dilatasi.
Model-model yang digunakan pada
disain grafis 2D biasanya tidak mendukung bentuk-bentuk tiga-dimensi, atau
fenomena yang bersifat tiga dimensi, seperti pencahayaan, bayangan, pantulan,
refraksi, dan sebagainya. Namun demikian, mereka dapat membuat model
berlapis-lapis (layer); nyata, translusen, dan transparan, yang dapat ditumpuk
dalam urutan tertentu. Urutan tersebut biasanya didefinisikan dengan angka
(kedalaman lapisan, atau jarak dari si penglihat).
Macam-Macam objek 2D :
· Line
· Circle
· Arc
· Polygon
· Text
· Section
· Rectangle
· Ellips
· Donut
· Star
· Helix
Dari macam-macam objek 2d ini
saya akan membahas 3 macam:
Circle
Circle atau lingkaran adalah
object 2 dimensi yang memiliki ukuran diameter dan jari-jari. Circle atau
lingkaran merupakan kumpulan titik-titik yang tak berhingga dan saling
berhubung.
Line
Objek line/garis adalah objek
salah satu 2 dimensi yang sangat mendasar dan sering digunakan untuk
perancangan gambar kerja. Line berasal dari 2 titik yang saling terhubung.
Polygon
Polygon adalah suatu fungsi yang
mirip dengan polyline, hanya saja hasilnya adalah kurva tertutup. Pada polygon
digunakan konsep array dalam menyatakan objek 2D sebagaikumpulan titik 2D.
Polygon digunakan untuk merepresentasikan objek-objek dua dimensi. Suatu poygon
paling sedikit dibatasi oleh tiga garis yang saling terhubung di antara ketiga
titik tersebut.
Adapun langkah-langkah untuk
mendefinisikan objek grafik 2 dimensi :
1. Mendefinisikan struktur dari titik 2D
Sistem Koordinat
OpenGL
2. Mendefinisikan struktur warna
Untuk memberi warna pada objek,
seperti titik atau garis, dapat dilakukan dengan menggunakan fungsi " glColor3f(red,green,blue);
Di mana red, green, blue berada
pada 0 sampai dengan 1, yang menunjukkan skala pencerahan dari
masing-masing skala.
3. Mendefinisikan struktur dari objek grafik 2D
Fungsi
gluOrtho2D (left,right,bottom,top) " gluOrtho2D(-320,320,-240,240)
Objek primitive (Lanjutan)
a. Triangle "GL_TRIANGLES
Triangle atau segitiga adalah
tiga buah titik yang terhubung menjadi suatu segitiga dengan blok di tengahnya.
b. Quads " GL_QUADS
Quad atau segempat adalah empat buah
titik yang terhubung menjadi suatu segempat dengan blok di tengahnya.
c. Polygon " GL_POLYGON
Polygon merupakan suatu fungsi
yang mirip dengan polyline, tetapi menghasilkan kurva tertutup dengan blok
warna (fill).
Menerapkan
Tranformasi Objek 2 Dimensi
Grafika computer merupakan bidang
yang menarik minat banyak orang. Salah
satu sub bagian dari grafika adalah pemodelan objek.Dalam pemodelan objek 2D,
berbagai objek dimodifikasi dengan melakukan berbagai operasi fungsi atau
operasi transformasi geometri. Transformasi ini dapat berupa transformasi dasar ataupun
gabungan dari berbagai transformasi geometri. Transformasi
ini dikenal dengan Transformasi
affine. Pada dasarnya,transformasi merupakan suatu operasi modifikasi
bentuk objek tanpa merusak bentuk dasar dari objek. Salah satu contoh transformasi adalah
transformasi dari window ke viewport.
Pada Viewport, Objek yang akan digambar pada layar
biasanya mempunyai ukuran yang jauh lebih besar dibanding dengan ukuran layar,
sehingga perlu dilakukan pemetaan transformasi yang memungkinkan objek tersebut
bisa seluruhnya digambar dilayar, tetapi pada layar dengan koordinat yang
terbatas, dan biasanya dibatasi oleh sebuah kotak yang disebut windows, sedangkan layarnya
tersebut disebut Viewport.
1. Langkah-Langkah
Transformasi Viewing 2 Dimensi
1) Pembentukan scene pada WC
menggunakan output primitif atribut.
2) Untuk mendapatkan
orientasi tertentu dari window, maka ditentukan sistem VC 2 dimensi pada WC.
Frame digunakan untuk melengkapi penentuan orientasi dari windows persegi empat
. Setelah frame dibentuk dapat ditransformasikan ke dalam WC untuk menampilkan
koordinat.
3) Kemudian viewport
ditentukan dalam normalized NVC (pada batasan antara 0 dan 1) dan memetakan
deskripsi VC dari scene pada Normalized Coordinate.
4) Akhirnya dilakukan
clipping (pemotongan) pada semua gambar yang ada diluar viewport.
2. Macam-macam transformasi:
1) Transformasi Objek, yang
ditransformasikan titik-titik yang menyusun objek tersebut.
2) Transformasi Koordinat,
yang diubah system koordinatnya sehingga objek mengalami transformasi
dikarenakan perubahan system koordinat tersebut.
3. Tujuan Transformasi :
1) Merubah atau menyesuaikan komposisi
pandangan.
2) Memudahkan membuat objek yang simetris
3) Melihat objek dari sudut pandang berbeda
4) Memindahkan satu atau beberapa objek dari
satu tempat ke tempat lain, biasanya digunakan pada animasi computer.
4. Transformasi
dasar pada objek dua dimensi terdiri dari :
a. TRANSLASI
Translasi merupakan suatu proses yang menyebabkan perpindahan
objek dari satu titik ke titik lain.Translasi dilakukan dengan penambahan translasi padasuatu
titik koordinat dengan translasi vector yaitu (trx,try),
dimana trx adalah translation vector menurut
sumbu x sedangkan try adalah translasi vector terhadap sumbu
y.
Koordinat baru titik yang
ditranslasi dapat diperoleh dengan
menggunakan rumus:
x ’ = x + trx
y ‘ = y + try
imana (x,y) adalah
koordinat asal suatu objek dan (x’,y’) adalah koordinat
baru objek tersebut setelah ditranslasi.Translasi adalah transformasi dengan bentuk yang
tetap memindahkan objek apa adanya. Dengan demikian setiap titik dari objek
akan ditranslasi dengan besaran yang sama.
a. SKALA
Transformasi
skala adalah perubahan ukuran suatu objek. P
b. ROTASI
Rotasi merupakan bentuk transformasi berupa pemutaran objek, dilakukan
dengan menambahkan besaran pada absis X dan ordinat Y. Rotasi dua dimensi pada suatu objek
akan memindahkan objek tersebut menurut garis melingkar. Pada bidang xy.
c. SHEARING
Shearing mempunyai
beberapa pengertian, antara lain :
· Shearing adalah bentuk transformasi yang membuat distorsi dari
bentuk suatu objek, seperti menggeser sisi tertentu.
· Shearing adalah suatu proses untuk mentransformasikan objek
dengan cara “membebani” objek tersebut kea rah tertentu, sehingga dihasilkan
suatu objek yang distorsi.
Dua macam shear yang umum adalah shear menurut sumbu x dan
shear menurut sumbu y.
6. SISTEM KOORDINAT HOMOGEN
Sistem koordinat homogen adalah system koordinat yang
mempunyai satu dimensi lebih tinggi dari system koordinat yang ditinjau.
Digunakan untuk menyatakan semua proses transformasi dengan perkalian matrix
termasuk pergeseran.
7. PEMBATALAN TRANSFORMASI AFFIN
Transformasi dari titik P ke titik Q dengan persamaan Q = PM + trdapat dibatalkan atau
dikembalikan dengan menggunakan persamaan P
= ( Q – tr )M-1 dengan
catatan bahwa M adalah marix non singular
(mempunyai determinan tidak sama dengan nol).
Untuk objek dua dimensi dapat dilakukan dengan matrix 2x2
karena pembatalan transformasi tidak perlu dengan bantuan koordinat homogen.
interface:
Source code Program :
Unit1.cpp
//---------------------------------------------------------------------------
#include // membaca file vcl untuk memulai pembuatan
program pada Borland C++ Builder
#include //membaca file header math yang berhubungan dengan
perhitungan
#pragma hdrstop à library
yang sudah disediakan oleh Borland C++ Builder
#include "Unit1.h" // membaca file Unit1.h
#pragma package(smart_init) // library yang sudah disediakan oleh Borland
C++ Builder
#pragma resource "*.dfm" // library yang sudah disediakan oleh Borland
C++ Builder
TForm1 *Form1;
struct Elemen { float x,y ;} ; //objek berbentuk struktur
dengan variabel X dan Y yang bertipe float
Elemen Objek[6]; //deklarasi elemen
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
// memanggil fungsi TForm1
//---------------------------------------------------------------------------
void __fastcall TForm1::FormShow(TObject *Sender)
{ int i;
Image1->Canvas->Rectangle(0,0,Image1->Width,Image1->Height);
Image1->Canvas->MoveTo(Objek[5].x,Objek[5].y); //move to memmindahkan garis
for (i=1;i<=5;i++){
Image1->Canvas->LineTo(Objek[i].x,Objek[i].y);};
} //line to
menambah garis
//========================================================================
void __fastcall TForm1::FormActivate(TObject *Sender)
{ Objek[1].x =
100; Objek[1].y = 50;
Objek[2].x = 50; Objek[2].y = 100;
Objek[3].x = 100; Objek[3].y
= 100;
Objek[4].x = 100; Objek[4].y
= 150;
Objek[5].x = 150; Objek[5].y
= 100;
FormShow(Sender);
}
// memanggil fungsi FormActivate untuk membuat objekdengan menentukan titik-titik objek pada koordinat
x dan y
//========================================================================
void __fastcall TForm1::ButtonatasClick(TObject *Sender)
{
int i;
for (i=1;i<=5;i++){ Objek[i].y-=5;};
FormShow(Sender);
}
// memanggil fungsi
ButtonatasClick
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonkananClick(TObject *Sender)
{
int i;
for (i=1;i<=5;i++){ Objek[i].x+=5;};
FormShow(Sender);
}
// memanggil fungsi ButtonkananClick
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonkiriClick(TObject *Sender)
{
int i;
for (i=1;i<=5;i++){ Objek[i].x-=5;};
FormShow(Sender);
}// memanggil fungsi ButtonkiriClick
//-----------------------------------------
----------------------------------
void __fastcall TForm1::ButtonbawahClick(TObject *Sender)
{
int i;
for (i=1;i<=5;i++){ Objek[i].y+=5;};
FormShow(Sender);
}// memanggil fungsi ButtonbawahClick
//---------------------------------------------------------------------------
void __fastcall TForm1:: Button1Click (TObject *Sender)
{
Elemen TempObjek[6];
int i; float Sdt;
for (i=1;i<=5;i++)
{ Objek[i].x=Objek[i].x-Image1->Width
/ 2;
Objek[i].y=Objek[i].y-Image1->Height / 2;
Sdt=10*M_PI/180;
TempObjek[i].x=(Objek[i].x*cos(Sdt)-Objek[i].y*sin(Sdt));
TempObjek[i].y=(Objek[i].x*sin(Sdt)+Objek[i].y*cos(Sdt));
Objek[i]=TempObjek[i];
Objek[i].x=Objek[i].x+Image1->Width / 2;
Objek[i].y=Objek[i].y+Image1->Height / 2;
} FormShow(Sender);
}// memanggil fungsi Button1Click
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Elemen TempObjek[6];
int i,n,m; float Sdt;
for (i=1;i<=5;i++)
{
n = Objek[3].x;
m = Objek[3].y;
Objek[i].x=Objek[i].x-n;
Objek[i].y=Objek[i].y-m;
Sdt=10*M_PI/180;
TempObjek[i].x=(Objek[i].x*cos(Sdt)-Objek[i].y*sin(Sdt));
TempObjek[i].y=(Objek[i].x*sin(Sdt)+Objek[i].y*cos(Sdt));
Objek[i]=TempObjek[i];
Objek[i].x=Objek[i].x+n;
Objek[i].y=Objek[i].y+m;
}
FormShow(Sender);
}// memanggil fungsi Button2Click
//---------------------------------------------------------------------------
UNIT.H
// File ini berisi event
handler untuk mengatasi
sebuah event dari komponen yang ditempatkan pada sebuah form.
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include
#include
#include
#include
#include
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: //
IDE-managed Components
TPanel *Panel1;
TButton *Buttonkiri;
TButton *Buttonatas;
TButton *Buttonbawah;
TButton *Buttonkanan;
TImage *Image1;
TButton *Button1;
TButton *Button2;
void __fastcall FormShow(TObject *Sender);
void __fastcall FormActivate(TObject *Sender);
void __fastcall ButtonatasClick(TObject *Sender);
void __fastcall ButtonkananClick(TObject *Sender);
void __fastcall ButtonkiriClick(TObject *Sender);
void __fastcall ButtonbawahClick(TObject *Sender);
void __fastcall Button1Click(TObject *Sender);
void __fastcall Button2Click(TObject *Sender);
private: // User
declarations
public: // User
declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
OUTPUT :
Menerapkan
Pembuatan Model Objek 3 Dimensi
Objek tiga dimensi jelas memiliki banyak perbedaan
dengan objek dua dimensi. Dengan koordinat x, y, z yang diperlukan, membuat
pengerjaan objek tiga dimensi menjadi lebih rumit. Dalam pembuatannya,
diperlukan koordinat untuk menentukan sudut pandang pengamat, kedalaman yang
diperlukan, dan transformasi objek untuk mempermudah pengerjaan.
OpenGL
dirancang sebagai perangkat yang instan dan tidak tergantung pada sistem
operasi dan bahasa pemrograman apapun. Perintah yang terdapat pada OpenGL tetap
sama pada semua sistem operasi karena OpenGL tidak mengimplementasikan window
khusus untuk merancang suatu objek seperti program visual lainnya. Sebagai
gantinya, diharuskan untuk membuat window sendiri menurut sistem operasi yang
digunakan dan bahasa pemrograman yang dipakai.
1. Kubus 3D
#include
GLfloat
light_diffuse[] = {1.0, 0.0, 0.0, 1.0};
//GLfloat
light_diffuse[] = {0.9f, 0.9f, 0.9f, 1.0f};
GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};
//GLfloat light_position[] = {2.0f, 2.0f, 2.0f, 0.0f};
void gambar3D(void)
{
glBegin(GL_QUADS);
// muka depan
glNormal3f( 0.0f, 0.0f,
1.0f); //Normal menuju Kita
glVertex3f(-1.0f, -1.0f,
1.0f); //Titik 1 (depan)
glVertex3f( 1.0f, -1.0f,
1.0f); //Titik 2 (depan)
glVertex3f( 1.0f, 1.0f,
1.0f); //Titik 3 (depan)
glVertex3f(-1.0f, 1.0f,
1.0f); //Titik 4 (depan)
// muka belakang
glNormal3f( 0.0f,
0.0f,-1.0f); //Normal menjauh Kita
glVertex3f(-1.0f,
-1.0f,-1.0f); //Titik 1 (belakang)
glVertex3f(-1.0f, 1.0f,
1.0f); //Titik 2 (atas)
glVertex3f( 1.0f, 1.0f,
1.0f); //Titik 3 (atas)
glVertex3f( 1.0f,
1.0f,-1.0f); //Titik 4 (atas)
// muka atas
glNormal3f( 0.0f, 1.0f,
1.0f); //Normal berarah atas
glVertex3f(-1.0f,
1.0f,-1.0f); //Titik 1 (atas)
glVertex3f(-1.0f, 1.0f,
1.0f); //Titik 2 (atas)
glVertex3f( 1.0f, 1.0f,
1.0f); //Titik 3 (atas)
glVertex3f( 1.0f,
1.0f,-1.0f); //Titik 4 (atas)
//muka bawah
glNormal3f( 0.0f, -1.0f,
0.0f); //Normal berarah bawah
glVertex3f(-1.0f,
-1.0f,-1.0f); //Titik 1 (bawah)
glVertex3f( 1.0f,
-1.0f,-1.0f); //Titik 2 (bawah)
glVertex3f( 1.0f, -1.0f,
1.0f); //Titik 3 (bawah)
glVertex3f(-1.0f, -1.0f,
1.0f); //Titik 4 (bawah)
//muka kanan
glNormal3f( 1.0f, 0.0f, 0.0f);
//Normal berarah kekanan
glVertex3f( 1.0f,
-1.0f,-1.0f); //Titik 1 (kanan)
glVertex3f( 1.0f,
1.0f,-1.0f); //Titik 2 (kanan)
glVertex3f( 1.0f, 1.0f,
1.0f); //Titik 3 (kanan)
glVertex3f( 1.0f, -1.0f,
1.0f); //Titik 4 (kanan)
//muka kiri
glNormal3f(-1.0f, 0.0f,
0.0f); //Normal berarah ke kiri
glVertex3f(-1.0f,
-1.0f,-1.0f); //Titik 1 (kiri)
glVertex3f(-1.0f, -1.0f,
1.0f); //Titik 2 (kiri)
glVertex3f(-1.0f, 1.0f,
1.0f); //Titik 3 (kiri)
glVertex3f(-1.0f,
1.0f,-1.0f); //Titik 4 (kiri)
glEnd();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT);
gambar3D();
glutSwapBuffers();
}
void inisialisasi(void)
{
//pencahayaan
glLightfv(GL_LIGHT0,
GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0,
GL_POSITION, light_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
//Buffer
glEnable(GL_DEPTH_TEST);
//setup kubus
glMatrixMode(GL_PROJECTION);
gluPerspective(40.0,1.0,1.0,10.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0, 0.0, 5.0, //
melihat pada (0,0,5)
0.0, 0.0, 0.0, // center
pada (0,0,0)
0.0, 1.0, 0.0); // arah Y
/* Mengatur posisi sudut */
//glTranslatef(0.0, 0.0,
-1.0);
glRotatef(30, 0.0, 1.0,
1.0);
glRotatef(15, 1.0, 1.0,
0.0);
}
int main(int argc, char
**argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE
| GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Grafika
Komputer 3 Dimensi");
glutDisplayFunc(display);
inisialisasi();
glutMainLoop();
return 0;
}
Gambar 1. Kubus
2.
Prisma 3D
#include
GLfloat light_diffuse[] =
{5.0, 4.0, 4.0, 5.0};
//GLfloat light_diffuse[]
= {0.9f, 0.9f, 0.9f, 1.0f};
GLfloat light_position[]
= {1.0, 1.0, 1.0, 0.0};
//GLfloat
light_position[] = {2.0f, 2.0f, 2.0f, 0.0f};
void gambar3D(void)
{
glBegin(GL_QUADS);
// muka belakang
glNormal3f( 0.0f,
0.0f,0.0f); //Normal menjauh Kita
glVertex3f(-1.0f,
1.0f,0.0f); //Titik 1 (belakang)
glVertex3f(1.0f, 1.0f,
0.0f); //Titik 2 (belakang)
glVertex3f( 1.0f, -1.0f,
0.0f); //Titik 3 (belakang)
glVertex3f( -1.0f,
-1.0f,0.0f); //Titik 4 (belakang)
//muka kanan
glNormal3f( 1.0f, 0.0f,
0.0f); //Normal berarah kekanan
glVertex3f( 0.0f,
1.0f,1.0f); //Titik 1 (kanan)
glVertex3f( 1.0f,
1.0f,0.0f); //Titik 2 (kanan)
glVertex3f( 1.0f, -1.0f,
0.0f); //Titik 3 (kanan)
glVertex3f( 0.0f, -1.0f,
1.0f); //Titik 4 (kanan)
//muka kiri
glNormal3f(-1.0f, 0.0f,
0.0f); //Normal berarah ke kiri
glVertex3f(-1.0f,
1.0f,0.0f); //Titik 1 (kiri)
glVertex3f(0.0f, 1.0f,
1.0f); //Titik 2 (kiri)
glVertex3f(0.0f, -1.0f,
1.0f); //Titik 3 (kiri)
glVertex3f(-1.0f,
-1.0f,0.0f); //Titik 4 (kiri)
//atas
glNormal3f(0.0f, 1.0f,
0.0f); //Normal berarah ke atas
glVertex3f(-1.0f,
1.0f,0.0f); //Titik 1 (atas)
glVertex3f(1.0f, 1.0f,
0.0f); //Titik 2 (atas)
glVertex3f(0.0f, 1.0f,
1.0f); //Titik 3 (atas)
//bawah
glNormal3f(0.0f, -1.0f,
0.0f); //Normal berarah ke bawah
glVertex3f(-1.0f,
-1.0f,0.0f); //Titik 1 (bawah)
glVertex3f(0.0f, -1.0f,
1.0f); //Titik 2 (bawah)
glVertex3f(1.0f, -1.0f,
0.0f); //Titik 3 (bawah)
glEnd ();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT);
gambar3D();
glutSwapBuffers();
}
void inisialisasi(void)
{
//pencahayaan
glLightfv(GL_LIGHT0,
GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0,
GL_POSITION, light_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
//Buffer
glEnable(GL_DEPTH_TEST);
//setup prisma
glMatrixMode(GL_PROJECTION);
gluPerspective(40.0,1.0,1.0,10.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0, 0.0, 5.0,
// melihat pada (0,0,5)
0.0, 0.0, 0.0, // center
pada (0,0,0)
0.0, 1.0, 0.0); // arah Y
/* Mengatur posisi sudut
*/
//glTranslatef(0.0, 0.0,
-1.0);
glRotatef(45, 1.0, 0.0,
1.0);
//glRotatef(15, 1.0, 1.0,
1.0);
}
int main(int argc, char
**argv)
{
glutInit(&argc,
argv);
glutInitDisplayMode(GLUT_DOUBLE
| GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Grafika
Komputer 3 Dimensi");
glutDisplayFunc(display);
inisialisasi();
glutMainLoop();
return 0;
}
Gambar 2. Prisma
3.
Antiprisma
#include
GLfloat light_diffuse[] =
{0.0, 1.0, .0, 0.0};
//GLfloat light_diffuse[] =
{0.9f, 0.9f, 0.9f, 1.0f};
GLfloat light_position[] =
{1.0, 1.0, 1.0, 0.0};
//GLfloat light_position[]
= {2.0f, 2.0f, 2.0f, 0.0f};
void gambar3D(void)
{
glBegin(GL_TRIANGLES);
// muka belakang
glNormal3f( 0.0f,
0.0f,1.0f); //Normal menjauh Kita
glVertex3f(1.0f,
0.0f,-1.0f); //Titik 1 (belakang)
glVertex3f(-1.0f, 0.0f,
-1.0f); //Titik 2 (belakang)
glVertex3f( 0.0f, 1.0f,
0.0f); //Titik 3 (belakang)
// muka depan
glNormal3f( 0.0f, 0.0f,
1.0f); //Normal menuju Kita
glVertex3f(-1.0f, 0.0f,
1.0f); //Titik 1 (depan)
glVertex3f( 1.0f, 0.0f,
1.0f); //Titik 2 (depan)
glVertex3f( 0.0f, 1.0f,
0.0f); //Titik 3 (depan)
//muka kanan
glNormal3f( 1.0f, 0.0f,
0.0f); //Normal berarah kekanan
glVertex3f( 1.0f,
0.0f,1.0f); //Titik 1 (kanan)
glVertex3f( 1.0f,
0.0f,-1.0f); //Titik 2 (kanan)
glVertex3f( 0.0f, 1.0f,
0.0f); //Titik 3 (kanan)
//muka kiri
glNormal3f(-1.0f, 0.0f,
0.0f); //Normal berarah ke kiri
glVertex3f(-1.0f, 0.0f,-1.0f);
//Titik 1 (kiri)
glVertex3f(-1.0f,0.0f,
1.0f); //Titik 2 (kiri)
glVertex3f(0.0f, 1.0f,
0.0f); //Titik 3 (kiri)
//bawah
glNormal3f(0.0f, 0.0f,
0.0f); //Normal berarah ke bawah
glVertex3f(-1.0f,
0.0f,1.0f); //Titik 1 (bawah)
glVertex3f(1.0f, 0.0f,
1.0f); //Titik 2 (bawah)
glVertex3f(1.0f, 0.0f,
-1.0f); //Titik 3 (bawah)
glVertex3f(-1.0f, 0.0f,
-1.0f); //Titik 4 (bawah)
glEnd();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT);
gambar3D();
glutSwapBuffers();
}
void inisialisasi(void)
{
glClearColor(1.0,1.0,1.0,0.0);
//pencahayaan
glLightfv(GL_LIGHT0,
GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0,
GL_POSITION, light_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
//Buffer
glEnable(GL_DEPTH_TEST);
//setup antiprisma
glMatrixMode(GL_PROJECTION);
gluPerspective(40.0,1.0,1.0,10.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0, 0.0, 5.0, //
melihat pada (0,0,5)
0.0, 0.0, 0.0, // center
pada (0,0,0)
0.0, 1.0, 0.0); // arah Y
/* Mengatur posisi sudut */
//glTranslatef(0.0, 0.0,
-1.0);
glRotatef(45, 1.0, 0.5,
1.0);
glRotatef(15, 1.0, 1.0,
1.0);
}
int main(int argc, char
**argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE
| GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("AntiPrisma");
glutDisplayFunc(display);
inisialisasi();
glutMainLoop();
return 0;
}
Gambar 3. Antiprisma
4.
Tetrahedron
//-----------------------------------------------------------------------------
#include
GLfloat
light_diffuse[] ={0.0,1.0,0.0,1.0};
//GLfloat
light_diffuse[] ={0.9f,0.9f,0.9f,1.0f};
GLfloat
light_position[] ={1.0,1.0,1.0,0.0};
//GLfloat
light_position[] ={2.0f,2.0f,2.0f,0.0f};
void
gambar3D(void)
{
glBegin(GL_QUADS);
//
Muka Depan
glNormal3f(0.0f,0.0f,
1.0f);//normal menuju kita
glVertex3f(-1.0f,-1.0f,
1.0f);//Titik 1 (depan)
glVertex3f(1.0f,-1.0f,
1.0f);//Titik 2 (depan)
glVertex3f(1.0f,1.0f,
1.0f);//Titik 3 (depan)
//
Muka Belakang
glNormal3f(0.0f,0.0f,
-1.0f);//normal menjauh kita
glVertex3f(-1.0f,-1.0f,
-1.0f);//Titik 1 (belakang)
glVertex3f(-1.0f,1.0f,
-1.0f);//Titik 2 (belakang)
glVertex3f(1.0f,1.0f,
-1.0f);//Titik 3 (belakang)
//Muka
Atas
glNormal3f(0.0f,1.0f,
1.0f);//normal berarah atas
glVertex3f(-1.0f,1.0f,
-1.0f);//Titik 1 (atas)
glVertex3f(-1.0f,1.0f,
1.0f);//Titik 2 (atas)
glVertex3f(1.0f,1.0f,
1.0f);//Titik 3 (atas)
//Muka
Bawah
glNormal3f(0.0f,-1.0f,
1.0f);//normal berarah bawah
glVertex3f(-1.0f,-1.0f,
-1.0f);//Titik 1 (bawah)
glVertex3f(1.0f,-1.0f,
-1.0f);//Titik 2 (bawah)
glVertex3f(1.0f,-1.0f,
1.0f);//Titik 3 (bawah)
//Muka
Kanan
glNormal3f(1.0f,0.0f,
0.0f);//normal berarah kekanan
glVertex3f(1.0f,-1.0f,
-1.0f);//Titik 1 (kanan)
glVertex3f(1.0f,1.0f,
-1.0f);//Titik 2 (kanan)
glVertex3f(1.0f,1.0f,
1.0f);//Titik 3 (kanan)
//Muka
Kiri
glNormal3f(-1.0f,0.0f,
0.0f);//normal berarah kekiri
glVertex3f(-1.0f,-1.0f,
-1.0f);//Titik 1 (kiri)
glVertex3f(-1.0f,-1.0f,
1.0f);//Titik 2 (kiri)
glVertex3f(-1.0f,1.0f,
1.0f);//Titik 3 (kiri)
glEnd();
}
void
display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glColor3f(1,1,0);
gambar3D();
glutSwapBuffers();
}
void
inisialisasi(void)
{
//Pencahayaan
glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
glLightfv(GL_LIGHT0,
GL_POSITION, light_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
//Buffer
glEnable(GL_DEPTH_TEST);
//setup
tetrahedron
glMatrixMode(GL_PROJECTION);
gluPerspective(60.0,1.0,1.0,10.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0,0.0,5.0,
//Melihat pada (0,0,5)
0.0,0.0,0.0,//center
pada (0,0,0)
0.0,1.0,0.0);//arah
Y
/*Mengatur
posisi sudut*/
glTranslatef(0.0,0.0,-1.0);
glRotatef(-29,
1.0,-1.0,1.0);
glRotatef(15,
0.0,1.0,0.0);
}
int
main(int argc,char** argv)
{
glutInit(&argc,
argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutCreateWindow("Grafika
Komputer 3 Dimensi");
glutDisplayFunc(display);
inisialisasi();
glutMainLoop();
return
0;
}
//--------------------------------------------------------
Gambar
4. Tetrahedron
5. Octahedron
#include
GLfloat light_diffuse[] = {12.0, 1.0, 5.0, 2.0};
//GLfloat light_diffuse[] = {0.9f, 0.9f, 0.9f, 1.0f};
GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};
//GLfloat light_position[] = {2.0f, 2.0f, 2.0f, 0.0f};
void gambar3D(void)
{
glBegin(GL_TRIANGLES);
// muka belakang atas
glNormal3f( 0.0f, 0.0f,1.0f); //Normal menjauh Kita
glVertex3f(1.0f, 0.0f,-1.0f); //Titik 1 (belakang)
glVertex3f(-1.0f, 0.0f, -1.0f); //Titik 2 (belakang)
glVertex3f( 0.0f, 1.0f, 0.0f); //Titik 3 (belakang)
// muka depan atas
glNormal3f( 0.0f, 0.0f, 1.0f); //Normal menuju Kita
glVertex3f(-1.0f, 0.0f, 1.0f); //Titik 1 (depan)
glVertex3f( 1.0f, 0.0f, 1.0f); //Titik 2 (depan)
glVertex3f( 0.0f, 1.0f, 0.0f); //Titik 3 (depan)
//muka kanan atas
glNormal3f( 1.0f, 0.0f, 0.0f); //Normal berarah kekanan
glVertex3f( 1.0f, 0.0f,1.0f); //Titik 1 (kanan)
glVertex3f( 1.0f, 0.0f,-1.0f); //Titik 2 (kanan)
glVertex3f( 0.0f, 1.0f, 0.0f); //Titik 3 (kanan)
//muka kiri atas
glNormal3f(-1.0f, 0.0f, 0.0f); //Normal berarah ke kiri
glVertex3f(-1.0f, 0.0f,-1.0f); //Titik 1 (kiri)
glVertex3f(-1.0f,0.0f, 1.0f); //Titik 2 (kiri)
glVertex3f(0.0f, 1.0f, 0.0f); //Titik 3 (kiri)
// muka belakang bawah
glNormal3f( 0.0f, 0.0f,1.0f); //Normal menjauh Kita
glVertex3f(1.0f, 0.0f,-1.0f); //Titik 1 (belakang)
glVertex3f(-1.0f, 0.0f, -1.0f); //Titik 2 (belakang)
glVertex3f( 0.0f, -1.0f, 0.0f); //Titik 3 (belakang)
// muka depan bawah
glNormal3f( 0.0f, 0.0f, 1.0f); //Normal menuju Kita
glVertex3f(-1.0f, 0.0f, 1.0f); //Titik 1 (depan)
glVertex3f( 1.0f, 0.0f, 1.0f); //Titik 2 (depan)
glVertex3f( 0.0f, -1.0f, 0.0f); //Titik 3 (depan)
//muka kanan bawah
glNormal3f( 1.0f, 0.0f, 0.0f); //Normal berarah kekanan
glVertex3f( 1.0f, 0.0f,1.0f); //Titik 1 (kanan)
glVertex3f( 1.0f, 0.0f,-1.0f); //Titik 2 (kanan)
glVertex3f( 0.0f, -1.0f, 0.0f); //Titik 3 (kanan)
//muka kiri bawah
glNormal3f(-1.0f, 0.0f, 0.0f); //Normal berarah ke kiri
glVertex3f(-1.0f, 0.0f,-1.0f); //Titik 1 (kiri)
glVertex3f(-1.0f,0.0f, 1.0f); //Titik 2 (kiri)
glVertex3f(0.0f, -1.0f, 0.0f); //Titik 3 (kiri)
glEnd();
glBegin(GL_QUADS);
//bawah
glNormal3f(0.0f, 0.0f, 0.0f); //Normal berarah ke bawah
glVertex3f(-1.0f, 0.0f,1.0f); //Titik 1 (bawah)
glVertex3f(1.0f, 0.0f, 1.0f); //Titik 2 (bawah)
glVertex3f(1.0f, 0.0f, -1.0f); //Titik 3 (bawah)
glVertex3f(-1.0f, 0.0f, -1.0f); //Titik 4 (bawah)
glEnd();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gambar3D();
glutSwapBuffers();
}
void inisialisasi(void)
{
glClearColor(1.0,1.0,1.0,0.0);
//pencahayaan
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
//Buffer
glEnable(GL_DEPTH_TEST);
//setup tetahedron
glMatrixMode(GL_PROJECTION);
gluPerspective(40.0,1.0,1.0,10.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0, 0.0, 5.0, // melihat pada (0,0,5)
0.0, 0.0, 0.0, // center pada (0,0,0)
0.0, 1.0, 0.0); // arah Y
/* Mengatur posisi sudut */
//glTranslatef(0.0, 0.0, -1.0);
glRotatef(45, 1.0, 0.0, 0.0);
//glRotatef(15, 1.0, 1.0, 1.0);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB |
GLUT_DEPTH);
glutCreateWindow("Tetrahedron");
glutDisplayFunc(display);
inisialisasi();
glutMainLoop();
return 0;
}
Gambar 5. Octahedron
6.
Objek Bebas
#include
GLfloat light_diffuse[] = {0.0, 0.1, 1.0, 1.0};
GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};
void octahedron(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat intensitasCahaya[]={0.9f, 0.9f, 0.9f, 1.0f};
GLfloat posisiCahaya[]={2.0f, 2.0f, 2.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, posisiCahaya);
glLightfv(GL_LIGHT0, GL_DIFFUSE, intensitasCahaya);
GLfloat bahan_ambient[]={0.0f, 0.5f, 0.6f, 1.0f};
GLfloat bahan_diffuse[]={12.0, 1.0, 5.0, 2.0};
GLfloat bahan_specular[]={1.0f, 1.0f, 1.0f, 1.0f};
GLfloat bahan_shininess[]={90.0f};
glMaterialfv(GL_FRONT, GL_AMBIENT, bahan_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bahan_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, bahan_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, bahan_shininess);
glPushMatrix();
glTranslatef(2.0, 1.0, -8.0);
glutSolidOctahedron();
glPopMatrix();
glFlush();
}
void icosahedron(void)
{
GLfloat intensitasCahaya[]={0.9f, 0.9f, 0.9f, 1.0f};
GLfloat posisiCahaya[]={2.0f, 2.0f, 2.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, posisiCahaya);
glLightfv(GL_LIGHT0, GL_DIFFUSE, intensitasCahaya);
GLfloat bahan_ambient[]={0.0f, 0.5f, 0.6f, 1.0f};
GLfloat bahan_diffuse[]={0.0, 1.0, 0.0, 0.0};
GLfloat bahan_specular[]={1.0f, 1.0f, 1.0f, 1.0f};
GLfloat bahan_shininess[]={90.0f};
glMaterialfv(GL_FRONT, GL_AMBIENT, bahan_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bahan_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, bahan_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, bahan_shininess);
glPushMatrix();
glTranslatef(-4, -2.5f, -8.0);
glutSolidIcosahedron();
glPopMatrix();
glFlush();
}
void dodecahedron(void)
{
GLfloat intensitasCahaya[]={0.9f, 0.9f, 0.9f, 1.0f};
GLfloat posisiCahaya[]={2.0f, 2.0f, 2.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, posisiCahaya);
glLightfv(GL_LIGHT0, GL_DIFFUSE, intensitasCahaya);
GLfloat bahan_ambient[]={0.0f, 0.5f, 0.6f, 1.0f};
GLfloat bahan_diffuse[]={10.0, 1.0, 0.0, 1.0};
GLfloat bahan_specular[]={1.0f, 1.0f, 1.0f, 1.0f};
GLfloat bahan_shininess[]={90.0f};
glMaterialfv(GL_FRONT, GL_AMBIENT, bahan_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bahan_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, bahan_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, bahan_shininess);
glPushMatrix();
glTranslatef(2.5f, -2.5f, -8.0);
glutSolidDodecahedron();
glPopMatrix();
glFlush();
}
void tetahedron(void)
{
GLfloat intensitasCahaya[]={0.9f, 0.9f, 0.9f, 1.0f};
GLfloat posisiCahaya[]={2.0f, 2.0f, 2.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, posisiCahaya);
glLightfv(GL_LIGHT0, GL_DIFFUSE, intensitasCahaya);
GLfloat bahan_ambient[]={0.0f, 0.5f, 0.6f, 1.0f};
GLfloat bahan_diffuse[]={9.0, 0.0, 0.0, 1.0};
GLfloat bahan_specular[]={1.0f, 1.0f, 1.0f, 1.0f};
GLfloat bahan_shininess[]={90.0f};
glMaterialfv(GL_FRONT, GL_AMBIENT, bahan_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bahan_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, bahan_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, bahan_shininess);
glPushMatrix();
glTranslatef(-4.0, 1.0, -8.0);
glRotatef(60, 1.0, 0.0, 0.0);
glutSolidTetrahedron();
glPopMatrix();
glFlush();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
octahedron();
icosahedron();
dodecahedron();
tetahedron();
glutSwapBuffers();
}
void inisialisasi(void)
{
int w=800, h=600;
glShadeModel(GL_FLAT);
glClearColor(1.0,1.0,1.0,0.0);
glClearAccum(0.0,0.0,0.0,0.0);
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0,(GLfloat) w/(GLfloat) h,1.0,20.0);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB |
GLUT_DEPTH);
glutCreateWindow("Grafika Komputer 3
Dimensi");
glutDisplayFunc(display);
inisialisasi();
glutMainLoop();
return 0;
}
GRAFIKA 3 DIMENSI
MATERI
•Sistem Koordinat
•Titik 3 Dimensi
•Definisi Obyek 3 Dimensi
•Implementasi Definisi Dari Struktur Face
•Implementasi Definisi Dari Struktur Obyek 3D
•Contoh Pernyataan Obyek Limas Segiempat
•Implementasi Pernyataan Obyek 3 Dimensi
•Implementasi Konversi Vektor 3D Menjadi Titik 2D
•Implementasi Konversi Titik 3D Menjadi Vektor 3D
•Implementasi Cara Menggambar Obyek 3D
•Implementasi Tilting
1. SISTEM KOORDINAT 3 DIMENSI
2. TITIK 3 DIMENSI
a. Titik 3D dinyatakan dengan P(x,y,z)
Typedef struct
{
float x,y,z;
} point3D_t
3. DEFINISI OBYEK 3 DIMENSI
a. Obyek face yang digabungkan
b. Face adalah
4. IMPLEMENTASI DEFINISI DARI STRUKTUR FACE
a. Typedef struct
{ int NumberofVertices;
short intpnt[32];
} face_t;
NumberofVerticesmenyatakan jumlah titik pada sebuah face
pnt[32] menyatakan nomor-nomor titik yang digunakan untuk
membentuk face, dengan maksimum 32 titik
5. IMPLEMENTASI DEFINISI DARI STRUKTUR OBYEK 3D
a. Typedef struct
{ int NumberofVertices;
point3D_t pnt[100];
int NumberofFaces;
face_t fc[32];
} object3D_t;
NumberofVertices menyatakan jumlah titik yang membentuk obyek.
pnt[100] menyatakan titik-titik yang membentuk face, dengan
maksimum 100 titik
NumberofFaces menyatakan jumlah face yang membentuk obyek
Fc[32]menyatakan face-face yang membentuk obyek
6. CONTOH PERNYATAAN OBYEK LIMAS SEGIEMPAT
a. Titik-titikyang membentukobyek:
Titik0 (0,150,0)
Titik1 (100,0,0)
Titik2 (0,0,100)
Titik3 (-100,0,0)
Titik4 (0,0,-100)
b. Face yang membentuk obyek:
Face 0 0,2,1
Face 1 0,3,2
Face 2 0,4,3
Face 3 0,1,4
Face 4 1,2,3,4
7. IMPLEMENTASI PERNYATAAN OBYEK 3 DIMENSI
a. object3D_t 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}}}};
Pernyataan
ini ditulis pada fungsi userdraw sebagai nilai dari obyek 3D yang akan
digambarkan
8. IMPLEMENTASI KONVERSI VEKTOR 3D MENJADI TITIK 2D
a. point2D_t Vector2Point2D(vector3D_t vec)
{ point2D_t pnt;
pnt.x=vec.v[0];
pnt.y=vec.v[1];
return pnt;
}
9. IMPLEMENTASI KONVERSI TITIK 3D MENJADI VEKTOR 3D
a. vector3D_t Point2Vector(point3D_t pnt)
{ vector3D_t vec;
vec.v[0]=pnt.x;
vec.v[1]=pnt.y;
vec.v[2]=pnt.z;
vec.v[3]=1.;
return vec;
}
10. IMPLEMENTASI CARA MENGGAMBAR OBYEK 3D
a. mat=tilting;
for(i=0;i<prisma.NumberofVertices;i++)
{vec[i]=Point2Vector(prisma.pnt[i]);
vec[i]=mat*vec[i];
}for(i=0;i<prisma.NumberofFaces;i++)
{for(j=0;j<prisma.fc[i].NumberofVertices;j++)
vecbuff[j]=vec[prisma.fc[i].pnt[j]];
for(j=0;j<prisma.fc[i].NumberofVertices;j++)
titik2D[j]=Vector2Point2D(vec[prisma.fc[i].pnt[j]]);
drawPolygon(titik2D,prisma.fc[i].NumberofVertices);
}
mat=tilting;
for(i=0;i<prisma.NumberofVertices;i++)
{vec[i]=Point2Vector(prisma.pnt[i]);
vec[i]=mat*vec[i];
}
Deklarasimat sebagai matrik tilting menyatakan
bahwa obyek yang digambar mengikuti pergerakan sumbu koordinat(tilting).
Setiap titik diubah menjadi vektor dengan
memperhatikan matrik transformasi yang dinyatakan dala mat.
11. IMPLEMENTASI TILTING
Tilting adalah matrik rotasi dari sumbu koordinat
dan semua obyek yang digambar didalamnya.
a. float theta=0.5;
matrix3D_t tilting=rotationXMTX(theta)*rotationYMTX(-theta);
Dalam deklarasi ini, matrik tilting adalah rotasi
terhadap sumbu Y sebesar-0.5 rad dan rotasi terhadap sumbu X sebesar0.5 rad.
b. for(i=0;i<prisma.NumberofFaces;i++)
{for(j=0;j<prisma.fc[i].NumberofVertices;j++)
vecbuff[j]=vec[prisma.fc[i].pnt[j]];
for(j=0;j<prisma.fc[i].NumberofVertices;j++)
titik2D[j]=Vector2Point2D(vec[prisma.fc[i].pnt[j]]);
drawPolygon(titik2D,prisma.fc[i].NumberofVertices);
}
Untuk setiap face pada obyek 3D:
(1)Ambilvektordarisetiaptitikpadaface
tersebut
(2)Konversikansetiapvektor3D
menjadititik2D
(3)Dari
hasilkonversidigambarkanpolygon
Download Materi Pemrograman Grafik
0 komentar:
Posting Komentar