Tableau 2 dimensions + propagation fluide

Version imprimable

10/05/2008, 22h55
nicodn02

Tableau 2 dimensions + propagation fluide

Bonsoir,

je voudrais savoir plus ou moins comment vous coderez une propagation d'un fluide dans un tableau 2D ?

Exemple :
tableau 5 sur 5 (remplit de -1)
une "goutte d'eau" en tab[0][0] ( on lui met 1 en valeur à la case )
toutes les cases adjacentes = valeur de la case + 1
on réitère jusqu'à remplir le tableau:
0 1 2 3 4
1 1 2 3 4
2 2 2 3 4
3 3 3 3 4
4 4 4 4 4

Je pensais à dabord indiquer où l'on met cette goutte d'eau, ici tab[0][0], mais sa airaot pu très bien être en tab [1][2]:
2 1 1 1 2
2 1 0 1 2
2 1 1 1 2
2 2 2 2 2
3 3 3 3 3

et de dire par exemple :
change la case de tous tes voisins si la valeur != -1 , et tu lui met en valeur : valeur de la case + 1

Mais je ne vois pas comment le coder ...
Merci!

Salut !

Tu peux faire un truc du style :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#define LONG_CARRE 10 /* taille tableau (longueur & hauteur) */
 
int main()
{
    signed char tab[LONG_CARRE][LONG_CARRE];
    int x,y,x_gauche,x_droite,y_haut,y_bas, x_goutte=4, y_goutte=6; /* valeurs au pif */
    int distance, ligne, colonne;
 
/*    for (x=0; x<LONG_CARRE; x++) for (y=0; y<LONG_CARRE; y++) tab[y][x]=-1; */
 
/* remplissage */
    tab[y_goutte][x_goutte]=0;
    for (distance=1; distance<LONG_CARRE; distance++)
    {
        x_gauche=x_goutte-distance;
        x_droite=x_goutte+distance;
        y_haut=y_goutte-distance;
        y_bas=y_goutte+distance;
        if (y_haut>=0 && y_haut<LONG_CARRE) for (x=(x_gauche<0?0:x_gauche) ; x<=(x_droite>=LONG_CARRE?LONG_CARRE-1:x_droite) ; x++) tab[y_haut][x]=distance;
        if (y_bas>=0 && y_bas<LONG_CARRE) for (x=(x_gauche<0?0:x_gauche) ; x<=(x_droite>=LONG_CARRE?LONG_CARRE-1:x_droite) ; x++) tab[y_bas][x]=distance;
        if (x_gauche>=0 && x_gauche<LONG_CARRE) for (y=(y_haut<0?0:y_haut) ; y<=(y_bas>=LONG_CARRE?LONG_CARRE-1:y_bas) ; y++) tab[y][x_gauche]=distance;
        if (x_droite>=0 && x_droite<LONG_CARRE) for (y=(y_haut<0?0:y_haut) ; y<=(y_bas>=LONG_CARRE?LONG_CARRE-1:y_bas) ; y++) tab[y][x_droite]=distance;
    }
 
/* affichage */
    for (ligne=0; ligne<LONG_CARRE; ligne++)
    {
        for (colonne=0; colonne<LONG_CARRE; colonne++) printf("%d", tab[ligne][colonne]);
        printf("\n");
    }
 
    return 0;
}

Par contre, comme tu peux le voir, ça va dessiner des contours carrés et non circulaires.

Bonjour,

Pour résoudre ton problème, je serai passé par une notion d'état : mettre -1 dans une case dont on ignore encore l'état me parait risqué. Si on calcule l'état du tableau case à case, on risque d'avoir une dérive.

Ex : goutte en 0,0
+ on calcule 1,0 : tout à -1 sauf 0,0 -> valeur 1
...
+ on calcule 1,1 : 0,0 est à 0 mais 1,0 est à 1... on prend quoi comme valeur ?

donc mon idée pour résoudre le problème :
Code:

1 2 3 4 5 struct maCase{ int etat; int prochainEtat; }; struct maCase tab[5][5]
Pour chaque case, on détermine le prochain état, mais on ne l'applique pas avant que tous les états aient été calculés.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 for(...){ /* Attention à ne pas tomber en dehors du tableau*/ tab[i][j].prochainEtat = (-1 == tab[i-1][j-1].etat ? 0 : tab[i-1][j-1].etat + 1) + (-1 == tab[i-1][j].etat ? 0 : tab[i-1][j].etat + 1) + (-1 == tab[i-1][j+1].etat ? 0 : tab[i-1][j+1].etat + 1) + (-1 == tab[i][j-1].etat ? 0 : tab[i][j-1].etat + 1) + /*...*/ ; } /* Une fois que tout est pret, on l'applique*/ for(...){ tab[i][j].etat = tab[i][j].prochainEtat; }
Il est aussi possible de travailler avec deux tableaux, un des états courants, un des états futurs, mais ça a moins de charme.