English
HOME | PROJECTS | C++ CLASSES | c\c++ source code | Gallery | Guestbook | BW Servers | Contact me | Login

Fractals:
Mandelbrot set
Julia sets
Burning Ship Fractal
Buddhabrot
Anti-Buddhabrot
Fractal Generator

Audio:
Create a Wav file

Graphics:
RGB HSV conversion
BMP file functions
Bezier curve
Edges map
Sobel operator
Brightness map
BMP images’ overlap
Blur filter

Cryptography:
Vigenère cipher
Vigenerè cryptanalysis
Steganography in BMP files

Windows API:
CreateThread()
File list
FTP download
Reading Windows registry

Math:
Normal integral
2D functions' grapher


<< Fractal Generator >>

visits: 3218


L'esecuzione di un algoritmo per generare frattali puo durare anche diverse ore (a seconda del numero di iterazioni scelto), dopodiche i dati generati vengono utilizzati per creare l'immagine attraverso un'altro algoritmo.
Quando si vuole colorare al meglio un frattale puo essere necessario effettuare vari tentativi di colorazione e per evitare di ripetere inutilmente calcoli tanto lunghi ho deciso di spezzare in due programmi la creazione di un frattale.
Il primo programma genera un database contenente i dati generati dal primo algoritmo e li salva in un apposito file, il secondo programma invece si occupa solo della colorazione: prende come input il file creato dall'altro programma e lo utilizza per creare l'immagine finale. Ovviamente il primo programma puo impiegare ore a generare dati di buona qualità, ma una volta generati si possono creare infinite immagini di quel frattale in pochissimo tempo.

Alcuni file gia generati. 
download:
	BuddhaBrot 3000x3000 iterazioni (5.000) numero punti (1.000.000.000) (download) (9.4 Mb)
	BuddhaBrot 3000x3000 iterazioni (10.000) numero punti (100.000.000) (download) (8.5 Mb)


