Table des matières

• 1  Introduction
• 2  Théorie
  • 2.1  Notations
  • 2.2  Mécanique
  • 2.3  Approche Lagrangienne et Eulerienne
  • 2.4  Equation de la dynamique
  • 2.5  En résumé
• 3  Approche pseudo-physique de la forme des vagues
  • 3.1  Forme de vagues
    • 3.1.1  Forme sinusoidale
    • 3.1.2  Quelle équation résolvons nous?
  • 3.2  Mise en place de la dispersion
    • 3.2.1  Condition de pression à la surface
    • 3.2.2  Equation de la surface libre
    • 3.2.3  Dispersion
    • 3.2.4  Ondes de capillaritée
  • 3.3  Modélisation de la Houle
    • 3.3.1  Courbes Trochoïdes
  • 3.4  Le phénomène de houle
    • 3.4.1  Le modèle de houle de Gerstner (1802)
    • 3.4.2  Le modèle de houle d'Airy (1845)
    • 3.4.3  Le modèle de houle de Stokes (1847)
    • 3.4.4  Le modèle de houle de Biesel
  • 3.5  Le modèle paramétrique
    • 3.5.1  Propagation
    • 3.5.2  Zone de compression
    • 3.5.3  Position de repos de la surface
  • 3.6  Représentation des ondes
    • 3.6.1  Vecteur d'onde
    • 3.6.2  Relation de dispersion
    • 3.6.3  Amplitude
    • 3.6.4  Etude des phénomènes liés à la profondeur
  • 3.7  Visualisation
    • 3.7.1  La réflexion spéculaire
    • 3.7.2  Résultats
• 4  Utilisation du Bruit de Perlin
  • 4.1  But de la méthode
  • 4.2  Bruit de Perlin
    • 4.2.1  Théorie
    • 4.2.2  Interpolation
    • 4.2.3  Mise en place de l'aspect fractal.
    • 4.2.4  Application aux textures
    • 4.2.5  Application au déplacement
    • 4.2.6  En Résumé
  • 4.3  Implémentation sous OpenGL
    • 4.3.1  Mise en place des classes de gestion des surfaces
    • 4.3.2  Mise en place du Bruit de Perlin
    • 4.3.3  Mise en place de la scène
  • 4.4  Bruit de Perlin particulier: Ridged Perlin et son lien avec l'océan
    • 4.4.1  Théorie
    • 4.4.2  Implémentation en OpenGL et limitations
  • 4.5  En Résumé
• 5  Visualisation par Ray Tracing
  • 5.1  Introduction
    • 5.1.1  Généralitées
    • 5.1.2  But de la partie
    • 5.1.3  Introduction à Pov-Ray
  • 5.2  Mise en place de la scène de Base
  • 5.3  Cas du Bump Mapping
  • 5.4  Height Field
  • 5.5  Isosurface
    • 5.5.1  Méthode
    • 5.5.2  Cas d'un petit rectangle
  • 5.6  Visualisation de surfaces étendues
  • 5.7  Interpolation entre les bruits
  • 5.8  Cas de scènes complexes
  • 5.9  En Résumé
  • 5.10  Animations
  • 5.11  Possibilité de lien avec l'aspect physique et difficultés liées
  • 5.12  En Résumé
• 6  Discussion et Conclusion
  • 6.1  Discussion
  • 6.2  Travail Future
  • 6.3  Conclusion

1  Introduction

2  Théorie

2.1  Notations

2.2  Mécanique

• Mécanique du point matériel. Cette mécanique s'adresse à des points (en interactions ou non) de dimensions nulles. Dans cette hypothèse, seul trois degrés de libertés sont présents pour chaque point. Ces degrés correspondent aux translation suivant x,y et z (la rotation n'ayant pas de sens pour un point de dimension 0). Dans cette hypothèse, la loi fondamentale s'appliquant dans le cas classique est celle de Newton stipulant que:

  m a(x

  )=

  Σ k

  Fk(x,t)   ,     (1)

  où m est la masse de la particule, a son accélération dans un référentielle Galiléen, F_k les forces extérieures exercées sur la particule, et x la position de celle çi. On notera également que, connaissant à chaque instant t la position x(t) de la particle, on peut relier son accélération à sa position par une simple dérivé seconde:

  a(t)=

  d x d t

  (2)

  En remplaçant cette équation dans la précédente, on obtient une équation différentielle du second ordre. On remarquera qu'en toute généralité, F peut également dépendre comme paramètre des dérivés de x par rapport au temps. Cette partie simple de la mécanique peut donc déja faire intervenir des équations différentielles ordinaires non linéaires et complexes. Un exemple simple étant le problème à trois corps dont la solution analytique n'existe pas, et dont la solution numérique possède un comportement chaotique (la moindre perturbation initiale va entrainer un changement très important de la solution lorsque t croît).
