Transcript grafika - Budapest University of Technology and Economics

Geometriai modellezés
Szirmay-Kalos László
Virtuális világ létrehozása

Geometria
– 2D: pont, síkgörbe, terület, fraktál (D2)
– 3D: pont, térgörbe, felület, test, fraktál (D3)
Transzformáció (mozgatás)
 Optikai tulajdonságok

Görbék: 1D ponthalmazok
A pontok koordinátái kielégítenek egy egyenletet:
– implicit:
f(x, y) = 0
 2D egyenes: ax + by + c = 0
2
2
2
 Kör: (x–x0) +(y–y0) –R = 0
– parametrikus: x = x(t), y = y(t)
3D egyenes: x = x0 + vx t
y = y 0 + vy t
z = z 0 + vz t
 Kör: t  [0,1]
x(t) = x0 + R cos 2t
y(t) = y0 + R sin 2t

– explicit:

y = F(x)
2D egyenes: y = mx + b
f(r) = 0
n(r – r0) = 0
|r – r0 |2 – R2 = 0
r = r(t)
r = r0 + v t, t  [-∞,∞]
r = r0 + R(cos 2t, sin 2t)
Szabadformájú görbék

Definíció vezérlőpontokkal
Polinom: x(t) = S ai ti, y(t) = S bi ti
 Polinom együtthatók:

– Interpoláció
– Approximáció
r2
r1
r(t) ?
t2
t1
rn
tn
Lagrange
interpoláció
Vezérlő pontok: r1, r2, r3,..., rn
 Keresd: r(t) = S [ai, bi ] ti amelyre
r(t1) = r1, r(t2) = r2, … , r(tn) = rn,
 Megoldás:

r(t) = S Li(t) ri
r(tk) = S Li(tk) ri = rk
P j  i (t-tj)
Li(t) =
P j  i (ti-tj)
Pj  i(tk-tj)
Li(tk)=
Pj  i(ti-tj)
1 if i=k
=
0 if ik
LagrangeCurve
class LagrangeCurve {
vector<float3> cps;
vector<float> ts;
// control points
// parameter (knot) values
float L(int i, float t) {
float Li = 1.0f;
for(int j = 0; j < cps.size(); j++)
if (j != i) Li *= (t – ts[j])/(ts[i] – ts[j]);
return Li;
}
public:
void AddControlPoint(float3 cp) {
float ti = cps.size();
// or something better
cps.push_back(cp); ts.push_back(ti);
}
float3 r(float t) {
float3 rr(0, 0, 0);
for(int i = 0; i < cps.size(); i++) rr += cps[i] * L(i,t);
return rr;
}
};
Lagrange interpoláció
bázisfüggvényei
1
0
1
0.33
0.67
P j  i (t-tj)
Li(t) =
P j  i (ti-tj)
r(t) = S Li(t) ri
Lagrange interpoláció
problémái
Hermite interpoláció
vi =r’(ti)
ti
pi =r(ti)
ti+1 pi+1=r(ti+1)
vi+1=r ’(ti+1)
 r(t) = a3(t-ti)3+a2(t-ti)2+a1(t-ti)+a0
 ri’(t) = 3a3(t-ti)2+2a2(t-ti)+a1
a 0= p i
a1= vi
a2 =
a3 =
3(pi+1 - pi)
(ti+1- ti)2 2(pi - pi+1)
+
(ti+1- ti)3
r(ti) = a0 = pi
r(ti+1) = a3(ti+1-ti)3+a2(ti+1-ti)2+a1(ti+1-ti)+a0 = pi+1
r’(ti) = a1 = vi
r’(ti+1) = 3a3(ti+1-ti)2+2a2(ti+1-ti)+a1 = vi+1
vi+1+2vi
(ti+1- ti)
vi+1+vi
(ti+1- ti)2
Bezier approximáció