Generatore del file BMP, per usarlo bisogna avere un file contenente i dati del frattale.
Better view of the source code - Download the source code 
  1. //*************************************//
  2. //******** created by mamo139 *********//
  3. //*** http://mamo139.altervista.org ***//
  4. //*************************************//
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h> 
  8. #include <string.h> 
  9. #include <math.h> 
  10.  
  11.  
  12. //*** strumenti gestione file bmp ***//
  13. char *** crea_bmp(char *nome, long x, long y);
  14. void disegna_bmp(char *nome, char *** array, long x, long y);
  15.  
  16. //*** strumenti gestione colori ***//
  17. struct rgb { 
  18.    int red; 
  19.    int green;
  20.    int blue; 
  21. }; 
  22. struct rgb_d { 
  23.    double red; 
  24.    double green;
  25.    double blue; 
  26. }; 
  27. struct hsv { 
  28.    int hue; 
  29.    int saturation;
  30.    int value; 
  31. }; 
  32. struct rgb hsv_rgb(struct hsv hsv_map);
  33.  
  34. //*** MAIN ***//
  35. int main (void){
  36.  
  37. 	char nomefiledb[100];
  38.     printf("nome del database (la matrice deve essere quadrata):");
  39.     scanf("%s",nomefiledb);
  40.     printf("lettura file: %s!\n",nomefiledb);
  41.     getchar(); 
  42.  
  43.     long x,y,d,i;
  44.  
  45.     FILE * st;
  46.     st = fopen(nomefiledb,"rb");
  47.     fseek(st,0,SEEK_END);
  48.     long filesize = ftell(st);
  49.     rewind(st);
  50.  
  51.     long  numero_dati=0, altezza, larghezza;
  52.     char * number;
  53.     number = (char *) malloc (100 * sizeof(char));
  54.     char * buffer;
  55.     buffer = (char *) malloc (filesize * sizeof(char));
  56.     long readed = fread(buffer,1,filesize,st);
  57.     rewind(st);
  58.  
  59.     printf("filesize: %d letto:%d\n",filesize,readed);
  60.  
  61.     for(x=0;x<filesize;x++){
  62.         if(buffer[x] == '\x00') numero_dati++;                        
  63.     }
  64.  
  65.     printf("numero dati: %d\n",numero_dati);
  66.     long xy = (long) sqrt(numero_dati);
  67.     printf("base matrice quadrata: %d\n",xy);
  68.     larghezza = xy;
  69.     altezza = xy;
  70.  
  71.     long ** matrice_input;
  72.     matrice_input = (long **) malloc ( xy * sizeof(long) );
  73.     for(x=0;x<larghezza;x++)
  74.         matrice_input[x] = (long *) malloc (xy * sizeof(long) );
  75.  
  76.     printf("\n\nmatrice per dati del file creata!\n");
  77.     printf("\nlettura del file in corso...\n");
  78.  
  79.     int se1=0,nump=0;
  80.     x=0;y=0;
  81.  
  82.     for(i=0;i<filesize;i++){
  83.         if(buffer[i] != '\x00'){
  84.             number[nump] = buffer[i];
  85.             nump++;            
  86.         }else{
  87.             number[nump] = '\0';  
  88.             matrice_input[x][y] = atoi(number);
  89.             nump = 0;
  90.             if(y<altezza-1) y++;
  91.             else { y=0;x++; }   
  92.         }
  93.  
  94.     }
  95.     printf("matrice caricata!\n");
  96.     printf("\nlarghezza: %d\naltezza: %d\n",larghezza,altezza);
  97.  
  98.     //************** INIZIO SCRITTURA BMP    
  99.     char image_name[] = "out_image.bmp";
  100.  
  101.     printf("\nCaricamento matrice bmp in corso...\n");
  102.     char *** matrice;
  103.     matrice = crea_bmp(image_name,larghezza,altezza);
  104.  
  105.     //inizio elaborazione immagine
  106.     double real_x,real_y, colore;
  107.     struct hsv hsv;
  108.     struct rgb rgb;
  109.  
  110.     printf("\nOperazioni di caricamento completate.\n");
  111.     //printf("\nPremere INVIO per inizio elaborazione colori.\n");
  112.     //getchar(); 
  113.  
  114.     printf("\nInizio ciclo di disegno.\n");
  115.     for(x=0;x<larghezza;x++){
  116.         for(y=0;y<altezza;y++){
  117.             d = matrice_input[x][y]/4;
  118.             //calcolo del colore
  119.             if(d>255) d=255;
  120.             colore = d;
  121.  
  122.             /*
  123.             rgb.blue = colore;
  124.             rgb.green = colore;
  125.             rgb.red = colore;
  126.             */
  127.             hsv.hue = (int) 300-colore;
  128.             hsv.saturation = 200;
  129.             hsv.value = colore;
  130.  
  131.             rgb = hsv_rgb(hsv);
  132.  
  133.             //controllo punto dell'insieme di mendelbrot
  134.             if(d==0) {
  135.             matrice[x][y][0]=0;
  136.             matrice[x][y][1]=0;
  137.             matrice[x][y][2]=0;                     
  138.             }
  139.             else {
  140.             //scrittura del colore
  141.             matrice[x][y][0]=rgb.blue; //blu: colore
  142.             matrice[x][y][1]=rgb.green; //verde: comportamento opposto al blu
  143.             matrice[x][y][2]=rgb.red; //rosso: costante
  144.             }
  145.         }
  146.         //printf("%d%%\n",x*100/larghezza);
  147.     }
  148.  
  149.     printf("Fine ciclo di disegno.\n\nScrittura file in corso...\n");
  150.  
  151.     disegna_bmp(image_name,matrice,larghezza,altezza);
  152.     printf("fine!");
  153.  
  154.     system(image_name);
  155.     //getchar();
  156.     return 0;
  157. }
  158.  
  159. //****** FUNZIONI *******//
  160. char *** crea_bmp(char *nome, long x, long y){
  161.  
  162.      FILE *stream, *cavia;
  163.      stream = fopen(nome,"wb");
  164.      cavia = fopen("cavia","rb");
  165.  
  166.      char *buffer;
  167.      buffer = (char *)malloc(54 * sizeof(char)); 
  168.      long b = fread( buffer, 1, 54, cavia);
  169.  
  170.      buffer[18] = x%256;//asse x
  171.      buffer[19] = x/256;
  172.      buffer[22] = y%256;//asse y
  173.      buffer[23] = y/256;
  174.  
  175.      fwrite(buffer, 1, b, stream);
  176.      fclose(stream);
  177.  
  178.      char *** array;
  179.      int i, j, h; 
  180.      array = (char***)malloc(x * sizeof(char *)); 
  181.      for(i=0; i<x; i++) { 
  182.           array[i] = (char**)malloc(y * sizeof(char *)); 
  183.           for (j=0; j<y; j++) 
  184.               array[i][j] = (char*)malloc(3 * sizeof(char *));  
  185.      }
  186.  
  187.     int i1,i2,i3;
  188.     for(i1=0; i1<x; i1++) 
  189.          for (i2=0; i2<y; i2++)
  190.               for (i3=0; i3<3; i3++)
  191.                    array[i1][i2][i3] = 0;  
  192.  
  193.      return array;    
  194. }
  195.  
  196. void disegna_bmp(char *nome, char *** array, long x, long y){
  197.  
  198.      FILE *stream;
  199.      stream = fopen(nome,"ab");
  200.  
  201.      int i1,i2;
  202.      for (i2=y-1; i2>=0; i2--)
  203.           for(i1=0; i1<x; i1++) 
  204.               fwrite(array[i1][i2], 1, 3, stream);
  205.  
  206.      fclose(stream);
  207. }
  208.  
  209. struct rgb hsv_rgb(struct hsv hsv_map){         
  210.  
  211.     struct rgb_d rgb_map;
  212.     struct rgb rgb_int;
  213.  
  214.     double H = ((double)hsv_map.hue);
  215.     double S = ((double)hsv_map.saturation)/255;
  216.     double V = ((double)hsv_map.value)/255;
  217.  
  218.     double hi = ((int)(H/60))%6;
  219.     double f = (H/60) - (double)hi;
  220.     double p = V*(1-S);
  221.     double q = V*(1-(f*S));
  222.     double t = V*(1-(1-f)*S);
  223.  
  224.     if (hi == 0){ rgb_map.red=V; rgb_map.green=t; rgb_map.blue=p;}
  225.     else if (hi == 1){ rgb_map.red=q*255; rgb_map.green=V; rgb_map.blue=p;}
  226.     else if (hi == 2){ rgb_map.red=p*255; rgb_map.green=V; rgb_map.blue=t;}
  227.     else if (hi == 3){ rgb_map.red=p*255; rgb_map.green=q; rgb_map.blue=V;}
  228.     else if (hi == 4){ rgb_map.red=t*255; rgb_map.green=p; rgb_map.blue=V;}
  229.     else if (hi == 5){ rgb_map.red=V*255; rgb_map.green=p; rgb_map.blue=q;}
  230.     else printf("ERRORE!");
  231.  
  232.     rgb_int.red = (int)(rgb_map.red*255);
  233.     rgb_int.green = (int)(rgb_map.green*255);
  234.     rgb_int.blue = (int)(rgb_map.blue*255);
  235.  
  236.     return rgb_int;   
  237. }
  238.  


