//*************************************//
//******** created by mamo139 *********//
//*** http://mamo139.altervista.org ***//
//*************************************//

#include <stdio.h>
#include <stdlib.h> 
#include <string.h> 

//*** strumenti gestione file bmp ***//
char *** crea_bmp(char *nome, long x, long y);
void disegna_bmp(char *nome, char *** array, long x, long y);

//*** strumenti genstione numeri complessi ***//
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[]="out_HSV.bmp";
//*********** PARAMETRI *************//
    long larghezza = 1500;
    long altezza = 1500;
    long deep = 2000;

         double y1 = 0.100;
    double x0 = -1.800, x1 = -1.675;  
         double y0 = -0.025;
//**********************************//
//aggiustamento parametri
    double agg_temp;
    agg_temp=y1;
    y1=y0*(-1);
    y0=agg_temp*(-1);
//**********************************//
    
    char *** matrice;
    matrice = crea_bmp(immagine_name,larghezza,altezza);
    
    //inizio elaborazione immagine
    long x,y,d,i;
    double real_x,real_y, colore;
    struct complesso z,c,temp;

    for(x=0;x<larghezza;x++){
        real_x = ((x1-x0)/larghezza)*x+x0;
        for(y=0;y<altezza;y++){
            real_y = ((y1-y0)/altezza)*y+y0;
            struct rgb rgb;
            struct hsv hsv;            
            //analisi di mendelbrot
            c.r = real_x;
            c.i = real_y;
            z.r = 0;
            z.i = 0;
            d = 0;
            for(i=0;i<deep;i++){
                if((z.r*z.r)+(z.i*z.i) > 4) {
                    d = i;
                    break;
                }
                temp.r = z.r;
                temp.i = z.i;
                if(temp.r<0)temp.r=temp.r*(-1);if(temp.i<0)temp.i=temp.i*(-1); //condizione burningship
                
                z.r = (temp.r*temp.r) - (temp.i*temp.i) + c.r;
                z.i = (temp.r*temp.i)*2 + c.i;
            }
            
            //calcolo del colore
            colore = ((double)d/(double)deep);
            colore = (int)((double)colore*360);
            
            hsv.hue = colore*5;
            hsv.saturation = 255;
            hsv.value = 255;
            
            //if(hsv.hue > 360) hsv.hue = 360;
            //if(hsv.saturation > 255) hsv.saturation = 255;
            //if(hsv.value > 255) hsv.value = 255;
            
            rgb = hsv_rgb(hsv);
            
            //controllo punto dell'insieme di mendelbrot
            if(d==0) {
            matrice[x][y][0]=0;
            matrice[x][y][1]=0;
            matrice[x][y][2]=0;                     
            }
            else {
            //scrittura del colore
            matrice[x][y][0]=rgb.blue; //blu: colore
            matrice[x][y][1]=rgb.green; //verde: comportamento opposto al blu
            matrice[x][y][2]=rgb.red; //rosso: costante
            }
        }
        printf("%d%%\n",x*100/larghezza);
    }
    
    disegna_bmp(immagine_name,matrice,larghezza,altezza);
    printf("fine!");

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

//****** FUNZIONI *******//
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;   
}