//*************************************//
//******** created by mamo139 *********//
//*** http://mamo139.altervista.org ***//
//*************************************//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

char *** crea_bmp(char *nome, long x, long y);
void disegna_bmp(char *nome, char *** array, long x, long y);

struct complesso
{
   double r;
   double i;
};

//*** strumenti gestione colori ***//
struct rgb { 
   int red; 
   int green;
   int blue; 
}; 
struct rgb_d { 
   double red; 
   double green;
   double blue; 
}; 
struct hsv { 
   int hue; 
   int saturation;
   int value; 
}; 
struct rgb hsv_rgb(struct hsv hsv_map);

//****** MAIN *******//

int main (void){
   
    char immagine_name[]="buddha_hsv.bmp";
//*********** PARAMETRI *************//
    long larghezza = 1000;
    long altezza = 1000;
    long deep = 10000;
    long buddha = 1000000;

         double y1 = 2;
    double x0 = -2, x1 = 2; 
         double y0 = -2;
//**********************************//
//aggiustamento parametri
    double agg_temp;
    agg_temp=y1;
    y1=y0*(-1);
    y0=agg_temp*(-1);
//**********************************//
   
    time_t t;
    srand((unsigned) time(&t));
    long b=0;
    long x,y;
   
    char *** matrice;
    matrice = crea_bmp(immagine_name,larghezza,altezza);
    
    long ** buddha_value;
    buddha_value = (long**) malloc(larghezza * sizeof(long *));
    for(b=0; b<larghezza; b++)
          buddha_value[b] = (long*) malloc(altezza * sizeof(long));
    for(x=0;x<larghezza;x++)for(y=0;y<altezza;y++)buddha_value[x][y]=0;
   
    struct complesso *history;
    history = (struct complesso*)malloc(deep * sizeof(struct complesso)); 
    
    printf("operazioni iniziali effettuate, inizio cicli!\n");
   
for(b=0;b<buddha;b++){ //ciclo buddhabrot
   
    //inizio elaborazione immagine
    long x,y,d,i,a;
    double real_x, real_y, colore;
    struct complesso z,c,temp;
   
        x=(rand())%larghezza;
        y=(rand())%altezza;

        real_x = ((x1-x0)/larghezza)*x+x0;
            real_y = ((y1-y0)/altezza)*y+y0;
            //analisi di mendelbrot
            c.r = real_x;
            c.i = real_y;
            z.r = 0;
            z.i = 0;
            d = 0;
            for(i=1;i<deep;i++){
                if((z.r*z.r)+(z.i*z.i) > 4) {
                    d = i;
                    break;
                }
                temp.r = z.r;
                temp.i = z.i;
               
                z.r = (temp.r*temp.r) - (temp.i*temp.i) + c.r;
                z.i = (temp.r*temp.i)*2 + c.i;
               
                history[i].r = z.r;
                history[i].i = z.i;
            }
           
            //controllo punto dell'insieme di mendelbrot
            if(d!=0) {
            for(a=0;a<d;a++){ //disegno la strada del punto
                x=(long) ((double)(history[a].r-x0)*larghezza/(x1-x0));
                y=(long) ((double)(history[a].i-y0)*altezza/(y1-y0));
                if(x>0 && x<larghezza && y>0 && y<altezza){
                       buddha_value[x][y]++;
                }   
            }
            }


    if(b%100000==0)printf("%d su %d gruppi da 100.000 cicli completati!\n",b/100000,buddha/100000);
} //fine buddha

    //coloro buddha
    long grande=0,piccolo=buddha_value[0][0];
    double media=0;
    printf("inizio colorazione!\n");
    for(x=0;x<larghezza;x++)//cerco il valore piu grande e piu piccolo!
    for(y=0;y<altezza;y++){
        if(buddha_value[x][y]>grande) grande = buddha_value[x][y];
        if(buddha_value[x][y]<piccolo) piccolo = buddha_value[x][y];
        media = media + (double)buddha_value[x][y]/(larghezza*altezza);
    }
    printf("biggest value: %d smallest value: %d media: %f\n",grande,piccolo,media);
    struct hsv hsv_map; struct rgb rgb_map;
    for(x=0;x<larghezza;x++)
    for(y=0;y<altezza;y++){
        buddha_value[x][y]=buddha_value[x][y]*5;
        if(buddha_value[x][y] > 255) buddha_value[x][y] = 255;  
                         
        hsv_map.hue = 50;
        hsv_map.saturation = 200;
        hsv_map.value = buddha_value[x][y];
        
        rgb_map = hsv_rgb(hsv_map);
        
        matrice[x][y][2]= rgb_map.red;
        matrice[x][y][1]= rgb_map.green;
        matrice[x][y][0]= rgb_map.blue;
    }
    printf("fine colorazione, inizio scrittura!\n");
   
    disegna_bmp(immagine_name,matrice,larghezza,altezza);
    printf("fine!");

    system(immagine_name);
    //getchar();
    return 0;
}