Generatore del file dell'insieme di Mandelbrot.
Better view of the source code - Download the source code 
  1. //*************************************//
  2. //******** created by mamo139 *********//
  3. //*** http://mamo139.altervista.org ***//
  4. //*************************************//
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h> 
  8. #include <string.h> 
  9.  
  10.  
  11. //*** strumenti genstione numeri complessi ***//
  12. struct complesso 
  13. { 
  14.    double r; 
  15.    double i; 
  16. }; 
  17. //*** strumenti gestione db
  18. int ** crea_matrice(long x, long y);
  19. void scrivi_matrice(char * file_name, int ** matrice, long xl, long yl);
  20.  
  21. //*** MAIN ***//
  22. int main (void){
  23.  
  24.     char db_name[]="ma";
  25. //*********** PARAMETRI *************//
  26.     long larghezza = 2000;
  27.     long altezza = 2000;
  28.     long deep = 10000;
  29.  
  30.          double y1 = 2;
  31.     double x0 = -2, x1 = 2;  
  32.          double y0 = -2;
  33. //**********************************//
  34. //aggiustamento parametri
  35.     double agg_temp;
  36.     agg_temp=y1;
  37.     y1=y0*(-1);
  38.     y0=agg_temp*(-1);
  39. //**********************************//
  40.  
  41.     int ** matrice;
  42.     matrice = crea_matrice(larghezza,altezza);
  43.  
  44.     //inizio elaborazione immagine
  45.     long x,y,d,i;
  46.     double real_x,real_y, colore;
  47.     struct complesso z,c,temp;
  48.  
  49.     for(x=0;x<larghezza;x++){
  50.         real_x = ((x1-x0)/larghezza)*x+x0;
  51.         for(y=0;y<altezza;y++){
  52.             real_y = ((y1-y0)/altezza)*y+y0;
  53.  
  54.             //analisi di mendelbrot
  55.             c.r = real_x;
  56.             c.i = real_y;
  57.             z.r = 0;
  58.             z.i = 0;
  59.             d = 0;
  60.             for(i=0;i<deep;i++){
  61.                 if((z.r*z.r)+(z.i*z.i) > 4) {
  62.                     d = i;
  63.                     break;
  64.                 }
  65.                 temp.r = z.r;
  66.                 temp.i = z.i;
  67.  
  68.                 z.r = (temp.r*temp.r) - (temp.i*temp.i) + c.r;
  69.                 z.i = (temp.r*temp.i)*2 + c.i;
  70.             }
  71.  
  72.             matrice[x][y] = d;
  73.         }
  74.         printf("%d%%\n",x*100/larghezza);
  75.     }
  76.  
  77.     scrivi_matrice(db_name,matrice,larghezza,altezza);
  78.     printf("fine!");
  79.  
  80.  
  81.     getchar();
  82.     return 0;
  83. }
  84. //****** FUNZIONI *******//
  85. int ** crea_matrice(long x, long y){
  86.  
  87.      int ** array;
  88.      int i, j; 
  89.      array = (int**)malloc(x * sizeof(int *)); 
  90.      for(i=0; i<x; i++) { 
  91.           array[i] = (int*)malloc(y * sizeof(int *)); 
  92.      }
  93.  
  94.     int i1,i2;
  95.     for(i1=0; i1<x; i1++) 
  96.          for (i2=0; i2<y; i2++)
  97.                    array[i1][i2] = 0;  
  98.  
  99.      return array;    
  100. }
  101. void scrivi_matrice(char * file_name, int ** matrice, long xl, long yl){
  102.      FILE *s;
  103.      s = fopen(file_name,"wb");
  104.  
  105.     int i1,i2;
  106.     for(i1=0; i1<xl; i1++) 
  107.          for (i2=0; i2<yl; i2++)
  108.                    fprintf(s,"%d%c",matrice[i1][i2],0);
  109.  
  110.     fclose(s);    
  111.  
  112. }
  113.  


