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

<< Mappa della luminosità >>

visiste: 4815


Semplice programma che sostituisce il colore con la luminosità.





  1. //*************************************//
  2. //******** created by mamo139 *********//
  3. //*** http://mamo139.altervista.org ***//
  4. //*************************************//
  5.  
  6.  
  7. #include <stdio.h>
  8. #include <windows.h>
  9. #include <math.h>
  10.  
  11. unsigned char* dammibit(unsigned char numero);
  12. unsigned char dammichar(unsigned char *bits);
  13. unsigned int * rgb_hsv(unsigned int *);
  14. unsigned int * hsv_rgb(unsigned int *);
  15. /*
  16.   char *bits;
  17. bits = new char [8];
  18. bits = dammibit(154);
  19. */
  20.  
  21. int main (void){
  22.  
  23. char nomefileb[20];
  24. printf("nome del file base:");
  25. scanf("%s",nomefileb);
  26. printf("%s!\n",nomefileb);
  27. //peso supportabile dal file base con steganografia 3-3-2bit
  28. FILE * pFile;
  29. long lSize;
  30. pFile = fopen ( nomefileb , "rb" );
  31. fseek (pFile , 0 , SEEK_END);
  32. lSize = ftell (pFile);
  33. fclose (pFile);
  34.  
  35.  
  36. long lbuffer = lSize; //byte letti alla volta nella base
  37. printf("buffer impostato a %d bytes\n",lbuffer);
  38.  
  39. unsigned char *buf; //buffer di lettura
  40. buf = new unsigned char [(lbuffer)+100]; //grandezza del buffer della base
  41.  
  42. FILE *file, *f_out;
  43. if ((file = fopen(nomefileb, "rb")) && (f_out = fopen("cript.bmp", "wb"))){
  44.  
  45. printf("files aperti con successo!!\n");
  46.  
  47. long b; //byte letti
  48. b = fread( buf, 1, 54, file);
  49.  
  50. unsigned int coordx = buf[18]+buf[19]*256;
  51. unsigned int coordy = buf[22]+buf[23]*256;
  52. printf("caratteristiche immagine: %d x %d\n",coordx,coordy);
  53.  
  54.  
  55. fwrite( buf, 1, b, f_out);
  56. printf("header scritto...\n");
  57.  
  58. //******************************INIZIO LETTURA DEL FILE*********************************//
  59. b = fread( buf, 1, lbuffer, file);
  60. printf("file caricato nel buffer...\n");
  61.  
  62. long x,y,z=0;
  63. //caricamento in array bidimensionale...
  64. //unsigned char mappa[coordx][coordy][4];
  65. int x1=coordx, y1=coordy, z1=3; // Le dimensioni
  66. unsigned char ***mappa;
  67. int i, j;
  68. mappa=(unsigned char***)malloc(x1 * sizeof(unsigned char *));
  69. for(i=0; i<x1; i++) {
  70. mappa[i]=(unsigned char**)malloc(y1 * sizeof(unsigned char *));
  71. for (j=0; j<y1; j++)
  72. mappa[i][j]=(unsigned char*)malloc(z1 * sizeof(unsigned char));
  73. }
  74. printf("mappa a due dimensioni creata...\n");
  75.  
  76. for(y=0; y < coordy ;y++){
  77. printf("loaded: y=%d\n",y);
  78. for(x=0;x < coordx;x++){
  79. mappa[x][y][0] = buf[z];
  80. mappa[x][y][1] = buf[(z+1)];
  81. mappa[x][y][2] = buf[(z+2)];
  82. z=z+3;
  83. }}
  84. printf("byte immagazzinati nella mappa: %d \n",z);
  85.  
  86. free(buf);
  87.  
  88. //*****************************INIZIO MODE DEL FILE**********************************//
  89.  
  90.  
  91.  
  92. for(y=0; y < coordy ; y++){
  93. for(x=0; x < coordx ; x++){
  94. unsigned int *wbuf;
  95. wbuf = new unsigned int [3];
  96. unsigned int *wbuf3;
  97.  
  98. unsigned char *wbuf2;
  99. wbuf2 = new unsigned char [3];
  100.  
  101. wbuf[0]=mappa[x][y][0];
  102. wbuf[1]=mappa[x][y][1];
  103. wbuf[2]=mappa[x][y][2];
  104.  
  105.  
  106. wbuf3 = rgb_hsv(wbuf);
  107.  
  108. wbuf3[0]=360 - (wbuf3[2]*256/360);
  109. wbuf3[1]=200;
  110. wbuf3[2]=200;
  111.  
  112. wbuf = hsv_rgb(wbuf3);
  113.  
  114. wbuf2[0]=wbuf[0];
  115. wbuf2[1]=wbuf[1];
  116. wbuf2[2]=wbuf[2];
  117.  
  118.  
  119. fwrite( wbuf2, 1, 3, f_out);
  120. delete [] wbuf2;
  121. delete [] wbuf3;
  122. delete [] wbuf;
  123.  
  124. } printf("%d%%\n",(y*100/coordy)); }
  125.  
  126.  
  127.  
  128. //fwrite( buf, 1, b, f_out);
  129.  
  130. }
  131.  
  132.  
  133. fclose(file);
  134. fclose(f_out);
  135.  
  136. system("PAUSE");
  137. return 1;
  138. }
  139.  
  140.  
  141. unsigned int * hsv_rgb(unsigned int hsv[3]){
  142.  
  143. //printf("REVERSE:\nH:%d\nS:%d\nV:%d\n",hsv[0],hsv[1],hsv[2]);
  144. double *dRGB;
  145. dRGB = new double[3];
  146.  
  147. double H = ((double)hsv[0]);
  148. double S = ((double)hsv[1])/255;
  149. double V = ((double)hsv[2])/255;
  150.  
  151. double hi = ((int)(H/60))%6;
  152. double f = (H/60) - (double)hi;
  153. double p = V*(1-S);
  154. double q = V*(1-(f*S));
  155. double t = V*(1-(1-f)*S);
  156.  
  157. if (hi == 0){ dRGB[0]=V;dRGB[1]=t;dRGB[2]=p;}
  158. else if (hi == 1){ dRGB[0]=q;dRGB[1]=V;dRGB[2]=p;}
  159. else if (hi == 2){ dRGB[0]=p;dRGB[1]=V;dRGB[2]=t;}
  160. else if (hi == 3){ dRGB[0]=p;dRGB[1]=q;dRGB[2]=V;}
  161. else if (hi == 4){ dRGB[0]=t;dRGB[1]=p;dRGB[2]=V;}
  162. else if (hi == 5){ dRGB[0]=V;dRGB[1]=p;dRGB[2]=q;}
  163. else printf("ERRORE!");
  164.  
  165. //printf("R:%f\nG:%f\nB:%f\n",dRGB[0],dRGB[1],dRGB[2]);
  166.  
  167. unsigned int *RGB;
  168. RGB = new unsigned int[3];
  169.  
  170. RGB[0] = (int)(dRGB[2]*255);
  171. RGB[1] = (int)(dRGB[1]*255);
  172. RGB[2] = (int)(dRGB[0]*255);
  173.  
  174. free(dRGB);
  175.  
  176. //printf("R:%d\nG:%d\nB:%d\n",RGB[0],RGB[1],RGB[2]);
  177. return RGB;
  178. }
  179.  
  180. unsigned int * rgb_hsv(unsigned int rgb[3]){
  181.  
  182. //colore rgb e hsv
  183. unsigned int *RGB;
  184. RGB = new unsigned int[3];
  185. unsigned int *HSV;
  186. HSV = new unsigned int[3];
  187.  
  188. //definizione del colore
  189. RGB[0]=rgb[2];
  190. RGB[1]=rgb[1];
  191. RGB[2]=rgb[0];
  192.  
  193. double *dRGB;
  194. dRGB = new double[3];
  195. double *dHSV;
  196. dHSV = new double[3];
  197.  
  198. //(0,1)
  199. dRGB[0]= ((double)RGB[0])/255;
  200. dRGB[1]= ((double)RGB[1])/255;
  201. dRGB[2]= ((double)RGB[2])/255;
  202.  
  203. //printf("R:%f\nG:%f\nB:%f\n",dRGB[0],dRGB[1],dRGB[2]);
  204.  
  205. double gradi = 0;
  206. double MAX= 0, MIN=0, numeratore=0;
  207. double H = 0; //tonalità
  208.  
  209. if( dRGB[0] == dRGB[1] && dRGB[1] == dRGB[2]) { H=0; MAX = dRGB[0]; MIN = dRGB[0]; } //tonalità trovata *********
  210. else{
  211. if( dRGB[0] >= dRGB[1] && dRGB[0] >= dRGB[2] && dRGB[1] >= dRGB[2]){ //rosso maggiore blu minore
  212. MAX = dRGB[0];
  213. MIN = dRGB[2];
  214. gradi = 0;
  215. numeratore = dRGB[1]-dRGB[2];
  216. //printf("a");
  217. }
  218. else if( dRGB[0] >= dRGB[1] && dRGB[0] >= dRGB[2] && dRGB[1] < dRGB[2]){ //rosso maggiore verde minore
  219. MAX = dRGB[0];
  220. MIN = dRGB[1];
  221. gradi = 360;
  222. numeratore = dRGB[1]-dRGB[2];
  223. //printf("b");
  224. }
  225. else if( dRGB[1] >= dRGB[0] && dRGB[1] >= dRGB[2] && dRGB[0] <= dRGB[2]){ //verde maggiore, rosso minore
  226. MAX = dRGB[1];
  227. MIN = dRGB[0];
  228. gradi = 120;
  229. numeratore = dRGB[2]-dRGB[0];
  230. //printf("c");
  231. }
  232. else if( dRGB[1] >= dRGB[0] && dRGB[1] >= dRGB[2] && dRGB[2] < dRGB[0]){ //verde maggiore, blu minore
  233. MAX = dRGB[1];
  234. MIN = dRGB[2];
  235. gradi = 120;
  236. numeratore = dRGB[2]-dRGB[0];
  237. //printf("d");
  238. }
  239. else if( dRGB[2] >= dRGB[0] && dRGB[2] >= dRGB[1] && dRGB[0] <= dRGB[1]){ //blu maggiore, rosso minore
  240. MAX = dRGB[2];
  241. MIN = dRGB[0];
  242. gradi = 240;
  243. numeratore = dRGB[0]-dRGB[1];
  244. //printf("e");
  245. }
  246. else if( dRGB[2] >= dRGB[0] && dRGB[2] >= dRGB[1] && dRGB[1] < dRGB[0]){ //blu maggiore, verde minore
  247. MAX = dRGB[2];
  248. MIN = dRGB[1];
  249. gradi = 240;
  250. numeratore = dRGB[0]-dRGB[1];
  251. //printf("f");
  252. }
  253. else printf("ERRORE!");
  254.  
  255. H = ( (int) (60*(numeratore/(MAX-MIN)) + gradi) ) % 360;//tonalità trovata ***********
  256.  
  257. }
  258.  
  259. double S = 0;//saturazione
  260.  
  261. if(MAX == 0) S = 0; //saturazione trovata **********
  262. else S = (MAX - MIN) / MAX; //saturazione trovata **********
  263.  
  264. double V = MAX; //luminosità/valore trovata **********
  265.  
  266. dHSV[0]=H;
  267. dHSV[1]=S;
  268. dHSV[2]=V;
  269.  
  270. HSV[0]= (int)(dHSV[0]);
  271. HSV[1]= (int)(dHSV[1] * 255);
  272. HSV[2]= (int)(dHSV[2] * 255);
  273.  
  274. //printf("H:%f\nS:%f\nV:%f\n",dHSV[0],dHSV[1],dHSV[2]);
  275. //printf("H:%d\nS:%d\nV:%d\n",HSV[0],HSV[1],HSV[2]);
  276.  
  277. free(dHSV);
  278. free(RGB);
  279. free(dRGB);
  280.  
  281.  
  282. return HSV;
  283. }
  284.  
Versione sito: 1.03.01 by mamo139. - Tutti i sorgenti presenti su questo sito sono rilasciati sotto licenza "GNU GPL version 3".