4.1.3.1.3 : La fonction générale du programme


Maintenant, implémentons la fonctions générale :

1
2
3
4
5
6
7
8
9
10
11
12

///Simulate the images
/**	@param nbRow : number of rows of the images to be created
 * 	@param nbCol : number of columns of the images to be created
 * 	@param nbImage : number of images to be created
 * 	@param nbExtraStep : number of extra steps to be computed between images
 * 	@param killRate : rate of the process which converts V into P
 * 	@param feedRate : rate of the process which feeds U and drains U, V and P
 * 	@param dt : time interval between two computation
 * 	@param outputFile : name of the file to be created
 * 	@return true on succsess, false otherwise
*/
bool simulateImage(size_t nbRow, size_t nbCol, size_t nbImage, size_t nbExtraStep, float killRate, float feedRate, float dt, const std::string & outputFile){


Nous allons commencer par indiquer quelques paramètres utiles pour l'utilisateur :

1

	std::cout << "simulateImage : nbRow = " << nbRow << ", nbCol = " << nbCol << std::endl;


Ensuite, nous devons définir l'ensemble de nos images en HDF5 :

1
2
3

	MatrixHdf5 fullMat;
	fullMat.setAllDim(nbCol, nbRow);
	fullMat.resize(nbImage);


On créé et on initialise les PTensor et les pointeurs de nos images temporaires :

1
2
3

	PTensor<float> tmpInU, tmpInV, tmpOutU, tmpOutV;
	float *tmpU1 = NULL, *tmpU2 = NULL, *tmpV1 = NULL, *tmpV2 = NULL;
	allocate_temporary(tmpU1, tmpU2, tmpV1, tmpV2, tmpInU, tmpInV, tmpOutU, tmpOutV, nbRow, nbCol);


On définit notre stencil 3x3 (avec éventuellement des coéfficients plus sérieux mais qui donnent des résultats moins rigolos) :

1
2
3
4
5
6
7
8
9
10

	long nbStencilRow(3l), nbStencilCol(3l);
	
	float diffudionRateU(0.1f), diffusionRateV(0.05f);
	//This matrix of neigbour exchange is quite accurate but gives not so fun results
// 	float matDeltaSquare[] = 	{0.05f, 0.2f, 0.05f,
// 					0.2f, 0.0f, 0.2f,
// 					0.05f, 0.2f, 0.05f};
	float matDeltaSquare[] = 	{1.0f, 1.0f, 1.0f,
					1.0f, 1.0f, 1.0f,
					1.0f, 1.0f, 1.0f};


On créé notre barre de chargement :

1
2

	ProgressTime progress(nbImage);
	progress.start();


On boucle sur toutes les images que l'on veut créer :

1

	for(size_t i(0lu); i < nbImage; ++i){


Petite mise à jour de la barre de chargement :

1

		progress.print();


On boucle sur les image supplémentaires à calculer entre deux images à sauvegarder :

1

		for(size_t j(0lu); j < nbExtraStep; ++j){


On appelle notre calcul de Gray Scott :

1
2
3

			grayscott_propagation(tmpU2, tmpV2, tmpU1, tmpV1, nbRow, nbCol,
					matDeltaSquare, nbStencilRow, nbStencilCol,
					diffudionRateU, diffusionRateV, feedRate, killRate, dt);


On interverti les pointeurs input et output afin d'éviter des copie inutiles :

1
2
3
4

			///Let's swap the pointer
			swapValue(tmpU1, tmpU2);
			swapValue(tmpV1, tmpV2);
		}


On sauvegarde l'image que l'on veut (en faisant attention car on interverti les pointeurs régulièrement) :

1
2
3
4
5
6

		if(tmpInV.getData() == tmpV2){
			fullMat.setRow(i, tmpV2);
		}else{
			fullMat.setRow(i, tmpV1);
		}
	}


On termine la barre de chargement :

1
2

	progress.finish();
	std::cerr << "Done" << std::endl;


On écrit le fichier HDF5 :

1
2

	//Let's save the output file
	fullMat.write(outputFile);


On renvoie true car tout s'est bien passé et on finit la fonction :

1
2

	return true;
}