/*!\file mandelbrot.c
 *
 * \author SOUPLET Antoine
 * \version 1.0
 * \date 09-01-2012 
 *
 * \brief Fichier contenant les fonctions associées à la structure de Mandelbrot
 *
 */

#include "functionAdd.h"
#include "mandelbrot.h"
#include <SDL/SDL.h>
#include <SDL/SDL_thread.h>

//Crée et initialise une structure Mandelbrot
Mandelbrot* initMandelbrot(SDL_Surface *surf_screen, double* pd_zoom, Point* ppoint_pInit, int i_minX, int i_maxX, int i_minY, int i_maxY, int *pi_nbIter, int* pi_numGradient) {
Mandelbrot *mand_mandelbrot;
mand_mandelbrot=myMalloc(sizeof(Mandelbrot));//allocation de l'espace nécéssaire à une structure Mandelbrot
(*mand_mandelbrot).surf_screen=surf_screen;//initialise l'attribut de la structure Mandelbrot correspondant à l'écran
(*mand_mandelbrot).pd_zoom = pd_zoom;//initialise l'attribut de la structure Mandelbrot correspondant au zoom
(*mand_mandelbrot).ppoint_pInit=ppoint_pInit;//initialise l'attribut ppoipInit
(*mand_mandelbrot).i_minX=i_minX;//initialise l'attribut i_minX
(*mand_mandelbrot).i_maxX=i_maxX;//initialise l'attribut i_maxX
(*mand_mandelbrot).i_minY=i_minY;//initialise l'attribut i_minY
(*mand_mandelbrot).i_maxY=i_maxY;//initialise l'attribut i_maxY
(*mand_mandelbrot).pi_nbIter=pi_nbIter;//initialise l'attribut pi_nbIter correspondant au nombre d'itération
(*mand_mandelbrot).pi_numGradient=pi_numGradient;//initialise l'attribut i_numGradient correspondant au choix de la coloration de la fractale de Mandelbrot
return (mand_mandelbrot);//retourne la structure Mandelbrot initialisée
}


//Libère l'espace alloué à une structure Mandelbrot ainsi qu'à ses attributs
void freeMandelbrot(Mandelbrot* mand_mandelbrot) {
free(mand_mandelbrot->pi_numGradient);
free(mand_mandelbrot->pi_nbIter);
free(mand_mandelbrot->pi_nbIter);//libère l'espace alloué au nombre d'itération;
SDL_FreeSurface(mand_mandelbrot->surf_screen);//libère l'espace alloué à l'écran
free(mand_mandelbrot->pd_zoom);//libère l'espace alloué au zoom
free(mand_mandelbrot->ppoint_pInit);//libère l'espace alloué au point initial
free(mand_mandelbrot);//libère l'espace alloué par la structure Mandelbrot
}

//Libère l'espace mémoire alloué lors du traitement d'un thread de dessin de la fractale Mandelbrot
void freeThreadMandel(Mandelbrot* mand_mandel, int* pi_oldIter, int* pi_nIter) {
	free(pi_oldIter);//libère l'espace mémoire alloué au nombre d'itérations associé au pixel précédent
	free(mand_mandel);//libère l'espace alloué par la structure Mandelbrot
}


//Libère l'espace alloué pendant la boucle de calcul Mandelbrot ou de Julia
void freeLoopMandelbrotJulia(SDL_Surface* surf_pixel, int i_nbGradColor, double* pd_color, int** ppi_tabColor) {
	int i;//variable de boucle
	for (i = 0; i < i_nbGradColor; i++) {
		free(ppi_tabColor[i]);
	}
	free(pd_color);
	free(ppi_tabColor);
	SDL_FreeSurface(surf_pixel);
}


//renvoie le nombre de couleur qui composent le dégradé
int getNbGradColor(int i_numGradient) {
	switch(i_numGradient) {
		case 1:
			return(5*7); //5 couleurs * 7 repétitions de dégradé
			break;
		case 2:
			return(6*7); //6 couleurs * 7 repétitions de dégradé
			break;
		case 3:
			return(4*7); //4 couleurs * 7 repétitions de dégradé
			break;
		case 4:
			return(5*7); //5 couleurs * 7 repétitions de dégradé
			break;
		default:
			return(2);
	}    
}