Generatore del file del Burning Ship Fractal.
Better view of the source code - Download the source code 
  1. //*************************************//
  2. //******** created by mamo139 *********//
  3. //*** http://mamo139.altervista.org ***//
  4. //*************************************//
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h> 
  8. #include <string.h> 
  9.  
  10.  
  11. //*** strumenti genstione numeri complessi ***//
  12. struct complesso 
  13. { 
  14.    double r; 
  15.    double i; 
  16. }; 
  17. //*** strumenti gestione db
  18. int ** crea_matrice(long x, long y);
  19. void scrivi_matrice(char * file_name, int ** matrice, long xl, long yl);
  20.  
  21. //*** MAIN ***//
  22. int main (void){
  23.  
  24.     char db_name[]="burn";
  25. //*********** PARAMETRI *************//
  26.     long larghezza = 2000;
  27.     long altezza = 2000;
  28.     long deep = 2000;
  29.  
  30.          double y1 = 2;
  31.     double x0 = -2, x1 = 2;  
  32.          double y0 = -2;
  33. //**********************************//
  34. //aggiustamento parametri
  35.     double agg_temp;
  36.     agg_temp=y1;
  37.     y1=y0*(-1);
  38.     y0=agg_temp*(-1);
  39. //**********************************//
  40.  
  41.     int ** matrice;
  42.     matrice = crea_matrice(larghezza,altezza);
  43.  
  44.     //inizio elaborazione immagine
  45.     long x,y,d,i;
  46.     double real_x,real_y, colore;
  47.     struct complesso z,c,temp;
  48.  
  49.     for(x=0;x<larghezza;x++){
  50.         real_x = ((x1-x0)/larghezza)*x+x0;
  51.         for(y=0;y<altezza;y++){
  52.             real_y = ((y1-y0)/altezza)*y+y0;
  53.  
  54.             //analisi di mendelbrot
  55.             c.r = real_x;
  56.             c.i = real_y;
  57.             z.r = 0;
  58.             z.i = 0;
  59.             d = 0;
  60.             for(i=0;i<deep;i++){
  61.                 if((z.r*z.r)+(z.i*z.i) > 4) {
  62.                     d = i;
  63.                     break;
  64.                 }
  65.                 temp.r = z.r;
  66.                 temp.i = z.i;
  67.                 if(temp.r<0)temp.r=temp.r*(-1);if(temp.i<0)temp.i=temp.i*(-1); //condizione burningship
  68.  
  69.                 z.r = (temp.r*temp.r) - (temp.i*temp.i) + c.r;
  70.                 z.i = (temp.r*temp.i)*2 + c.i;
  71.             }
  72.  
  73.             matrice[x][y] = d;
  74.         }
  75.         printf("%d%%\n",x*100/larghezza);
  76.     }
  77.  
  78.     scrivi_matrice(db_name,matrice,larghezza,altezza);
  79.     printf("fine!");
  80.  
  81.  
  82.     getchar();
  83.     return 0;
  84. }
  85. //****** FUNZIONI *******//
  86. int ** crea_matrice(long x, long y){
  87.  
  88.      int ** array;
  89.      int i, j; 
  90.      array = (int**)malloc(x * sizeof(int *)); 
  91.      for(i=0; i<x; i++) { 
  92.           array[i] = (int*)malloc(y * sizeof(int *)); 
  93.      }
  94.  
  95.     int i1,i2;
  96.     for(i1=0; i1<x; i1++) 
  97.          for (i2=0; i2<y; i2++)
  98.                    array[i1][i2] = 0;  
  99.  
  100.      return array;    
  101. }
  102. void scrivi_matrice(char * file_name, int ** matrice, long xl, long yl){
  103.      FILE *s;
  104.      s = fopen(file_name,"wb");
  105.  
  106.     int i1,i2;
  107.     for(i1=0; i1<xl; i1++) 
  108.          for (i2=0; i2<yl; i2++)
  109.                    fprintf(s,"%d%c",matrice[i1][i2],0);
  110.  
  111.     fclose(s);    
  112.  
  113. }
  114.  


