2008. 01. 03. vizsga forrásának megtekintése

{{GlobalTemplate|Infoalap|SzgGrafVizsga20080103}}


__TOC__

==Infók <br>==
* rendelkezésre álló idő 80 perc.  <br>
* Összesen szerezhető pontok: 40 (=20+10+5+5)  <br>
* A vizsga sikeres = (1. feladat >= 6 pont) && (összes pont >= 16 pont);  <br>
* {{InLineFileLink|Infoalap|SzgGrafVizsga20080103|megooldas.doc|Hivatalos megoldás}}

==1. feladat <br>==
'''Írjon Color Trace (Vector s, Vector d, int depth) függvényt, amely megkapja a sugár kezdőpontját (s) és irányát (d, amely egység hosszú), a maximális rekurziós mélységet (depth), és kiszámolja a sugár mentén visszafelé haladó fény sugársűrűségét az r,g,b hullámhosszokon. A globális változóval megadott színtér (scene) nsik db síkból áll, amelyek mindkét oldala Phong-Blinn modell szerint spekulárisan (figyelem, nem Phong modellről van szó!) veri vissza a fényt. A sík két oldala ugyanolyan optikai paraméterekkel rendelkezik. Egy, globális változóval megadott irányfényforrás van (light), amely csak a (végtelen távoli) fényforrásból látható felületeket világítja meg (árnyékszámítás kell!).'''	<br>
Pontozás:  <br>
* megoldás elvének leírása képletekkel = 3 pont  <br>
* láthatósági feladat megoldása C++ nyelven = 6 pont  <br>
* spekuláris visszaverődés számítása Phong-Blinn modell szerint C++-ban = 6 pont (Phong modell 0 pontot ér)  <br>
* árnyékszámítás C++-ban = 5 pont  <br>
* Minden olyan program és pszeudokód, amely jelöléseiben vagy funkciójában nem felel meg a kitűzött feladatnak = -10 pont  <br>
A felhasználható osztályok:<br>
<pre>
struct Color{
float r,g,b;
Color (float r0, float g0, float b0){r=r0; g=g0; b=b0;}
Color operator* (Color c){return Color(r*c.r, g*c.g, b*c.b);}
Color operator* (float c){return Color(r*c, g*c, b*c);}
Color operator+ (Color c){return Color(r+c.r, g+c.g, b+c.b);}
};

struct Vector{
float x,y,z;
Vector (float x0, float y0, float z0){x=x0; y=y0; z=z0;}
Vector operator*(float c){return Vector(x*c, y*c, z*c);}
Vector operator+(Vector c){return Vector(x+c.x, y+c.y, z+c.z);}
};

struct Sik{
Vector r0;	//helyvektor Descartes koordinátái
Vector N;	//sík normálvektora (egységhosszú)
Color ks;	//a spekuláris fényvisszaverődési tényező
float shininess;	//a Phong-Blinn modell exponens
} scene[nsik];

struct Feny{
Vector D;	//fényforrás iránya
Color I;	//bejövő sugársűrűség
} light;
</pre>

'''A megoldás elve:'''

A Trace függvény megkeresi azt a síkot melyet a sugár legelőször metsz.
A sugár paraméteres egyenlete: r(t)=s+d*t.
A sík implicit egyenlete: (r-r0)*N=0.
Az előbbit az utóbbiba helyettesítve:
(r(t)-r0)*n=0
(s+d*t-r0)*n=0
(s-r0+d*t)*n=0
(s-r0)*n+d*t*n=0
d*n*t=-(s-r0)*n
Ebből meghatározható a metszésponthoz tartozó t érték: t=(r0-s)*n / d*n
Amiből a metszéspont: p=s+d*t

