Számítógépes grafika, PPKE-ITK, Benedek Csaba, 2010 2D képszintézis 4. előadás Számítógépes grafika, PPKE-ITK, Benedek Csaba, 2010

Számítógépes grafika feladata modellezés Virtuális világ modell képszintézis világ = sík Metafórák: 2D rajzolás

2D képszintézis feladatai 1. Vektorizáció: A virtuális világban tárolt szabadformájú elemeket (például körívek, interpolációs vagy spline görbék) pontok, szakaszok és poligonok halmazával közelítjük. 2. Transzformáció: a lokális koord.rsz →világ koord.rsz → képernyő koord.rsz, homogén lineáris transzformáció 3. Vágás: csak az jeleníthető meg, ami a nézet téglalapján belül van, 4. Pásztakonverzió, avagy raszterizáció: geometriai elemek közelítése pixelek átszínezésével

2D képszintézis

Vektorizáció A szabadformájú elemek közelítése pontokkal, szakaszokkal vagy poligonokkal Homogén lineáris transzformáció és vágás nem változtatja meg az elemek típusát Felosztás finomsága paraméter Pl néhány pixel hosszú szakaszok nem növelik jelentősen a raszterizáció amúgy is jenlévő hibáját r(t) [0,1]: 0, t1 , t2 , ... , tn , 1 r1 =r(0), r2 = r(t2), … , rn = r(1) r2 rn r1

Modellezési transzformáció Sx 0 0 0 Sy 0 0 0 1 cos f sin f 0 -sin f cos f 0 0 0 1 1 0 0 0 1 0 px py 1 TM ux uy 0 vx vy 0 ox oy 1 (x, y) v u [x, y, 1] = [a, b, 1]  (a, b) o [0, 0, 1] [ox oy 1 ] [1, 0, 1] [ox+ux oy+uy 1 ] p= [x,y] u=[ux,uy] v=[vx,vy] [0, 1, 1] [ox+vx oy+vy 1 ] p=(x, y) = o + au + bv

Ablak-nézet transzformáció ww vw ablak nézet (x, y) (X, Y) wh vh TV (vx,vy) (wx,wy) X = (x-wx) vw/ww + vx Y = (y-wy) vh/wh + vy vw/ww 0 0 0 vh/wh 0 vx-wxvw/ww vy-wyvh/wh 1 [X, Y, 1] = [x, y, 1]

Összetett transzformáció [X, Y, 1] = ([a, b, 1] TM ) TV [X, Y, 1] = [a, b, 1] (TM TV ) = [a, b, 1] TC TV nézeti transzformáció számítása for each object o TM előállítása TC = TM TV for each point of object o: transzformáció TC -vel endfor

Vágás Ablakra vs. nézetre vágás Vektorizáció miatt: pont, szakasz, poligon Pontok vágása x > xmin, x < xmax, y > ymin, y < ymax ymax ymin xmin xmax

Szakasz vágás félsíkra xmax xi, yi x2, y2 x1, y1 x(t) = x1 + (x2 - x1)t, y(t) = y1 + (y2 - y1)t x = xmax Metszéspont: xmax= x1 + (x2 - x1)t  t = (xmax-x1)/(x2-x1) xi = xmax yi = y1 + (y2 - y1) (xmax-x1)/(x2-x1)

Cohen-Sutherland vágás Kód=C3C2C1C0 1001 1000 1100 C3 0001 0000 0100 C1 0110 0011 0010 C0 C2

Cohen-Sutherland algoritmus #define Code(p) ((p.x < xmin) + ((p.y < ymin)<<1) + \\ ((p.x > xmax)<<2) + ((p.y > ymax)<<3) bool LineClip(Vector& p1, Vector& p2) { for( ; ; ) { int c1 = Code(p1), c2 = Code(p2); if (c1 == 0 && c2 == 0) return true; if ((c1 & c2) != 0) return false; if ((c1 & 1)) p1 = IntersectX(p1, p2, xmin); else if ((c1 & 2)) p1 = IntersectY(p1, p2, ymin); else if ((c1 & 4)) p1 = IntersectX(p1, p2, xmax); else if ((c1 & 8)) p1 = IntersectY(p1, p2, ymax); else if ((c2 & 1)) p2 = IntersectX(p1, p2, xmin); else if ((c2 & 2)) p2 = IntersectY(p1, p2, ymin); else if ((c2 & 4)) p2 = IntersectX(p1, p2, xmax); else if ((c2 & 8)) p2 = IntersectY(p1, p2, ymax); }

Poligonok vágása Továbbra is: négy félsíkra vágás... Csúcspont belső pont: a vágott poligonnak is belső pontja Csúcspont külső pont: eldobhatjuk, de egy új csúcspont is létrejöhet, ha az aktuális él metszi a vágás egyenesét!

