Să se implementeze corelația curbelor traiectorie și viteză (cursul 9).

• Curba traiectorie este o curbă parametrică 3D
  • $Q(u) = (X(u), Y(u), Z(u))$
  • Un exemplu - curbă Bezier
    • 4 puncte de control
    • Formula parametrică: $Q(u) = P_0 \cdot (1-t)^3 + P_1 \cdot 3 \cdot t \cdot (1-t)^2 + P_2 \cdot 3 \cdot t^2 \cdot (1-t) + P_3 \cdot t^3$
• Curba de viteză corelează timpul cu distanța parcursă de obiect pe curba traiectorie
  • Distanța e măsurată prin lungimea arcului de curbă
  • Exemple: viteză constantă (curba este o linie dreaptă), accelerare lină la plecare și decelerare lină la sosire (curba ease-in ease-out)
  • $V(u) = (S(u), T(u))$, unde
    • $S(u) = a_{3s} \cdot u^3 + a_{2s} \cdot u^2 + a_{1s} \cdot u + a_{0s} $
    • $T(u) = a_{3t} \cdot u^3 + a_{2t} \cdot u^2 + a_{1t} \cdot u + a_{0t} $
  • Exemple pentru viteza constată:
    • $S(u) = u$
    • $T(u) = u$
  • Exemple pentru curba ease-in ease-out
    • dacă $u<0.5$ atunci $S(u) = 2 \cdot u^2$, altfel $S(u) = - 2 \cdot u^2 + 4 \cdot u - 1$
    • $T(u) = u$
• Corelația curbelor traiectorie și viteză
  • Curbele sunt parametrizate în funcție de $u$, nu de $t$
  • Pentru fiecare moment de timp $t_i$, $t_{initial} <= t_i <= t_{final}$
    • Se determină $u_i$, astfel încât $T(u_i) = t_i$
    • Se calculează $s_i = S(u_i)$, lungimea arcului de curbă parcurs până la momentul $t_i$
    • Se determină $u_k$, astfel încât lungimea arcului de curbă de la $Q(0)$ la $Q(u_k)=s_i$
    • Se calculează poziția de pe curba traiectorie la momentul $t_i$: $(X(u_k), Y(u_k), Z(u_k))$

• Se poate folosi implementarea propusă mai jos, care este o combinație între metodele prezentate la curs
• Se pot folosi si alte metode, atât timp cât ele sunt corecte și generale (adică funcționează pe orice formulă a curbelor traiectorie/viteză)

Metode importante

1. Popularea tablourilor corespunzătoare curbelor $V(u)$ și $Q(u)$: această metodă se apelează o singură data, în init()

• Se calculează și se memorează în câte un tablou timpi și distanțe corespunzătoare curbei $V(u)$, eșantionând $u$ cu un pas foarte mic:
  • $T(u_i)$ - timp calculat cu formula cubică polinomială
  • $S(u_i)$ - distanță calculată cu formula cubică polinomială
• Se calculează și se memorează în câte un tablou lungimi de arce si pozitii care corespund unor valori discrete ale lui $u$ (nu trebuie să fie același pas ca mai devreme):
  • $Q(u_k)$ - poziții calculate cu formula parametrică a curbei (de ex, Bezier)
  • $S(u_k)$ - distanță calculată pe baza pozițiilor $Q(u_k)$ de pe curbă și a aproximării distanței parcurse pe arcul dintre $Q(u_k)$ și $Q(u_k - pas)$ prin lungimea segmentului dintre $Q(u_k)$ și $Q(u_k - pas)$.
    • Atenție!! Trebuie să existe o corespondență între distanța calculată cu formula cubică polinomială și distanța calculată pe curba traiectorie (adică distanța maxim calculat polinomial (obținut pentru $u_i=1$) trebuie să fie egală cu distanța totală parcursă pe curba traiectorie (obținută pentru $u_k=1$). Un mod de a obține această corespondență este prin normalizarea distanțelor în intervalul [0,1]

2. Căutare binară:

• determină poziția într-un vector ordonat, pentru care o valoare dată este egală (sau aproximativ egală) cu o valoare din vector

3. Animația efectivă: animația se realizează în funcția update()

• Se realizează asemanator cu animația de la laboratorul 5 (cu free form deformation)
  • Se stabileste timpul total al animației - timpul de parcurgere a curbei de către un obiect (in secunde)
  • Se stabileste un numar de frame-uri intre care se realizează interpolare liniară (de exemplu, 10 sau 20)
  • Când se ajunge la finalul unui interval de interpolare (adica într-un key frame), se determină timpul (cu GetElapsedTime())
    • Atât timp cât nu s-a finalizat animația (timpul curent este mai mic decât timpul total de parcurgere), se determină (prin căutare binară), $u_i$ astfel încât $T(u_i)$ calculat prin formula cubică polinomială să fie egal cu timpul curent
    • Dacă s-a determinat $u_i$, atunci se poate afla și $S(u_i)$
    • Se determină $u_k$ (prin căutare binară), astfel încât $S(u_k)$ să fie egal cu $S(u_i)$ care fusese calculat mai devreme
    • Dacă s-a determinat $u_k$, atunci se poate afla și $Q(u_k)$
  • Dacă nu suntem într-un key frame, atunci calculăm pozițiile prin interpolare liniară

1. Să se aleagă o curbă traiectorie (să se aleagă fie între mai multe curbe predefinite, care au punctele de control stabilite, sau să se modeleze interactiv - de exemplu prin deplasarea punctelor de control)
2. Să se aleagă o curbă viteză (să se aleagă fie între mai multe curbe predefinite, sau să se modeleze interactiv)
3. Să se afișeze curba viteză în 2D
4. Să se afișeze curba traiectorie în 3D
5. Să se afișeze o animație a unui obiect 3D (de exemplu, o sferă), care se deplasează pe curba traiectorie pe baza caracteristicilor mișcării stabilite prin curba de viteză
6. Să se poată restarta animația (de exemplu, la apăsarea unei taste)
7. Să se poată modifica fie curba traiectorie, fie curba de viteză (de exemplu, la apăsarea unei taste) și să se reia animația

1. Definirea și redarea curbei traiectorie: 25 puncte
2. Definirea și redarea curbei de viteză: 25 puncte
3. Calculul poziției corespondente momentului $t$ de timp: 100 puncte
   1. calculul unui parametru $u_i$ care corespunde unui moment $t$ de timp astfel încât $T(u_i) = t$
   2. calculul lui $S(u_i)$
   3. calculul unui parametru $u_k$ care corespunde unei distanțe $S(u_i)$, astfel încât $S(u_k) = S(u_i)$
   4. calculul poziției $Q(u_k)$
4. Redarea și animația corectă unui obiect pe curba traiectorie (100 puncte)
5. Restartarea animației: 25 puncte
6. Selecția altor curbe de traiectorie / viteză și restartarea animației: 25 puncte

1. Să se modeleze interactiv curbele traiectorie / de viteză prin drag-and-drop pentru punctele de control
2. Alte elemente interesante