Italiano
HOME | PROGETTI | CLASSI C++ | Sorgenti c\c++ | Galleria | Guestbook | Server BW | Contattami | Login

<< Fractal Generator >>

visiste: 2570


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.
  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.
  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.
  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.
  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.
  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.  
Versione sito: 1.03.01 by mamo139. - Tutti i sorgenti presenti su questo sito sono rilasciati sotto licenza "GNU GPL version 3".