naive_propagation.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
/*{
Nous aurons besoin des fonctions \func{std::min} et \func{std::max} qui sont disponible dans \file{algorithm} :
}*/
#include <algorithm>
/*{
Ensuite, nous incluons notre header :
}*/
#include "naive_propagation.h"
 
/*{
Et nous commençons l'implementation de notre fonction :
}*/
 
void grayscott_propagation(float * outMatU, float * outMatV, const float * matU, const float * matV, long nbRow, long nbCol,
                       const float * matDeltaSquare, long nbStencilRow, long nbStencilCol,
                       float diffudionRateU, float diffusionRateV, float feedRate, float killRate, float dt)
{
/*{
Nous déterminons les \textbf{offset} de notre \textbf{stencil} (le nombre de couches à partir de la cellule centrale) :
}*/
        long offsetStencilRow((nbStencilRow - 1l)/2l);
        long offsetStencilCol((nbStencilCol - 1l)/2l);
/*{
Nous bouclons sur les lignes et les colonnes de nos matrices pour mettre à jour toutes nos cellules :
}*/
        for(long i(0l); i < nbRow; ++i){
                for(long j(0l); j < nbCol; ++j){
/*{
Il faut maintenant déterminer les bornes de nos calculs (voir section \ref{secNaiveImplStencil}) :
}*/
                        long firstRowStencil(std::max(i - offsetStencilRow, 0l));
                        long firstColStencil(std::max(j - offsetStencilCol, 0l));
                        
                        long lastRowStencil(std::min(i + offsetStencilRow + 1l, nbRow));
                        long lastColStencil(std::min(j + offsetStencilCol + 1l, nbCol));
/*{
Définissons quelques variables temporaires :
}*/
                        long stencilIndexRow(0l);
                        float u(matU[i*nbCol + j]), v(matV[i*nbCol + j]);
                        float fullU(0.0f), fullV(0.0f);
/*{
Nous devons maintenant boucler sur les lignes et les colonnes de notre \textbf{stencil} :
}*/
                        for(long k(firstRowStencil); k < lastRowStencil; ++k){
                                long stencilIndexCol(0l);
                                for(long l(firstColStencil); l < lastColStencil; ++l){
/*{
Nous pouvons enfin calculer notre gradient :
}*/
                                        float deltaSquare(matDeltaSquare[stencilIndexRow*nbStencilCol + stencilIndexCol]);
                                        fullU += (matU[k*nbCol + l] - u)*deltaSquare;
                                        fullV += (matV[k*nbCol + l] - v)*deltaSquare;
/*{
Il ne faut pas oublier d'incrémenter les indices qui nous permettent de parcourir la matrice \textbf{matDeltaSquare] :
}*/
                                        ++stencilIndexCol;
                                }
                                ++stencilIndexRow;
                        }
/*{
On finalise le calcul :
}*/
                        float uvSquare(u*v*v);
                        float du(diffudionRateU*fullU - uvSquare + feedRate*(1.0f - u));
                        float dv(diffusionRateV*fullV + uvSquare - (feedRate + killRate)*v);
/*{
Et on sauvegarde le résultat :
}*/
                        outMatU[i*nbCol + j] = u + du*dt;
                        outMatV[i*nbCol + j] = v + dv*dt;
/*{
Fin des deux boucles sur les lignes et les colonnes :
}*/
                }
        }
/*{
Fin de la fonction :
}*/
}