//Modifie un tableau de couleur afin de correspondre au mieux aux fractales de Mandelbrot et de Julia
double* colorToRGB(double* pd_color, int** ppi_tabColor, int i_nbColor, int i_nbGradColor) {
	double d_interval;  //longueur d'un interval entre deux couleur
	int i_position;     //indice d'une des deux couleur à dégrader
	double d_ajuste;    //pourcentage de la premiere couleur (1-ajutse, pourcentage deuxieme couleur)
	d_interval=1.0/(i_nbColor*i_nbGradColor-1);
	i_position=floor(pd_color[0]*(i_nbColor*i_nbGradColor-1));
	d_ajuste= (pd_color[0]-i_position*d_interval)*(i_nbColor*i_nbGradColor-1);
	pd_color[1]=floor((ppi_tabColor[i_position][0]*(1.0-d_ajuste))+(ppi_tabColor[i_position+1][0]*(d_ajuste))); //pd_color[1] est la moyenne pondérée d'une couleur C(i) et C(i+1)
	pd_color[2]=floor((ppi_tabColor[i_position][1]*(1.0-d_ajuste))+(ppi_tabColor[i_position+1][1]*(d_ajuste))); //pd_color[2] est la moyenne pondérée d'une couleur C(i) et C(i+1)
	pd_color[3]=floor((ppi_tabColor[i_position][2]*(1.0-d_ajuste))+(ppi_tabColor[i_position+1][2]*(d_ajuste))); //color[3] est la moyenne pondérée d'une couleur C(i) et et C(i+1)
	return (pd_color);
}



//Création du dégradé numero 1
int** createGrad1(int i_nbColor) {
	int** ppi_tab; //tableau contenant les couleurs du dégradé 1
	int i;     // variable de boucles
	ppi_tab=myMalloc(sizeof(int*)*2*i_nbColor);
	for (i = 0; i < (2*i_nbColor); i++) {
		ppi_tab[i]=myMalloc(sizeof(int)*3);
	} 
	for (i = 0; i < i_nbColor; i++) {    
		ppi_tab[0+i*2][0]=0;
		ppi_tab[0+i*2][1]=0;
		ppi_tab[0+i*2][2]=0;   
		ppi_tab[1+i*2][0]=255;
		ppi_tab[1+i*2][1]=255;
		ppi_tab[1+i*2][2]=255;
	}
	return(ppi_tab);
}


//Création du dégradé numero 2
int** createGrad2(int i_nbColor) {
	int** ppi_tab; //tableau contenant les couleurs du dégradé 2
	int i;  //variable de boucle
	ppi_tab=myMalloc(sizeof(int*)*5*i_nbColor);
	for (i = 0; i < (5*i_nbColor); i++) {
		ppi_tab[i]=myMalloc(sizeof(int)*3);
	} 
	for (i = 0; i < i_nbColor; i++) {
		ppi_tab[0+i*5][0]=4;
		ppi_tab[0+i*5][1]=210;
		ppi_tab[0+i*5][2]=23;
		ppi_tab[1+i*5][0]=29;
		ppi_tab[1+i*5][1]=239;
		ppi_tab[1+i*5][2]=49;
		ppi_tab[2+i*5][0]=255;
		ppi_tab[2+i*5][1]=255;
		ppi_tab[2+i*5][2]=255;
		ppi_tab[3+i*5][0]=4;
		ppi_tab[3+i*5][1]=106;
		ppi_tab[3+i*5][2]=210;
		ppi_tab[4+i*5][0]=29;
		ppi_tab[4+i*5][1]=4;
		ppi_tab[4+i*5][2]=210;
	}
	return(ppi_tab);
}