Ezután a metszéspontból sugarat indít a fényforrás irányával ellentétes irányba, és megnézi az metsz-e más síkot. Ha igen, akkor a pont árnyékban van, nincs abban a pontban direkt megvilágításból érkező fény. Ha nem, akkor a kimenő sugársűrűséghez hozzáadja a direkt megvilágításból származó fény hatását.
A Phong-Blinn modell a nézeti irány vektorának (V) és a megvilágítási irány vektorának (L) felezővektora (H=L+V/|L+V) és a felületi normálvektor (N) által bezárt szöggel (fi) számolja a spekulárisan visszavert sugársűrűséget az alábbi módon: Lout=Lin*ks*(cos fi)^shininess.
A cos fi skaláris szorzatként is megkapható egységvektorok esetén: cos fi=H*N

A direkt megvilágítás vizsgálata után az ideális visszaverődési irányból érkező sugársűrűségre számolja a spekuláris visszaverődést ugyanilyen módon és ezt is hozzáadja a kimenő sugársűrűséghez.
Ehhez a visszaverődés iránya: R=V+2*cos alfa, ahol az alfa a normálvektor és a nézeti irány által bezárt szög. A cos alfa=-N*V skaláris szorzatnak felel meg.
A visszaverődési irányból érkező sugársűrűség a függvény rekurzív hívásával kereshető meg, a sugarat a metszéspontból a visszaverődési irány felé indítva. (Persze csak a megadott mélységig)

-- [[BudaiPeterIstvan|buc]] - 2008.01.04.

==2. feladat <br>==
'''Melyik pixelt változtatja meg az alábbi program?''' <br>
Pontozás: <br>
* a pixel x,y koordinátáinak megadása számítással együtt = 10 pont <br>
* az alábbi sorok jelentésének taglalása = -5 pont <br>
<pre>
glDisable(GL_DEPTH_TEST);
glViewport(0 /*left*/, 0 /*bottom*/, 200 /*width*/, 200 /*height*/)
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90 /*fov*/, 1 /*aspect*/, 1 /*fp*/, 1000 /*bp*/);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0 /*eyex*/, 0 /*eyey*/, 6 /*eyez*/, 0 /*lax*/, 0 /*lay*/, -1 /*laz*/, 0 /*upx*/, 1 /*upy*/, 0 /*upz*/);
glTranslatef(-15.0, -10.0, -49.0);
glBegin(GL_POINTS);
glVertex4f(0, 0, 2, -2);
glEnd();
</pre>

'''Megoldás:''' <br>
Hát ahogy azt már órán számtalanszor hallhattuk, az OpenGL kódot visszafelé kell olvasni. :)<br>
Így:
<pre>
glBegin(GL_POINTS);
glVertex4f(0, 0, 2, -2);
glEnd();
</pre>
Felveszünk egy pontot a [0,0,2,-2] koordinátára.
<pre>
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0 /*eyex*/, 0 /*eyey*/, 6 /*eyez*/, 0 /*lax*/, 0 /*lay*/, -1 /*laz*/, 0 /*upx*/, 1 /*upy*/, 0 /*upz*/);
glTranslatef(-15.0, -10.0, -49.0);
</pre>
A modelview trafó mátrixát állítjuk be. Vagyis...<br>
glTranslatef(-15.0, -10.0, -49.0); -> Ez egy eltolás. Tehát eltoljuk a dolgokat a [-15,-10,-49] pontba. Ez mátrixban így néz ki:<br>
<math> \left[ \begin{array}{rrrr} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ -15 & -10 & -49 & 1 \end{array} \right] </math>
<br>Ha a fenti pontunkat megszorozzuk ezzel a mátrixszal, akkor eredményül a [30,20,100,-2] pontot kapjuk. Homogén osztás után ez a [-15,-10,-50,1] pont lesz.
Ezek után jön a gluLookAt(...), ami megmondja, hogy honnan is nézünk mi erre a pontra rá. Én a feladatban úgy emlékszem, hogy a szem z koordinátája is 0 volt, tehát a szem az origóban volt. A következő 3 koordináta adja meg a nézeti irányt, amiből kiderül, hogy a kamera a -Z irányba néz. (Ez nekünk történetesen pont jó, mert a mi pontunk is arra van.) Az utolsó 3 koordináta meg megadja a függőleges irányt. Ez az y tengely lesz.
<pre>
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90 /*fov*/, 1 /*aspect*/, 1 /*fp*/, 1000 /*bp*/);
</pre>
Itt a gluPerspective adja meg a perspektív transzformáció paramétereit. (A perspektív transzformációhoz érdemes megnézni a könyv 195. oldalát.)
<pre>
glViewport(0 /*left*/, 0 /*bottom*/, 200 /*width*/, 200 /*height*/)
</pre>
Ez pedig megadja, hogy a viewportunk 200x200-as.<br>
A mi pontunk z=-50-nél van, így ez a pixel a képernyőn a [(-15+50)*2, (-10+50)*2] vagyis [70,80] lesz.<br>
(Csak végig kell gondolni, hogy a z=-50-nél az a négyzet, amit lát a kamera (négyzet, mert aspect=1) [-50,-50] és [50,50] koordináták közötti terület. És ezt a négyzetet kell egy [0,0] [200,200] nagyságú négyzetre "transzformálni", ami a képernyő.)
-- [[ZoltanH|Mezzanine]] - 2008.01.03.