Generatore del file del Buddhabrot.
Better view of the source code - Download the source code 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <time.h>
  5.  
  6. struct complesso
  7. {
  8.    double r;
  9.    double i;
  10. };
  11.  
  12. //****** MAIN *******//
  13.  
  14. int main (void){
  15.  
  16.     char immagine_name[]="bu";
  17. //*********** PARAMETRI *************//
  18.     long larghezza = 3000;
  19.     long altezza = 3000;
  20.     long deep = 5000;
  21.     long buddha = 1000000000;
  22.  
  23.          double y1 = 2;
  24.     double x0 = -2, x1 = 2; 
  25.          double y0 = -2;
  26. //**********************************//
  27. //aggiustamento parametri
  28.     double agg_temp;
  29.     agg_temp=y1;
  30.     y1=y0*(-1);
  31.     y0=agg_temp*(-1);
  32. //**********************************//
  33.  
  34.     time_t t;
  35.     srand((unsigned) time(&t));
  36.     long b=0;
  37.     long x,y;
  38.  
  39.     long ** buddha_value;
  40.     buddha_value = (long**) malloc(larghezza * sizeof(long *));
  41.     for(b=0; b<larghezza; b++)
  42.           buddha_value[b] = (long*) malloc(altezza * sizeof(long));
  43.     for(x=0;x<larghezza;x++)for(y=0;y<altezza;y++)buddha_value[x][y]=0;
  44.  
  45.     struct complesso *history;
  46.     history = (struct complesso*)malloc(deep * sizeof(struct complesso)); 
  47.  
  48.     printf("operazioni iniziali effettuate, inizio cicli!\n");
  49.  
  50. for(b=0;b<buddha;b++){ //ciclo buddhabrot
  51.  
  52.     //inizio elaborazione immagine
  53.     long x,y,d,i,a;
  54.     double real_x, real_y, colore;
  55.     struct complesso z,c,temp;
  56.  
  57.         x=(rand())%larghezza;
  58.         y=(rand())%altezza;
  59.  
  60.         real_x = ((x1-x0)/larghezza)*x+x0;
  61.             real_y = ((y1-y0)/altezza)*y+y0;
  62.             //analisi di mendelbrot
  63.             c.r = real_x;
  64.             c.i = real_y;
  65.             z.r = 0;
  66.             z.i = 0;
  67.             d = 0;
  68.             for(i=1;i<deep;i++){
  69.                 if((z.r*z.r)+(z.i*z.i) > 4) {
  70.                     d = i;
  71.                     break;
  72.                 }
  73.                 temp.r = z.r;
  74.                 temp.i = z.i;
  75.  
  76.                 z.r = (temp.r*temp.r) - (temp.i*temp.i) + c.r;
  77.                 z.i = (temp.r*temp.i)*2 + c.i;
  78.  
  79.                 history[i].r = z.r;
  80.                 history[i].i = z.i;
  81.             }
  82.  
  83.             //controllo punto dell'insieme di mendelbrot
  84.             if(d!=0) {
  85.             for(a=0;a<d;a++){ //disegno la strada del punto
  86.                 x=(long) ((double)(history[a].r-x0)*larghezza/(x1-x0));
  87.                 y=(long) ((double)(history[a].i-y0)*altezza/(y1-y0));
  88.                 if(x>0 && x<larghezza && y>0 && y<altezza){
  89.                        buddha_value[x][y]++;
  90.                 }   
  91.             }
  92.             }
  93.  
  94.  
  95.     if(b%1000000==0)printf("%d su %d gruppi da 1000.000 cicli completati!\n",b/1000000,buddha/1000000);
  96. } //fine buddha
  97.  
  98.     //creo db
  99.     printf("\nCreazione db in corso...\n");
  100.     FILE *s;
  101.     s = fopen(immagine_name,"wb");
  102.     for(x=0;x<larghezza;x++)
  103.     for(y=0;y<altezza;y++){
  104.          fprintf(s,"%d%c",buddha_value[x][y],0);
  105.     }
  106.     fclose(s);   
  107.     printf("db creato.\n");
  108.  
  109.     printf("fine!");
  110.  
  111.     getchar();
  112.     return 0;
  113. }
  114.  
  115.  