char *** crea_bmp(char *nome, long x, long y){
     
     FILE *stream, *cavia;
     stream = fopen(nome,"wb");
     cavia = fopen("cavia","rb");
     
     char *buffer;
     buffer = (char *)malloc(54 * sizeof(char));
     long b = fread( buffer, 1, 54, cavia);
     
     buffer[18] = x%256;//asse x
     buffer[19] = x/256;
     buffer[22] = y%256;//asse y
     buffer[23] = y/256;
     
     fwrite(buffer, 1, b, stream);
     fclose(stream);
     
     char *** array;
     int i, j, h;
     array = (char***)malloc(x * sizeof(char *));
     for(i=0; i<x; i++) {
          array[i] = (char**)malloc(y * sizeof(char *));
          for (j=0; j<y; j++)
              array[i][j] = (char*)malloc(3 * sizeof(char *)); 
     }

    int i1,i2,i3;
    for(i1=0; i1<x; i1++)
         for (i2=0; i2<y; i2++)
              for (i3=0; i3<3; i3++)
                   array[i1][i2][i3] = 0; 

     return array;   
}

void disegna_bmp(char *nome, char *** array, long x, long y){

     FILE *stream;
     stream = fopen(nome,"ab");
         
     int i1,i2;
     for (i2=y-1; i2>=0; i2--)
          for(i1=0; i1<x; i1++)
              fwrite(array[i1][i2], 1, 3, stream);
             
     fclose(stream);
}

struct rgb hsv_rgb(struct hsv hsv_map){         
 
    struct rgb_d rgb_map;
    struct rgb rgb_int;
    
    double H = ((double)hsv_map.hue);
    double S = ((double)hsv_map.saturation)/255;
    double V = ((double)hsv_map.value)/255;
    
    double hi = ((int)(H/60))%6;
    double f = (H/60) - (double)hi;
    double p = V*(1-S);
    double q = V*(1-(f*S));
    double t = V*(1-(1-f)*S);
    
    if (hi == 0){ rgb_map.red=V; rgb_map.green=t; rgb_map.blue=p;}
    else if (hi == 1){ rgb_map.red=q*255; rgb_map.green=V; rgb_map.blue=p;}
    else if (hi == 2){ rgb_map.red=p*255; rgb_map.green=V; rgb_map.blue=t;}
    else if (hi == 3){ rgb_map.red=p*255; rgb_map.green=q; rgb_map.blue=V;}
    else if (hi == 4){ rgb_map.red=t*255; rgb_map.green=p; rgb_map.blue=V;}
    else if (hi == 5){ rgb_map.red=V*255; rgb_map.green=p; rgb_map.blue=q;}
    else printf("ERRORE!");
   
    rgb_int.red = (int)(rgb_map.red*255);
    rgb_int.green = (int)(rgb_map.green*255);
    rgb_int.blue = (int)(rgb_map.blue*255);
    
    return rgb_int;   
}