Magyarázat a mintamegoldáshoz:
A gluPerspective első két paramétere szerencsére biztositja hogy a nézeti gúlát ne kelljen normálni (a 90 fokos látószög és az 1-es aspect miatt), igy az x-y koordináták maradnak önmaguk a perspektiv transzf. után, csak a Z és a súly változik. A Z némileg összetettebb képlet szerint - de ez itt nem is fontos, kiszámitását mellőzzük -, a súly pedig egyszerüen a Kamera-koordinátarendszer Z értékének ellentettje lesz.

Most jön a vágás, még homogén alakban. Jelen esetben egyszerüen örülünk hogy minden érték abszolútértékben kisebb mint a súly - a Zről feltételezzük, mivel nem jegyeztük meg a pontos képletét -, vagyis a pont látható lesz.

Ezután elvégezzük a homogén osztást, majd végiggondoljuk hogy ha a pont x-y koordinátái a (+-1,+-1)-es négyzet közepéről nézve (-0.3,-0.2), akkor 200x200as, bal alulról tekintett rendszerben ez (70,80)-nak fog megfelelni. Ez egyébként a képernyőtranszformáció, ahol az x-y képernyőkoordinátákat úgy kapjuk hogy a homogén-osztott x-y eszközkoordinátát hozzáadjuk 1-hez, majd ezt szorozzuk a képszélesség felével.

Mivel egyetlen pontról szólt a feladat, a Z koordinátának a képernyő rendszerben már nincs jelentősége.
-- [[TuriAndras|leves]] - 2008.01.15.



==3. feladat <br>==
'''Milyen képfeldolgozási műveletet végeztünk?''' <br>
Eredeti kép részlete: <br>
(a sötét képen fehér pixelek voltak "elszórva") <br>
Feldolgozott kép részlete: <br>
(a fehér pixelek eltűntek a képről) <br>
'''Adott egy kép salt and pepper típusú zajjal, majd a másodikon már nincs ilyen zaj => rank v median szűrés''' <br>
Írja le a művelet lényegét! (5 pont)

==4. feladat <br>==
'''Milyen képfeldolgozási műveletet végeztünk?''' <br>
[https://wiki.sch.bme.hu/pub/Infoalap/SzgGrafVizsga20070116/taurus1_FS2.PNG Adva volt ez a kép és a "párja"]
'''(Adott egy szürkeárnyalatos kép, a második fekete-fehér, láthatóan ditheringes de nem mátrixos. => 1 bitre redukálunk, dithering, mintha még FS-hibapropagáció is lett volna, de ez nem biztos)''' <br>
Írja le a művelet lényegét! (5 pont)


-- [[KocsisIstvan|Sirály]] - 2008.01.03.
-- [[KovacsZoltan]] - 2008.01.03.


[[Category:Infoalap]]