Generatore del file del Anti-Buddhabrot.
Better view of the source code - Download the source code 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <time.h>
  5.  
  6. struct complesso
  7. {
  8.    double r;
  9.    double i;
  10. };
  11.  
  12. //****** MAIN *******//
  13.  
  14. int main (void){
  15.  
  16.     char immagine_name[]="bu";
  17. //*********** PARAMETRI *************//
  18.     long larghezza = 2000;
  19.     long altezza = 2000;
  20.     long deep = 1000;
  21.     long buddha = 10000000;
  22.  
  23.          double y1 = 2;
  24.     double x0 = -2, x1 = 2; 
  25.          double y0 = -2;
  26. //**********************************//
  27. //aggiustamento parametri
  28.     double agg_temp;
  29.     agg_temp=y1;
  30.     y1=y0*(-1);
  31.     y0=agg_temp*(-1);
  32. //**********************************//
  33.  
  34.     time_t t;
  35.     srand((unsigned) time(&t));
  36.     long b=0;
  37.     long x,y;
  38.  
  39.     long ** buddha_value;
  40.     buddha_value = (long**) malloc(larghezza * sizeof(long *));
  41.     for(b=0; b<larghezza; b++)
  42.           buddha_value[b] = (long*) malloc(altezza * sizeof(long));
  43.     for(x=0;x<larghezza;x++)for(y=0;y<altezza;y++)buddha_value[x][y]=0;
  44.  
  45.     struct complesso *history;
  46.     history = (struct complesso*)malloc(deep * sizeof(struct complesso)); 
  47.  
  48.     printf("operazioni iniziali effettuate, inizio cicli!\n");
  49.  
  50. for(b=0;b<buddha;b++){ //ciclo buddhabrot
  51.  
  52.     //inizio elaborazione immagine
  53.     long x,y,d,i,a;
  54.     double real_x, real_y, colore;
  55.     struct complesso z,c,temp;
  56.  
  57.         x=(rand())%larghezza;
  58.         y=(rand())%altezza;
  59.  
  60.         real_x = ((x1-x0)/larghezza)*x+x0;
  61.             real_y = ((y1-y0)/altezza)*y+y0;
  62.             //analisi di mendelbrot
  63.             c.r = real_x;
  64.             c.i = real_y;
  65.             z.r = 0;
  66.             z.i = 0;
  67.             d = 0;
  68.             for(i=1;i<deep;i++){
  69.                 if((z.r*z.r)+(z.i*z.i) > 4) {
  70.                     d = i;
  71.                     break;
  72.                 }
  73.                 temp.r = z.r;
  74.                 temp.i = z.i;
  75.  
  76.                 z.r = (temp.r*temp.r) - (temp.i*temp.i) + c.r;
  77.                 z.i = (temp.r*temp.i)*2 + c.i;
  78.  
  79.                 history[i].r = z.r;
  80.                 history[i].i = z.i;
  81.             }
  82.  
  83.             //controllo punto dell'insieme di mendelbrot
  84.             if(d==0) {
  85.             for(a=0;a<deep;a++){ //disegno la strada del punto
  86.                 x=(long) ((double)(history[a].r-x0)*larghezza/(x1-x0));
  87.                 y=(long) ((double)(history[a].i-y0)*altezza/(y1-y0));
  88.                 if(x>0 && x<larghezza && y>0 && y<altezza){
  89.                        buddha_value[x][y]++;
  90.                 }   
  91.             }
  92.             }
  93.  
  94.  
  95.     if(b%1000000==0)printf("%d su %d gruppi da 1000.000 cicli completati!\n",b/1000000,buddha/1000000);
  96. } //fine buddha
  97.  
  98.     //creo db
  99.     printf("\nCreazione db in corso...\n");
  100.     FILE *s;
  101.     s = fopen(immagine_name,"wb");
  102.     for(x=0;x<larghezza;x++)
  103.     for(y=0;y<altezza;y++){
  104.          fprintf(s,"%d%c",buddha_value[x][y],0);
  105.     }
  106.     fclose(s);   
  107.     printf("db creato.\n");
  108.  
  109.     printf("fine!");
  110.  
  111.     getchar();
  112.     return 0;
  113. }
  114.  
  115.  
Website version: 1.03.01 by mamo139. - All the source codes are intended to be released under "GNU GPL version 3".