//Création du dégradé numero 3
int** createGrad3(int i_nbColor) {
	int** ppi_tab; //tableau contenant les couleurs du dégradé 3
	int i;  //variable de boucle
	ppi_tab=myMalloc(sizeof(int*)*6*i_nbColor);
	for (i = 0; i < (6*i_nbColor); i++) {
		ppi_tab[i]=myMalloc(sizeof(int)*3);
	} 
	for (i = 0; i < i_nbColor; i++) {
		ppi_tab[0+i*6][0]=0;
		ppi_tab[0+i*6][1]=0;
		ppi_tab[0+i*6][2]=40;
		ppi_tab[1+i*6][0]=0;
		ppi_tab[1+i*6][1]=255;
		ppi_tab[1+i*6][2]=255;
		ppi_tab[2+i*6][0]=206;
		ppi_tab[2+i*6][1]=255;
		ppi_tab[2+i*6][2]=255;
		ppi_tab[3+i*6][0]=255;
		ppi_tab[3+i*6][1]=255;
		ppi_tab[3+i*6][2]=210;
		ppi_tab[4+i*6][0]=255;
		ppi_tab[4+i*6][1]=178;
		ppi_tab[4+i*6][2]=44;
		ppi_tab[5+i*6][0]=135;
		ppi_tab[5+i*6][1]=76;
		ppi_tab[5+i*6][2]=7;
	} 
	return (ppi_tab);
}


//Création du dégradé numero 4
int** createGrad4(int i_nbColor){
	int** ppi_tab; //tableau contenant les couleurs du dégradé 4
	int i; //variable de boucle
	ppi_tab=myMalloc(sizeof(int*)*4*i_nbColor);
	for (i = 0; i < (4*i_nbColor); i++) {
		ppi_tab[i]=myMalloc(sizeof(int)*3);
	} 
	for (i = 0; i < i_nbColor; i++) {
		ppi_tab[0+i*4][0]=0;
		ppi_tab[0+i*4][1]=40;
		ppi_tab[0+i*4][2]=116;
		ppi_tab[1+i*4][0]=5;
		ppi_tab[1+i*4][1]=124;
		ppi_tab[1+i*4][2]=193;
		ppi_tab[2+i*4][0]=10;
		ppi_tab[2+i*4][1]=221;
		ppi_tab[2+i*4][2]=229;
		ppi_tab[3+i*4][0]=0;
		ppi_tab[3+i*4][1]=255;
		ppi_tab[3+i*4][2]=198;
	} 
	return (ppi_tab);
}


//Création du dégradé numero 5
int** createGrad5(int i_nbColor) {
	int** ppi_tab; //tableau contenant les couleurs du dégradé 5
	int i; //variable de boucle
	ppi_tab=myMalloc(sizeof(int*)*5*i_nbColor);
	for (i = 0; i < (5*i_nbColor); i++) {
		ppi_tab[i]=myMalloc(sizeof(int)*3);
	} 
	for (i = 0; i < i_nbColor; i++) {
		ppi_tab[0+i*5][0]=207;
		ppi_tab[0+i*5][1]=0;
		ppi_tab[0+i*5][2]=0;
		ppi_tab[1+i*5][0]=237;
		ppi_tab[1+i*5][1]=178;
		ppi_tab[1+i*5][2]=19;
		ppi_tab[2+i*5][0]=251;
		ppi_tab[2+i*5][1]=254;
		ppi_tab[2+i*5][2]=11;
		ppi_tab[3+i*5][0]=194;
		ppi_tab[3+i*5][1]=254;
		ppi_tab[3+i*5][2]=11;
		ppi_tab[4+i*5][0]=11;
		ppi_tab[4+i*5][1]=254;
		ppi_tab[4+i*5][2]=11;
	} 
	return (ppi_tab);
}


//Crée un tableau de couleurs en fonction du numéro de dégradé choisit
int** createTabColor(int i_numGradient) {
	switch(i_numGradient){
		case 1:
			return(createGrad2(7));
			break;
		case 2:
			return(createGrad3(7));
			break;
		case 3:
			return(createGrad4(7));
			break;
		case 4:
			return(createGrad5(7));
			break;
		default:
			return(createGrad1(1));
	}
}