Keresd: r(t) = S Bi(t) ri
– Bi(t): ne oszcilláljon
– Konvex burok tulajdonság
– Bi(t)  0,
S Bi(t) = 1
r2
r1
r3
r(t)
r0
B2(t)
B0(t)
B1(t)
B3(t)
Bernstein polinomok
Newton féle binomiális tétel
n
S( )
1n = (t+(1-t))n =
i=0
n i
n-i
t
(1-t)
i
Bi(t)
Bi(t)  0, S Bi(t) = 1: OK
Bezier approximáció
1
n=3
0
1
n i
Bi(t) = i t (1-t)n-i
()
r(t) = S Bi(t) ri
BezierCurve
class BezierCurve {
vector<float3> cps;
// control points
float B(int i, float t) {
int n = p.size()-1; // n deg polynomial = n+1 pts!
float choose = 1;
for(int j = 1; j <= i; j++) choose *= (float)(n-j+1)/j;
return choose * pow(t, i) * pow(1-t, np-i);
}
public:
void AddControlPoint(float3 cp) { cps.push_back(cp); }
float3 r(float t) {
float3 rr(0, 0);
for(int i = 0; i < cps.size(); i++) rr += cps[i] * B(i,t);
return rr;
}
};
Catmull-Rom spline
Minden két vezérlőpont közé egy görbe szegmens
Simaság: a sebesség is legyen közös két egymás utánira
vi+1
ri+1
ri-1
r0
ri
t0
vi =
ti-1
1
2
ti
rn
vi
ti+1
tn
ri+1 - ri
ri - ri-1
ti+1 - ti + ti - ti-1
Egy görbeszegmens: Hermite interpoláció
Legeslegelső és legutolsó sebesség explicite
CatmullRom
class CatmullRom {
vector<float3> cps;
vector<float> ts;
float3 Hermite(
// control points
// parameter (knot) values
float3 p0, float3 v0, float t0,
float3 p1, float3 v1, float t1,
float t ) {
???
}
public:
void AddControlPoint(float3 cp, float t) { ??? }
float3 r(float t) {
for(int i = 0; i < cps.size() - 1; i++) {
if (ts[i] <= t && t <= ts[i+1]) return Hermite(…);
}
}
};
Renner Gábor spline
A sebességeket és az időket találjuk ki abból, hogy görbén a mozgás
legyen egyenletes:
ti+1
ti-1
ri+1
Ai-1
ri-1
ri-2
Ai
ti+2
vi
ri+2
ri t i
1. ti+1 – ti  ívhossz
2. vi = [Ai(ri – ri-1) + Ai-1(ri+1 – ri)]/(Ai + Ai-1)
3. vi normalizálása
Felületek

Felület a 3D tér 2D részhalmaza:
– Koordináták kielégítenek egy egyenletet
– implicit:
f(x, y, z) = 0

gömb:
– parametrikus:

gömb
(x - x0)2 + (y - y0)2 + (z - z0)2 - R2 = 0
x = x(u,v), y = y(u,v), z = z(u,v),
u,v [0,1]
x = x0 + R cos 2u sin v
y = y0 + R sin 2u sin v
z = z0 + R cos v
u,v  [0,1]
– explicit (magasságmező):
z = h(x,y)
r(u,v) = rv(u)
Tórusz (donut)
x(u )  R  r cos(u )
y (u )  r sin(u )
y
z (u )  0
x(u)
v
r
u
x
R
z
x(u, v)  x(u ) cos(v)  ( R  r cos(u )) cos(v)
y (u, v)  y (u )  r sin(u )
z (u, v)  x(u ) sin(v)  ( R  r cos(u )) sin(v)
Szabadformájú felület: r(u,v)

Definíció vezérlőpontokkal
r(u,v) = S S Bi (u) Bj(v) ri,j
r(u,v) = rv(u) = S Bi (u) ri (v)
ri (v) = S Bj(v) ri,j
Szabadformájú felületek
Vezérlő háló:
r(u,v) = S S Bi,j (u,v) ri, j
= S S Bi(u) Bj(v) ri, j
Vezérlőpontok módosítása
Poligonháló finomítása
Subdivision görbék
= 1/2 + 1/4 S
Catmull-Clark
subdivision felület
= 1/4S
i = 1/2S
= 1/v2S
= 1/4S
+2/v2S i +(v-3)/v
+ 1/2 i
Durva poligon modell
Subdivision: 1. szint
Subdivision: 2. szint
Testek

Ellenpéldák

Érvényes test:
– Nem lehet alacsonyabb dimenziójú elfajulás

Érvényes testet eredményező módszerek
– 2.5 dimenziós eljárások
– B-rep
– Constructive Solid Geometry
B-rep

Test = határoló felületek

Topológiai érvényesség (Euler tétel ha egy
darabból áll és nincsenek benne lyukak) :
csúcsok + lapok= élek + 2
Euler operátorok

Lap kihúzás

Lap felvágás
Él törlés
 Csúcs szétvágás

Kezdeti test
Lap kihúzás
Lap kihúzás
Még egy
Még mindig
Subdivision simítás
Poligon modell: leves
1. háromszög 2. háromszög
Háromszög leves
csúcsok
Sokszögek
lapok
csúcsok
x1 x2 x3 x4 x5 x6
y1 y2 y3 y4 y5 y6
z1 z2 z3 z4 z5 z6
e1 e2 e3 e4 e5
u1 u2 u3 u4 u5
x1 x2 x3 x4 x5 x6
y1 y2 y3 y4 y5 y6
z1 z2 z3 z4 z5 z6
Poligon modell: hierachikus
lapok
v11
v12
v13
…
v21 v31 v41
v22 v32 v42
v23 v33 v43
…
… …
x1 x2 x3 x4 x5 x6
csúcsok y1 y2 y3 y4 y5 y6
koordinátái z1 z2 z3 z4 z5 z6
él1
él2
él3
Poligon modell: half edge
(half edge, winged edge, radial edge)
struct hedge {
vertex* endVertex;
hedge* pairHedge;
face* borderedFace;
hedge* nextHedge;
};
struct vertex {
float x, y, z;
hedge* oneEmanatingHedge;
};
struct face {
hedge* oneBorder;
};