• Mécanique des systèmes rigides. Dans ce cas, on ne considère plus un unique point, mais un solide rigide pouvant être en mouvement. On a alors 6 degrés de libertés en notant les trois translation et les trois rotations. Ce système s'adresse en particulier aux mouvements de robots automatiques. Chaque partie peut être modélisée par des jointures d'un type donné (glissière, pivôt, encastrement, ...). Chaque jointure limitant le nombre de degré de liberté. On peut donc connaître le comportement du système lorsque l'ensemble des translations et angles sont définis. L'aspect dynamique fait, de plus, intervenir un ensemble de moments dépendant de la distribution de masse dans ce solide. On notera l'exemple des moments d'inertie s'opposant aux variations de la rotation du solide. Les équations régissant la dynamique font donc appels à la loi de Newton plus l'équation des moments d'inertie.
• Mécanique des milieux continus. Dans cette dernière mécanique, on considère que l'on a non seulement les déformations solides: translation, rotation et même aggrandissement, mais également toutes déformations internes. Ainsi les positions relatives des points à l'intérieur des matériaux ne sont plus fixes mais dépendent de leurs emplacements initiaux et du temps. Dans ce cas, les variations dynamiques dépendent non seulement du temps, mais également de la position. Les équations régissant ces systèmes sont donc des équations aux dérivés partielles (PDE). Celle çi sont évidement très complexes à résoudre, et, à l'exception de quelques cas très simples, les solutions analytiques n'existent pas. Un exemple de milieu déformable d'un coeur est montré en fig. 1

  ---

  

  
  
  

  Fig. 1: [

  
  
  Exemple d'un modèle déformable]Exemple d'un modèle déformable correspondant ici à un modèle informatique d'un ventricule d'un coeur.

  ---

2.3  Approche Lagrangienne et Eulerienne

---

Fig. 2: [

Exemple de particules fluides]Exemple de particule fluide.

---

• le terme lié à la dérivation temporelle qui est appelé dérivé locale
• le terme lié à la dérivation spatialle appelé terme de dérivé convective.

2.4  Equation de la dynamique

2.5  En résumé

• La dynamique des fluide correspond au cas de la mécanique des milieux continus avec un point de vue Eulerien.
• L'équation de Navier-Stockes provient de l'application du principe fondamentale de la dynamique sur une particule de fluide.
• Chaque terme de l'équation peut être simplifié suivant les hypothèses prises en compte.

3  Approche pseudo-physique de la forme des vagues

3.1  Forme de vagues

3.1.1  Forme sinusoidale

3.1.2  Quelle équation résolvons nous?

3.2  Mise en place de la dispersion

3.2.1  Condition de pression à la surface

3.2.2  Equation de la surface libre

3.2.3  Dispersion

3.2.4  Ondes de capillaritée

---

Fig. 3: [

Illustration de deux particules fluides acollées]Illustration de deux particules fluides. La tension capillaire tente d'empécher les deux particules de se séparer.

---

3.3  Modélisation de la Houle

3.3.1  Courbes Trochoïdes

• Pour d = 0 le point est le centre du disque, le trochoïde est alors une droite.
• Pour d < R ou v > rω La courbe s'appelle aussi cycloïde raccourcie et ressemble à une sinusoïde.

  ---

  

  
  
  

  Fig. 4: [

  
  
  trochoïde raccourcie ]trochoïde raccourcie avec R=1 et d=0,5

  ---

• Pour d = R ou v = rω On obtient la cycloïde.

  ---

  

  
  
  

  Fig. 5: [

  
  
  Cycloïde]cycloïde avec R=1 et d=1

  ---

• Pour d > R ou v < rω La courbe s'appelle aussi cycloïde allongée et peut prendre diverses formes, avec de plus en plus de points doubles à mesure que d augmente

  ---

  

  
  
  

  Fig. 6: [

  
  
  trochoïde allongée]trochoïde allongée avec R=2 et d=4

  ---

3.4  Le phénomène de houle

• La houle est un mouvement ondulatoire de la mer formé par une succession de vagues qui ne se brisent pas.
• Une houle se caractérise par son amplitude (en mètres) et sa longueur d'onde λ ou sa période (en secondes).
• Souvent, à peine sensible en pleine mer, la houle s'amplifie au voisinage de la côte et lorsque la profondeur diminue, elle peut alors atteindre plusieurs mètres et déferler.
  
  (Source Wikipédia)

3.4.1  Le modèle de houle de Gerstner (1802)

• Hypothèses sur la nature du fluide:
  • Parfait: viscosité nulle.
  • Fluide irrotationnel.
  • Tension superficielle négligée.
  • homogène: structure uniforme dont les éléments constitutifs sont de même nature ou répartis de façon uniforme (une seule phase).
• Hypothèses sur les conditions aux limites: La pression atmosphérique est constante, le vent ne souffle pas, le fond est horizontal et à profondeur infinie.
• Cambrure: (amplitude/longueur d'onde) doit être inférieure à 1/π.

  ---

  

  
  
  

  Fig. 7: [

  
  
  Mouvement de trochoïdes]Illustration d'un mouvement de trochoïdes

  ---

3.4.2  Le modèle de houle d'Airy (1845)

• Fluide parfait.
• Fluide irrotationnel.
• Tension superficielle négligée.
• Amplitude doit être très inférieure à la longueur d'onde.
• Amplitude doit être très inférieure la profondeur.

• ξ la hauteur de la surface libre par rapport à la position de repos
• ϕ le champ des vitesses
• L la longueur d'onde

• Les trajectoires sont des ellipses dont le demi-axe horizontal α est constant et le demi-axe vertical β diminue linéairement avec z.

  ⎧ ⎪ ⎪ ⎪ ⎨ ⎪ ⎪ ⎪ ⎩

  α= H 2   cosh(∥k∥ (z0+h)) sinh(∥k∥ h)   β= H 2   sinh(∥k∥ (z0+h)) sinh(∥k∥ h)

• Les trajectoires sont fermées, à la fin de chaque cycle de houle chaque particule revient à sa position initiale. Il n'y a pas de transport de masse. Les particules ne font qu'osciller (ceci n'est valide que pour des ondes de faibles amplitudes).L'eau n'est pas entrainés par l'onde.
• Sur le fond (z = - d = profondeur du fond marin) B s'annule, la trajectoire devient donc un segment de droite.

  ---

  

  
  
  

  Fig. 8: [

  
  
  Illustration de la houle d'Airy]Illustration de la houle d'Airy. Les orbites des mouvements circulaires diminuent si la profondeur d'eau diminue ou que les particules sont proche du fond

  ---

3.4.3  Le modèle de houle de Stokes (1847)

3.4.4  Le modèle de houle de Biesel

---

Fig. 9: [

Illustration de la houle de Biesel]Illustration de la houle de Biesel. L'orentation des orbites des mouvements des particules varient en fonction de la profondeur du fond

---

3.5  Le modèle paramétrique

---

Fig. 10: [

Paramètres pour la modélisation de la houle.]Représentation des paramètres nécessaires à la modélisation de la houle.

---

3.5.1  Propagation

3.5.2  Zone de compression

---

Fig. 11: [

Exemple de compression]Exemple de compression dans le cas d'une seule onde.

---

3.5.3  Position de repos de la surface

3.6  Représentation des ondes

3.6.1  Vecteur d'onde

• Son amplitude A
• Sa fréquence ω/2π
• Sa direction k/∥k∥.

3.6.2  Relation de dispersion

• Pour des ondes avec λ > 1.7 cm: onde gravitationnelle
• Pour des ondes avec λ < 1.7 cm: onde capillaire

3.6.3  Amplitude

---

Fig. 12: [

Gaussienne utilisée]Gaussienne utilisée pour une onde porteuse de pulsation 0.5.

---

3.6.4  Etude des phénomènes liés à la profondeur

• Eau profonde
  
  En eau profonde le terme tanh(∥k∥h) tend vers 1 On retrouve alors les 2 régimes d'ondes gravitationnelles et capillaires.
• Eau peu profonde (approche des plages)
  
  Les ondes conservent leur pulsation ω et le vecteur d'onde k obéit alors à la loi de dispersion.
  • La longueur d'onde diminue, les vagues se rapprochent les unes des autres. C'est un phénomène de réfraction. Ce phénomène de réfraction entraîne une déformation du front d'onde à l'approche des plages.
  • Enfin si l'amplitude est suffisante, la variation du vecteur d'onde entraîne un déphasage spatial progressif entre la crête et le creux de la vague. C'est ce qui fait que les vagues se penchent en avant à l'approche de la plage.

---

Fig. 13: [

Illustration du déphasage spatial]Illustration du déphasage spatial. Evolution des vecteurs d'ondes des crêtes et des creux des vagues pour illustrer el phénomène de déferlement

---

3.7  Visualisation

---

Fig. 14: [

Représentation du maillage triangulaire.]Représentation du maillage triangulaire utilisé pour notre modèle.

---

---

Fig. 15: [

Reflexion à la surface de la mer]Photo de la réflexion sur la surface de la mer (tiré de [13])

---

3.7.1  La réflexion spéculaire

---

Fig. 16: [

Calcul de l'effet spéculaire]Schéma représentatif de la direction des vecteurs pour la représentation de l'effet spéculaire

---

---

Fig. 17: [

Affichage avec texture.]Affichage des normales et de la texture.

---

3.7.2  Résultats

• Le nombre d'onde
  
  On peut modifier le nombre d'onde prise en compte dans la superposition.

  ---

  

  
  
  

  Fig. 18: [

  
  
  Variation du nombre d'onde.]Variation du nombre d'onde. Une seule onde pour la première image et une composition de dix ondes pour les deux dernières images.

  ---

• L'effet spéculaire

  ---

  

  
  
  

  Fig. 19: [

  
  
  Effet spéculaire.]La première image montre l'affichage des normales qui vont servir à calculer l'effet spéculaire. La seconde est l'affichage du résultat du rendu.

  ---

• Orientation et profondeur du fond marin
  
  On peut modifier la disposition du fond marin afin de représenter la mer soit en eau profonde soit à l'approche des plages. On peut ainsi modifier la profondeur et l'inclinaison du fond.

  ---

  
  

  
  
  

  Fig. 20: [

  
  
  ]Les deux premières images montrent l'effet de la variation de la profondeur (2 m et 8 m). La dernière image montre le cas du sol incliné.

  ---

• Limite du modèle
  
  Le modèle ne peut évidement pas modéliser les brisures de vagues. On observe alors un effet de recouvrement sur la représentation des vagues.

  ---

  

  
  
  

  Fig. 21: [

  
  
  Limitation du modèle]Limitation du modèle. Visualisation de l'effet de recouvrement du à la profondeur trop faible et amplitude des vagues trop grande.

  ---

4  Utilisation du Bruit de Perlin

COMPILE THIS:
main(k){float i,j,r,x,y=-16;while(puts(""),y++<15)for(x
=0;x++<84;putchar(" .:-;!/>)|&IH%*#"[k&15]))for(i=k=r=0;
j=r*r-i*i-2+x/25,i=2*r*i+y/10,j*j+i*i<11&&k++<111;r=j);}

4.1  But de la méthode

4.2  Bruit de Perlin

4.2.1  Théorie

---

   

Fig. 22: [

Construction du bruit de perlin par interpolation.]Construction de la fonction γ du bruit de perlin par interpolation de positions aléatoires. La première figure montre les points rouges correspondants aux valeurs de k₀ alors que la seconde figure montre γ interpolant ces valeurs.

---

---

Fig. 23: [

Bruit de Perlin simple en deux dimensions.]Bruit de Perlin simple pour le cas à deux dimensions.

---

---

Fig. 24: [

Bruit de Perlin simple en deux dimensions en couleur.]Bruit de Perlin simple pour le cas à deux dimensions à valeurs vectorielles. Ici la sortie est codée en rouge, vert et bleu.

---

4.2.2  Interpolation

• Interpolation Linéaire
  
  Le cas le plus simple consistant en l'interpolation linéaire (et bi/tri linéraire en deux puis trois dimensions) est simplement donné par
  f(u) = u f(0)+(1−u)f(1) ,
  où u est la variable normalisée telle que u=x−⌊ x ⌋/⌈ x ⌉ − ⌊ x ⌋, avec ⌊ ⌋, l'opérateur floor (entier inférieur le plus proche) et ⌈ ⌉ l'opérateur ceil (entier supérieur le plus proche). Évidemment, lorsque le vecteur des points est disposé de façon uniforme sur Z, le dénominateur ⌈ x ⌉ − ⌊ x ⌋ est constant et se simplifie pour donner 1.
  
  En notant I l'opérateur d'interpolation défini ainsi, on peut exprimer l'interpolation bilinéraire:
  f(u,v) = I(f(u,0),f(u,1)) ,
  où l'on voit que l'on réduit l'interpolation en dimension 2 à deux interpolation suivant la première dimension puis une suivant la seconde.
  
  La méthode peut se mettre aisément sous forme récursive par

  f(u)=I(f[

  ⎛ ⎝

  (ui)i∈[1,N−1],0

  ⎞ ⎠

  ,f

  ⎛ ⎝

  (ui)i∈[1,N−1],1

  ⎞ ⎠

  ]) ,

  qu'il est facile d'utiliser en dimension 3 notamment. Ici la variable u est toujours normalisée entre [0,1] de la même façon.
  
  
• Interpolation Cubique
  
  Le point négatif de l'interpolation linéraire est que celle-ci donne un aspect triangulaire en dimension 2 ou supérieure. On peut ainsi mentionner un autre interpolation également très répendue : l'interpolation cubique (avec ces généralisations bi/tricubique). Celle çi peut s'exprimer avec la formule d'interpolation de Lagrange [22]. L'interpolation est cette fois meilleure que par une simple fonction linéaire, cependant l'algorithme est plus lourd à gérer car il nécessite la valeur de f des deux précédécésseurs et des deux successeurs⁵. Dans le cas de points régulièrement espacés par pas de 1, on note x₀,x₁,x₂,x₃ les points connus localement où x₀=⌊ x−1⌋ et x_i+1=x_i+1. On peut alors exprimer l'interpolation par

  f(x) = (f(x3)−f(x2)+f(x1)−f(x0)) u3   +(−f(x3)+f(x2)−2 f(x1)+ 2 f(x0)) u2   +(f(x2)−f(x0)) u   +f(x1)

  .

  
  
  
• Interpolation Sinusoïdale
  
  Une méthode intermédiare peut également être considérée en utilisant la fonction de base de forme sinusoidale ϕ(u)=1/2(1−cos(π u)). Cette fois, on peut approximer l'allure d'un polynome d'ordre >1 en utilisant uniquement les deux plus proches voisins⁶ avec la relation
  f(x) = ϕ(x) f(0)+(1−ϕ(x)) f(1) .
  
  
  
• Interpolation Splines
  
  D'autres méthodes permettent d'obtenir des courbes encore plus lisses. On citera ainsi les Splines (notamment celles d'ordres 3) permettant d'obtenir des courbes C² [23]. Le temps de calcul est globalement le même que pour l'interpolation cubique mais celle-ci possèdent des propriétés encore plus interessantes aux niveaux des raccords. Nous pourrions implémenter cette méthode, cependant ce rapport ne se spécialise pas dans la mise au point optimale du bruit de Perlin, et la méthode cubique étant déjà suffisement lente lors de l'implémentation, nous laissons la mise en place de l'interpolation spline pour une amélioration future possible.

double interpolate_1D_linear(double v0,double v1,double x)
  res = v1*(1-x)+v2*x;

double interpolate_1D_sinus(double a,double b,double x)
  double f=(1-cos(ft*PI))*0.5;
  res = a*(1-f)+b*f;

double interpolate_1D_cubic(double v0,double v1,double v2,double v3,double x)
  res = v1+x*((v2-v0)+x*((-v3+v2-2*v1+2*v0)+x*(v3-v2+v1-v0)));

%tableau des positions et des interpolations
double V[64];double Ix[16];double Ixy[4];

%valeurs au sommet
for(k3=0:4)
   for(k2=0:4)
     for(k1=0:4)
       V[k1+4*(k2+4*k3)] = noise_3D(int_x+k1-1,int_y+k2-1,int_z+k3-1);

%interpolation en x
for(k3=0:4)
  for(k2=0:4)
    k=k2+4*k3;
    Ix[k] = interpolate_1D_cubic(V[4*k+0],V[4*k+1],V[4*k+2],V[4*k+3],frac_x);

%interpolation en y
for(k3=0:4)
  Ixy[k3] = interpolate_1D_cubic(Ix[4*k3+0],Ix[4*k3+1],Ix[4*k3+2],Ix[4*k3+3],frac_y);

%interpolation en z
return interpolate_1D_cubic(Ixy[0],Ixy[1],Ixy[2],Ixy[3],frac_z);

---

 
 
 

Fig. 25: [

Comparaison des méthodes d'interpolations.]Comparaison des méthodes d'interpolations. La première colonne concerne l'interpolation pour le cas 1D alors que la seconde colonne concerne le cas 2D. Les lignes correspondent aux méthodes d'interpolations. La première ligne est celle réalisée par l'interpolation linéaire, la seconde est celle réalisée par interpolation sinusoïdale, alors que la dernière correspond à l'interpolation cubique.

---

4.2.3  Mise en place de l'aspect fractal.

---

+         +

+         +

+         +

+         +

=         =

Fig. 26: [

Construction itérative du bruit de Perlin.]Schéma de la construction itérative du bruit de perlin par sommation de fréquence croissante et d'amplitude décroissante. La colonne de gauche montre le cas 1D alors que celle de droite montre le cas 2D.

---

4.2.4  Application aux textures

static double noise_3D(int x,int y,int z)
{
  res = 413243*(x<<12+234123*(x<<10)+(y<<6)*31412
       +(z<<12)*13243+54235239*(x*23+y*3142-z*432
       +x*y*54324-z*x*4312))+120+43124132*y
       +4321432*z-41231*x+Ak;
  res = fabs(res);
  res = ((int)res)%1000000/(float)1000000;
  return res;
}

---

Fig. 27: [

Exemple de textures créé par un bruit de perlin.]Exemple de texture 2D créés de façon aléatoire par un bruit de perlin. La figure de gauche montre le cas à niveaux de gris alors que celle de droite montre le cas en couleurs.

---

P0 = get_perlin_noise(xx,yy,zz,5,1/2,2,0);
P0 = 1-min(2*P0,1);

pic = zeros([size(P0),3]);
pic(:,:,1)=P0*0.6+0.4;
pic(:,:,2)=P0*0.6+0.4;
pic(:,:,3)=P0*0.2+0.8;

imagesc(u,u,pic);
axis square

---

Fig. 28: [

Texture de nuages par bruit de Perlin]Exemple de texture de nuages générée par le bruit de Perlin. La figure de gauche correspond à une texture générée automatiquement. La figure de droite représente celle d'un vrai ciel légèrement nuageux prise par un appareil numérique le 28/01/2007.

---

noise = (get_perlin_noise(xx,yy,zz,7,1/1.8,2,0)-0.5)*2;
noise = (cos(8*(x+y+0.25*noise)*pi)+1)/2;
for(k=1:3)
 pic(:,:,k) = noise;
surf(xx,yy,zz,'CData',pic,'EdgeColor','none');

noise = 9*get_perlin_noise(xx*1.5,yy*1.5,zz*1.5,2,1/2.5,2,0);
noise = noise-round(noise);

base = 1-abs(2-x)/Xmax+y.*sin(x/Xmax*pi)/Xmax;
noise = 1.5*U+get_perlin_noise(xx*1.5,yy*1.5,zz*1.5,5,1/2,2,0);
noise = max(2*noise,1);
imagesc(noise);
colormap hot(256);

---

Fig. 29: [

Type de textures créés par le bruit de Perlin.]Différents types de textures pouvant être créés rapidement par un bruit de Perlin. De gauche à droite sont représentées les imitations de marbre, bois et flamme.

---

4.2.5  Application au déplacement

1. La première façon de réaliser ce déplacement est évidement de considérer une grille de vertex paramétrés par (x,y), intialement construite avec z=0. En affectant z=γ_p(x,y), on obtient alors un déplacement continu et aléatoire de la surface qui va pouvoir modéliser la forme des vagues. Cette méthode va être implémentée sous OpenGL afin d'obtenir un déplacement en temps réel dans la partie suivante.
   
   
2. Une seconde façon de réaliser ce déplacement correspond à la perturbation d'une isosurface. Cette méthode est très puissante pour déformer tout type de surface. Pour cela on se place dans le cas 3D et on considère une fonction ϕ:R³→R telle qu'une isosurface soit définie de facon implicite par:
   { x∈R³ | ϕ(x)=0 }
   Cette isosurface va alors définir un ou plusieur objets. Dans le cas de fonctions simples, ces objets seront généralement lisses pour peu que ϕ soit continue. Il va alors être possible de leur donner un aspect plus naturel en ajoutant une fonction de bruit en recherchant la nouvelle isosurface telle que par exemple:
   { x∈R³ | ϕ(x)+γ_p(x)=0 }
   La puissance de cette représentation est qu'elle est indépendante de la topologie de l'objet. Ainsi la surface de l'eau déformée ne sera pas contrainte à être topologiquement liée à un plan mais pourra posséder des ensembles non connexes pouvant modéliser des gouttes d'eau projetées par exemple.
   
   Différentes méthodes permettent de tracer des isosurfaces efficacement et de les mailler pour une représentation sous OpenGL, notamment l'algorithme bien connu du “marching cube” [24]. Dans notre cas, nous utiliserons directement l'isosurface rendu par une méthode de ray-tracing permettant de gérer facilement le problème de sa visualisation.
   
   Prenons par exemple le cas du plan. Celui çi peut être délimité en prenant la fonction ϕ(x,y,z)=z. Nous obtenons alors dans ce cas la surface correspondant au plan z=0. L'ajout d'un bruit de Perlin sur cette fonction ϕ+γ_p va alors déformer le plan et l'isosurface correspondante ne sera plus un plan parfait.
   
   Des exemples sur un plan et sur une sphère implémentés sous Matlab sont montrés en fig. 30

   ---

   
   

   
   
   

   Fig. 30: [

   
   
   Déformation d'isosurfaces.]Images des déformations de la fonction implicite par un bruit de Perlin. Les figures de gauche montrent les isosurfaces non bruitées alors que les figures de droite montrent celles obtenues après l'application du bruit.

   ---

   Le code Matlab complet de la déformation de la sphère est le suivant:

   N=20;
   u=linspace(-1,1,N);
   [xx,yy,zz]=meshgrid(u,u,u);
   
   A=0.2;R=0.6;
   
   %noise
   noise = get_perlin_noise(3*xx,3*yy,3*zz,3,1/2,2,0);
   
   %function
   phi = xx.^2+yy.^2+zz.^2-R.^2+A*noise;
   
   %draw
   p = patch(isosurface(xx,yy,zz,phi,0));
   isonormals(xx,yy,zz,phi,p);
   set(p,'FaceColor','blue','EdgeColor','none');
   camlight;
   lighting phong;
   material shiny;
   axis equal
   axis([-1,1,-1,1]);
   axis vis3d
   view([95,35]);
   set(gca,'color','white','xtick',[],'ytick',[],'ztick',[]);
   set(gcf,'color','white');
   

   Cette méthode sera utilisée dans la dernière partie du rapport concernant le rendu par ray-tracing.

4.2.6  En Résumé

• Permet de modéliser un bruit continu et de nature fractale.
• On contrôle le nombre d'itérations et de changements d'échelles pour donner un aspect plus ou moins accidenté.
• S'applique sans aucune difficultée au cas 3D scalaire ou vectoriel.
• Nécessite un choix d'interpolation (l'interpolation cubique donne de bons résultats).
• Permet de modéliser de nombreux phénomènes sous forme de textures.
• Permet de réaliser des déformations pour donner un aspet physique: déformation de la position des vertex ou déformation d'une fonction 3D définissant une isosurface.

4.3  Implémentation sous OpenGL

4.3.1  Mise en place des classes de gestion des surfaces

class Parameterized_surface
{
 public:
  Parameterized_surface();
  ~Parameterized_surface();

  //init
  int set_size(int N_1,int N_2);
  int set_properties(int is_normal,int is_texture_coordinate,int is_color);
  int set_flat_surface(float L1_min,float L1_max,float L2_min,float L2_max);

  //set
  int set_x3(int k1,int k2,float value);
  int set_vertex(int k_1,int k_2,float x,float y,float z);
  int set_color(int k_1,int k_2,float r,float g,float b);
  int set_color(int k_1,int k_2,float r,float g,float b,float a);
  int fill_x3(float value);

  int scale(float s_x,float s_y,float s_z);

  //texture
  int map_environmental_texture(float H,float s_1,float s_2);

  //normal
  int update_normal();

  int calculate_dimensions();
  float *get_dimensions();
  int normalize_x3(float min_x3,float max_x3);

  float get_x(int k_1,int k_2);
  float get_y(int k_1,int k_2);
  float get_z(int k_1,int k_2);

  int get_N_vertex();
  int get_N_connectivity();
  float *get_vertex();
  float *get_normal();
  float *get_color();
  float *get_texture_coordinate();
  unsigned int *get_connectivity();

 private:

  int destroy();
  int alloc();
  int build_connectivity();
  int fill_flat_surface();

  int N_1,N_2;
  int N_vertex,N_connectivity;
  int N_color,N_texture;

  float dimensions[6];

  float *vertex;
  float *normal;
  float *texture_coordinate;
  float *color;
  unsigned int *connectivity;

  int is_normal,is_texture_coordinate,is_color;

};

class Mesh_tool
{
 public:
  Mesh_tool();
  ~Mesh_tool();

  int scale(float s_x,float s_y,float s_z,int N_vertex,float *vertex);
  int get_normal(int N_connectivity,unsigned int *connectivity,
                 int N_vertex,float *vertex,float *normal);

 private:
};

class Water_surface
{
 public:
  Water_surface();
  ~Water_surface();

  int set_size(int N_x,int N_y,float min_x,float max_x,
      float min_y,float max_y,float min_z,float max_z);

  int draw();
  int update_water(int kt);
  int scale(float s_x,float s_y,float s_z);

 private:

  int load_texture();

  int N_x,N_y;
  float dimensions[6];
  Parameterized_surface surf;
  GLuint texture_number;
};

int Water_surface::draw()
{
  GLfloat M_specular[3]={0.8,0.8,0.8};
  GLfloat M_shiny = 130;
  glMaterialfv(GL_FRONT,GL_SPECULAR,M_specular);
  glMaterialf(GL_FRONT,GL_SHININESS,M_shiny);

  glEnable(GL_LIGHTING);
  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D,texture_number);

  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_NORMAL_ARRAY);
  glEnableClientState(GL_COLOR_ARRAY);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);

  %set position in memory
  glVertexPointer(3,GL_FLOAT,0,surf.get_vertex());
  glNormalPointer(GL_FLOAT,0,surf.get_normal());
  glColorPointer(4,GL_FLOAT,0,surf.get_color());
  glTexCoordPointer(2,GL_FLOAT,0,surf.get_texture_coordinate());

  %draw
  glDrawElements(GL_TRIANGLES,surf.get_N_connectivity(),
                 GL_UNSIGNED_INT,surf.get_connectivity());

  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisableClientState(GL_NORMAL_ARRAY);
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);

  glDisable(GL_TEXTURE_2D);
  glDisable(GL_LIGHTING);

  return 0;
}

  surf.set_x3(k_x,k_y,z);

---

Fig. 31: [

Mise en place de la grille paramétrique en OpenGL]Mise en place de la grille Paramétrique en OpenGL

---

4.3.2  Mise en place du Bruit de Perlin

class Perlin_noise
{
 public:
  float get_perlin(float x,float y,float z,int octave,float persistence,
   float frequency);

 private:
  float interpolate_noise_3D(float x,float y,float z);
  float interpolate_cubic_1D(float v0,float v1,float v2,float v3,float x);
  float noise_3D(int n1,int n2,int n3);
};

z = 0.02*cos(6*x-ct/2)
   +0.07*noise.get_perlin(x,y,Z0+ct/10,octave,persistence,frequency);
surf.set_x3(k_x,k_y,z);

---

Fig. 32: [

Mise en place du bruit de Perlin sur la grille.]Mise en place du bruit de Perlin sur la grille paramétrique.

---

4.3.3  Mise en place de la scène

• La rivière

---

Fig. 33: [

Changement de coloration de la vague suivant la hauteur.]Changement de coloration de la vague suivant sa hauteur en z en lui donnant un dégradé entre le bleu et le blanc.

---

---

Fig. 34: [

Texture d'eau utilisée.]Texture d'eau utilisée. Celle-ci est créée par Gimp à l'aide du bruit de Perlin.

---

---

Fig. 35: [

Schéma de la mise en place de la texture environnementale.]Schéma de la mise en place de la texture environnementale.

---

---

Fig. 36: [

Exemple de texture sur la surface.]Exemple de texture plaquée sur la surface. L'image de gauche correspond au plaquage simple où les coordonnées de textures sont directement liées aux paramétrage de la surface. L'image de droite correspond à la mise en place de la texture environnementale donné en eq. 18.

---

  //enable multitexturing
  glActiveTextureARB(GL_TEXTURE0_ARB);
  glBindTexture(GL_TEXTURE_2D,texture_number);
  glEnable(GL_TEXTURE_2D);
  //multiply texture with color
  glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
  glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
  glClientActiveTextureARB(GL_TEXTURE0_ARB);
  glTexCoordPointer(2,GL_FLOAT,0,&multitexturing[0]);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);

  glActiveTextureARB(GL_TEXTURE1_ARB);
  glBindTexture(GL_TEXTURE_2D,texture_number);
  glEnable(GL_TEXTURE_2D);
  //then add the new one
  glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
  glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD_SIGNED);
  glClientActiveTextureARB(GL_TEXTURE1_ARB);
  glTexCoordPointer(2,GL_FLOAT,0,&multitexturing[2*N_x*N_y]);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);

  glVertexPointer(3,GL_FLOAT,0,surf.get_vertex());
  glNormalPointer(GL_FLOAT,0,surf.get_normal());
  glColorPointer(4,GL_FLOAT,0,surf.get_color());

  //draw
  glDrawElements(GL_TRIANGLES,surf.get_N_connectivity(),
                 GL_UNSIGNED_INT,surf.get_connectivity());

  glDisableClientState(GL_NORMAL_ARRAY);
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);

  glActiveTextureARB(GL_TEXTURE1_ARB);
  glClientActiveTextureARB(GL_TEXTURE1_ARB);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisable(GL_TEXTURE_2D);

  glActiveTextureARB(GL_TEXTURE0_ARB);
  glClientActiveTextureARB(GL_TEXTURE0_ARB);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisable(GL_TEXTURE_2D);

---

Fig. 37: [

Exemple de mutlitexturing.]Multitexturing appliqué sur l'image de l'eau. Une texture simple est plaquée par rapport aux coordonnées paramétriques de la surface et celle-ci est modulée par la texture environnementale. De plus on garde toujours une couleur plus claire pour les vagues les plus hautes.

---

• Le paysage

---

Fig. 38: [

Texture d'herbe utilisé pour le sol.]Texture d'herbe utilisé pour le sol.

---

//create hole
z = fmin(7*abs((float)(k_y-N_y/2.0)/(float)N_y),1.2);
//add Perlin noise
z += 0.3*noise.get_perlin(x,y,Z0,octave,persistence,frequency);

---

Fig. 39: [

Sol et rivière.]Affichage du sol et de la rivière en même temps.

---

• Le reste

---

Fig. 40: [

Image de la scène complete avec le bruit de Perlin.]Images de la scène complète avec le bruit de Perlin.

---

4.4  Bruit de Perlin particulier: Ridged Perlin et son lien avec l'océan

4.4.1  Théorie

---

Fig. 41: [

Étapes de la construction du bruit de Perlin à crêtes.]Étapes de bases de la construction du bruit de Perlin à crêtes μ. La première image montre un bruit de Perlin simple centré en 0. La seconde étape consiste en la prise de la valeur absolue afin de créer les crêtes. Ensuite, l'étape 3 consiste à renverser la fonction précédente afin d'avoir les crêtes en haut. Le renversement est réalisé par l'inversion puis la translation par le paramètre L proche de un. Enfin l'étape suivante est l'élévation au carré afin d'accentuer les crêtes.

---

---

Fig. 42: [

Sommation d'octaves du bruit de Perlin à crêtes.]Exemple de sommation d'octaves dans le cas du bruit de Perlin à crêtes. La figure de gauche montre la sommation de deux octaves alors que la suivante montre la sommation de trois.

---

---

Fig. 43: [

Effet des parametres du bruit de Perlin à crête.]Effet des paramètres pour le bruit de Perlin à crêtes. La première image montre le bruit lorsque le paramètre a est pris grand (ici 6), les fréquences sommées sont alors plus hautes dès les premières octaves, on passe donc rapidement de grands pics à des pics faibles mais de fréquences importantes. Les figures 2 et 3 montrent l'effet de l'offset sur l'apparence de la courbe. Pour un offset L important (figure 2, L=1.4), les hauteurs sont plus importantes, il y a donc peu de différence entre les crêtes et les creux qui sont également accidentés. Au contraire pour la figure trois où L=0.9, seul les crêtes sont bruitées alors que les creux restent très lisses. Enfin le paramètre H est modifié dans les figures 4 et 5. En effet, pour la figure cinq, on prend H important (H=1.2) ce qui donne une diminution très importante des contributions dès les premières octaves, le bruit apparaît donc peu accidenté. Au contraire, sur la dernière figure, on choisit H=0.2, la décroissance en amplitude des contributions de grandes amplitudes est alors plus réduite, on obtient donc plus de bruit. On peut bien remarquer sur cette image que les crêtes hautes sont plus bruitées que les creux.

---

---

Fig. 44: [

Bruit de Perlin à crêtes en 2D.]Bruit de Perlin à crêtes réalisé en 2D avec Matlab. Les filaments partants des crêtes et un fond peu bruité est caractéristique de ce bruit.

---

4.4.2  Implémentation en OpenGL et limitations

float Perlin_noise::get_ridged_multifractal_perlin(float x,float y,float z,
  float H,int octave,float frequency,float offset,float threshold)
{
  int k_octave=0;
  float signal=0.0;
  float result=0.0;
  float weight=0.0;

  //calculate first pass
  signal = get_perlin(x,y,z);
  signal = offset-fabs(signal);
  signal *= signal;

  result = signal;
  weight = 1.0;

  //sum octaves
  for(k_octave=0;k_octave<octave-1;k_octave++)
    {
      rand_octave = (int)((k_octave<<13)*4321+234);

      x *= frequency;
      y *= frequency;
      z *= frequency;

      weight = signal*threshold;
      //truncate weight
      if(weight>1)
       weight=1;
      else
       if(weight<0)
        weight=0;
      signal = get_perlin(x,y,z);
      signal = offset-fabs(signal);
      signal *= signal*weight;

      //sum contributions
      result += signal*powf(frequency,-(float)k_octave*H);
    }
  
  return result;
}

---

Fig. 45: [

Plage et mer modélisée par un unique sinus.]Aspect de la plage choisie et de la mer modélisée pour l'instant par un unique sinus sur l'axe z.

---

---

Fig. 46: [

Mer avec sinus plus bruit de Perlin simple.]Les vagues de la mer sur la plage avec ajout du bruit de Perlin simple afin de donner un effet plus naturel qu'un simple sinus. On remarquera que pour améliorer le réalisme, on rend la mer plus transparente sur la côte qu'au large où la hauteur de l'eau est sensée la rendre plus opaque.

---

 //sinus
 z = 0.03*cos(4*y-ct/2);
 //Perlin
 z+= 0.04*noise.get_perlin(x,y,Z0+ct/10,octave,persistence,frequency);
 //Ridged Perlin
 z+= 0.1*noise.get_ridged_multifractal_perlin(x/2,y/2-ct/5.0,z/2-ct/10.0,
     0.7,4,2,1.1,0.8)
     *
     (N_y-k_y)/(float)N_y;//depends on the distance to the beach

---

Fig. 47: [

Résultats complet de la mer avec le bruit de Perlin à crête.]Résultats obtenus avec le bruit de Perlin à crêtes. Le premier plan de la plage est consitué d'eau transparente avec la contribution principale du sinus et du bruit de Perlin simple. L'arrière plan de la mer plus profonde et moins transparente est consituée du bruit de Perlin à crêtes provoquant des vagues beaucoup plus pentues.

---

---

Fig. 48: [

Prises de vues de la mer avec le bruit de Perlin à crête.]Différentes prises de vues de la mer réalisées à l'aide du bruit de Perlin à crêtes. La première image montre l'aspect général de la plage avec l'eau transparente et peu agitée sur la côte, et les vagues plus importante au large. La seconde image montre le terrain avec la mer au fond. La troisième image montre l'aspect de la mer et de la plage vue de haut. La quatrième image montre la mer se jettant sur la plage vu de derrière. La cinquième et la sixième images sont des vues de derrière au niveau de la mer, à la hauteur des vagues importantes. La septième image montre la grille utilisée sur les vagues. L'avant dernière image montre la construction du terrain en dégradé et enfin la dernière image est une vue d'ensemble de l'agencement de la scène au milieu de la sky-box.

---

---

Fig. 49: [

Problème due à l'échantillonnage du bruit haute fréquence.]Problème due à l'échantillonnage grossier du bruit sur les hautes fréquences.

---