Sutherland-Hodgeman poligonvágás PolygonClip(p[n]  q[m]) m = 0; for( i=0; i < n; i++) { if (p[i] belső) { q[m++] = p[i]; if (p[i+1] külső) q[m++] = Intersect(p[i], p[i+1], vágóegyenes); } else { if (p[i+1] belső) }

Konkáv poligonok vágása Konkáv poligon több részre eshet szét q[2] q[5] q[1] q[6] q[3] q[7] q[4] q[0] Kétszeres él = nem él valójában

Raszterizáció Alakzatok formáinak közelítése: pixelek átszínezése útján Alapegység: pixel egy geometria objektumhoz több ezer/millió pixel tartozhat Következmény: az elvárt sebesség nagyságrendileg haladja meg az eddigi műveleteket!

Pászta konverzió (raszterizáció) model Geometriai primitívek: 0.1-1 microsec / primitív transzformáció vágás raszterizáció Pixel műveletek Pixelek 10-50 nanosec / pixel rasztertár

Szakasz rajzolás Egyenes egyenlete: y = mx + b Egyeneshúzás: m=(y2-y1)/(x2-x1) b=y1-x1*(y2-y1)/(x2-x1) for( x = x1; x <= x2; x++) { Y = m*x + b; y = Round( Y ); write( x, y ); } x1 x2

Inkrementális elv Y(X) kiszámítása Szakasz rajzolás: Y(X) = F( Y(X-1) ) = Y(X-1) + dY/dX Szakasz rajzolás: Y(X) = mX + b = m(X-1)+b+m Y(X) = F( Y(X-1) ) = Y(X-1) + m Összeadás: fixpontos ábrázolás: y = Y 2T T: hiba < 1 a leghosszabb műveletsornál N 2-T < 1: T > log2 N round( y ): y+0.5-t csonkítjuk

DDA szakaszrajzolás DDADrawLine(x1, y1, x2, y2) { m = (y2 - y1)/(x2 - x1) y = y1 + 0.5 FOR X = x1 TO x2 { Y = round(y) trunc(y) WRITE(X, Y, color) y = y+m }

DDA szakaszrajzoló hardver X Y X számláló y regiszter 0.5 = .1000000 CLK S x1 y1 m

Bresenham szakaszrajzoló algoritmus Lásd tankönyv 103. oldal...

Terület elárasztás működése Flood(x, y) { if (pixel[x][y] belső pont) { Write(x, y, color); Flood(x, y-1); Flood(x, y+1); Flood(x-1, y); Flood(x+1, y); } 2 2 1 2 mag 1 2 1 1 Belső pont = sötétkék

Területkitöltés Geometriai reprezentáció alapján Belső pixel p1,p2,...,pn csúcsok p1-p2, p2-p3,...,pn-p1 élek Belső pixel páratlanszor metszünk élt, ha végtelenből jövünk végtelen: vágás után a nézet széle

Területkitöltés p2 p4 x1 x4 x3 x2 y p1 p3

Kitöltés gyorsítása Vizsgálatok csak az aktív élekre Metszéspontszámítás inkrementális elv szerint Dx/Dy Dx/Dy y x(y) x(y+1) x(y+2)

Aktív él lista AET: aktív éltábla AET ymax Dx/Dy x next ymin=1024 ymax Dx/Dy x1 next ymax Dx/Dy x1 next ymin=1 ET: éltábla ymin=0

2. rész - ANIMÁCIÓ modellezés Virtuális világ modell világ = sík képszintézis világ = sík Metafórák: 2D rajzolás

T1(t) TV(t) T2(t) Animáció = időfüggés Nézeti transzformáció (kamera pozíció, orientáció, látószög, vágósík) T1(t) TV(t) T2(t) Transzformációk alak szín megjelenítési attribútumok, stb

Valós idejű animáció Óra inicializálás (tstart) do t = Óra leolvasás Legalább 15 ciklus másodpercenként Óra inicializálás (tstart) do t = Óra leolvasás for each object o: modellezési transzf TM, o = TM, o(t) Nézeti transzformáció: TV = TV(t) Képszintézis while (t < tend)

Folyamatás mozgatás - OpenGL Követelmények: animáció folyamatosan fusson (azaz a felhasználó-nak ne kelljen minden lépésnél „léptetni” a rendszer reagáljon a felhasználói beavatkozásra (pl leállítás, lövés…) nem jó egyszerű végtelen ciklus-hurok! Megoldás: olyan ciklus, amely felváltva hajt végre egy-egy lépést a rendszer eseménykezelő hurkából és a program szimulációs hurkából

GLUT Üresjárati eseménykezelő függvény: Idő lekérdezés: Minta program: glutIdleFunc(myIdleFunc) Idő lekérdezés: glutGet(GLUT_ELAPSED_TIME) Minta program: long oldTime; void IdleFunc(void) { long newTime=glutGet(GLUT_ELAPSED_TIME); myStepFunction(newTime-oldTime); oldTime=newTime; }

Dupla buffer animációhoz Inicializálás: glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glClear(GL_COLOR_BUFFER_BIT); rajzol… glutSwapBuffers( ); Rasztertár 1. monitor Rasztertár 2.

Valószerű mozgás Fizikai törvények: Fiziológiai törvények Newton törvény ütközés detektálás és válasz: impulzus megmaradás Fiziológiai törvények csontváz nem szakad szét meghatározott szabadságfokú ízületek bőr rugalmasan követi a csontokat Energiafelhasználás minimuma

Newton törvény m d2 F/m = r dt2 = rL d2 TM(t) dt2 r(t) = rL TM(t) Az erő rugalmas mechanizmuson keresztül hat, azaz folytonosan változik TM(t) C2 folytonos

TM(t): Mozgástervezés Követelmény: ált. C2 , néha (C1,C0) folytonosság Mozgás = a transzformációs elemek időbeli változtatása Tetszőleges pozíció+orientáció megadható az alábbi mátrixszal: De az orientáció (A mátrix) szabadsági foka csak 3! szabályos orientáció: sorvektorok egymásra merőleges egységvektorok TM(t)= a11 a12 a13 0 a21 a22 a23 0 a31 a32 a33 0 px py pz 1 Forduló, billentő csavaró szög

TM(t): Mozgástervezés TM(t) mátrixelemek nem függetlenek! Tervezés független paraméterek terében  pozíció: px, py, pz orientáció: , ,    p(t)=[px, py, pz, , ,  ](t) TM(t)= cos sin -sin cos 1 cos -sin 1 sin cos 1 cos sin -sin cos 1 px, py, pz, 1

Orientáció tervezés – gondok… Változó orientáció-animálás a , ,  csavaró-billentő-forduló szögek független interpolációjával PRO: minden pillanatban érvényes orientációt kapunk KONTRA: képzeletbeli tengelyek körül forgatunk, ezért a mozgás nem lesz valósszerű  a paraméterek egyenletes változtatása egyenetlen mozgást eredményez, a képzeletbeli tengelyek láthatóvá válnak megoldás: interpoláció kvaterniókkal (érdeklődőknek részletek: Szirmay-Kalos László et. al. „Háromdimenziós grafika, animáció és játékfejlesztés” 312 oldal – lásd könyvtárban)

Mozgástervezés a paramétertérben p(t) elemei ált. C2 , néha (C1,C0) folytonosak p(t) elemeinek a definíciója: görbével direkt módon (spline) képlettel: script animation pl: origóból (vx , vy) kezdősebességgel kilőtt lövedék mozgása x(t)=vx t , y(t) = vy t - g t2/2 kulcsokból interpolációval: keyframe animation görbével indirekt módon: path animation mechanikai modellből az erők alapján: physical anim. mérésekből: motion capture animation

Interpoláció: 3-d rendű spline r (t) = ai (t- ti )3 + bi (t- ti ) 2 + ci (t- ti ) 1 + di ha ti ≤t< ti+1 vi vi+1 C2 folytonosság követelményéből: spline Ismeretlen vi -k meghatározása: ri’’(ti+1)= ri+1’’(ti+1) + sebesség a kezdő és végpontban bonyolult lineáris egyenletrendszer megoldását igényli  nem vezérelhető lokálisan  Tervezési paraméterek alapján: Kohanek-Bartels, Catmull-Rom Feladjuk a C2 folytonosság követeleményét Legalább szép sima legyen a pálya… r(ti) = ri, r(ti+1) = ri+1 r’(ti) = vi r’(ti+1) = vi+1 ri+1 r1 rn r0 ri t0 t1 ti ti+1 tn

Catmull-Rom „spline” ri+1 - ri ri - ri-1 vi = ti+1 - ti ti - ti-1 r (t) = ai (t- ti )3 + bi (t- ti ) 2 + ci (t- ti ) 1 + di ha ti ≤t< ti+1 Sebességek előírása: r’(ti) = vi r’(ti+1) = vi+1 vi+1+vi 2(ri+1 - ri) ai= – (ti+1 - ti )2 (ti+1 - ti )3 ri+1 ri-1 3(ri+1 – ri) vi+1 + 2vi bi= – rn vi (ti+1 - ti )2 (ti+1 - ti ) r0 ri t0 ti-1 ti ti+1 tn ci= vi di= ri ri+1 - ri ri - ri-1 vi = 1 2 + ti+1 - ti ti - ti-1

Pálya animáció: Transzformáció ym r(t) görbe: xm xm0(t) 0 ym0(t) 0 zm0(t) 0 r(t) 1 TM = r(t) zm Explicit up vektor Frenet keretek: zm = r’(t) zm = r’(t) xm = zm  up xm = zm  r’’(t) =r’(t)  r’’(t) ym = zm  xm ym = zm  x A függőleges, amerre az erő hat

Fizikai animáció Erők (gravitáció, turbulencia stb.) Tömeg, tehetetlenségi nyomaték (F = ma) Ütközés detektálás (metszéspontszámítás) Ütközés válasz rugók, ha közel vannak impulzus megmaradás alapján

Egy kis mechanika dr/dt = v dv/dt = F(r,v,t)/m -n(v·n) ÜtközésDetektál F(r,v,t) erő Középpont helyzete: r+v·t m v dr/dt = v dv/dt = F(r,v,t)/m metszés: t* Ha t* < dt Collision for ( t = 0; t < T; t += dt) { F = Erők számítása a = F/m v += a ·dt if ( ÜtközésDetektál ) ÜtközésVálasz r += v ·dt } ÜtközésVálasz n = CollisionNormal v’ -n(v·n) v v’ = [v - n(v·n)]-[n(v·n)·bounce]

Folytonos-Diszkrét ütközés detektálás pontra és féltérre n ·(r(t) - r0) > 0 r(ti) Sugár indul: r+v·t v n ·(r(t) - r0) = 0 r(ti+1) metszés: t* Ha t* < dt Collision n ·(r(t) - r0) < 0

Ferde hajítás Mozgás+ gravitáció: v=g∙t r(t+t)=r(t)+v(t)∙t v(t+t)=v(t)+g∙t v=g∙t 2 F0 7 1 3 v(0)=v0 Fg=mg 8 6 4 Fg=mg … 5 Rugalmas ütközés: lásd előbb

Vízszintes rugón mozgó labda r(t+t)=r(t)+v(t)∙t v(t+t)=v(t)+a(t)∙t a(t)=F(t)/m F(t)=-l(t)∙D D: rugóállandó l(t): megnyúlás t-ben Labda Rugó center l(t)

Golyók ütközése Lendület megmaradás: m1v1+m2v2=m1u1+m2u2 Mechanikai energia megmaradás 1/2 m1v12+ 1/2 m2v22= 1/2 m1u12+ 1/2 m2u22 v1 v2 u1 u2 Megoldás: (m1-m2)v1+2m2v2 (m2-m1)v2+2m1v1 u1= u2= m1+m2 m1+m2

Ferde ütközés v1┴= u1┴ v2┴= u2┴ m1v1II+m2v2II=m1u1II+m2u2II

Ütközés detektálás háromszög-háromszög gyorsítás: befoglalók O(n2)

Karakter animáció rL rw rw = rL · Rkéz·Talkar·Rkönyök·Tfelkar·Rváll·Tgerinc·Tember homogén koordináta 4-es

2D csont l  px,py 1 0 0 0 1 0 0 l 1 -sin cos 0 0 0 1 1 0 0 0 1 0 x, y, 1 1 0 0 0 1 0 0 l 1 cos sin 0 -sin cos 0 0 0 1 1 0 0 0 1 0 px py 1

Robot példa Head Torso Leg1 Leg2 Arm1 Arm2 glTranslatef(xr, yr, zr); T1, T2, T3 Head Torso Leg1 Leg2 Arm1 Arm2 T0 = robot előrehalad glTranslatef(xr, yr, zr); T1= kar elhelyése glTranslatef(xv, yv, zv); T2= forgatás glRotatef(angle, 1.0f, 0.0f, 0.0f); T3= skálázás glScalef(1.0f, 4.0f, 1.0f); T2 T1 T0 T3

Robot rajzolás + animáció void DrawRobot(float dt) { xr += vx*dt; yr += vy*dt; zr += vz*dt; glPushMatrix(); glTranslatef(xr, yr, zr); angle += av*dt; if (angle>30 || angle<-30) av*=-1; glColor3f(1, 0, 0); // red glTranslatef(xv, yv, zv); glRotatef(angle, 1, 0, 0); glScalef(1, 4, 1); // 1x4x1 cube DrawCube( ); glPopMatrix(); … Másik kéz, lábak, fej, törzs } Robot Arm1 Arm2 Head Torso

„Inverz kinematika” T0 = előrehaladás (forward, up) ??? T2 = forgatás (ang) forward up leg A láb (end effektor) földön legyen és ne csúszkáljon forward += leg * fabs(sin(angNew) - sin(angOld)); up = leg * (1 - cos(angNew));