· 7 years ago · Jan 02, 2019, 07:16 PM
1#include <stdio.h>
2#include <stdlib.h>
3#include <malloc.h>
4//#include "XORSHIFT32.h"
5#include <math.h>
6#define presumed_detections 500
7
8#if 1 //ALL CODE
9typedef struct
10{
11 unsigned char b, g, r;
12}pixel;
13
14typedef struct
15{
16 unsigned int inaltime;
17 unsigned int latime;
18 pixel *vector_valori;
19}BMP_image;
20// |-----------------------------------|---/||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\
21// | PARTEA INTAI - IMAGE CRIPTING |---/||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\
22// |-----------------------------------|---/||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\
23
24#if 0
25
26BMP_image* citire_si_liniarizare(char *nume_img)
27{
28 BMP_image *img = (BMP_image*)malloc(sizeof(BMP_image) * 1);
29
30 int i, j;
31 FILE *fin = NULL;
32 fin = fopen(nume_img, "rb");
33 //FILE *fout = fopen("test_citire.bmp", "wb");
34 if (fin == NULL)
35 {
36 printf("nu am gasit imaginea sursa din care citesc\n");
37 system("pause");
38 exit(1);
39 }
40 //if (fout == NULL)
41 //{
42 // printf("nu am gasit imaginea sursa din care citesc\n");
43 // system("pause");
44 // exit(1);
45 //}
46
47 ///
48
49 fseek(fin, 18, SEEK_SET);
50 fread(&img->latime, sizeof(unsigned int), 1, fin);
51 fread(&img->inaltime, sizeof(unsigned int), 1, fin);
52 printf("Dimensiunea imaginii in pixeli (latime x inaltime): %u x %u\n", img->latime, img->inaltime);
53
54 ///
55
56 //fseek(fin, 0, SEEK_SET);
57
58 char *temp_pixel = (char*)malloc(3 * sizeof(char));
59
60 img->vector_valori = (pixel*)malloc((img->inaltime*img->latime) * sizeof(pixel));
61
62 int padding;
63 if (img->latime % 4 != 0)
64 padding = 4 - (3 * img->latime) % 4;
65 else
66 padding = 0;
67
68 /*char header[54];
69 fread(header, sizeof(char), 54, fin);
70 fwrite(header, sizeof(char), 54, fout);*/
71 fseek(fin, 54, SEEK_SET);
72
73
74
75 for (i = img->inaltime - 1; i >= 0; i--)
76 {
77
78 for (j = 0; j < img->latime; j++)
79 {
80 fread(temp_pixel, sizeof(char), 3, fin);
81 //fwrite(&temp_pixel, sizeof(char), 3, fout);
82 //fflush(fout);
83 img->vector_valori[i*img->latime + j].b = temp_pixel[0];
84 img->vector_valori[i*img->latime + j].g = temp_pixel[1];
85 img->vector_valori[i*img->latime + j].r = temp_pixel[2];
86 //fwrite(&img->vector_valori[i*img->latime + j].b, sizeof(char), 1, fout);
87 //fwrite(&img->vector_valori[i*img->latime + j].g, sizeof(char), 1, fout);
88 //fwrite(&img->vector_valori[i*img->latime + j].r, sizeof(char), 1, fout);
89 fflush(fin);
90 }
91
92 fseek(fin, padding, SEEK_CUR);
93 //fseek(fout, padding, SEEK_CUR);
94 }
95
96 fclose(fin);
97 //fclose(fout);
98 free(temp_pixel);
99 return img;
100}
101unsigned int* xorshift32(int seed, int size)
102{
103 unsigned int r, k;
104 r = seed;
105 unsigned int *output = (unsigned int*)malloc(size * sizeof(unsigned int));
106 for (k = 0; k < size; k++)
107 {
108 r = r ^ r << 13;
109 r = r ^ r >> 17;
110 r = r ^ r << 5;
111 output[k] = r;
112 //pt ca populez de la 0 si nu de la 1,oriunde folosesc aleator, scad 1
113 }
114 return output;
115}
116BMP_image* permutare(BMP_image *img, unsigned int *aleatoare)
117{
118 pixel p;
119
120 int *sigma = (int*)malloc((img->inaltime*img->latime) * sizeof(int));
121 for (int i = 0; i <= img->inaltime*img->latime - 1; i++)
122 sigma[i] = i;
123
124 for (int i = img->latime*img->inaltime - 1, k = 0; i >= 1; i--)
125 {
126 unsigned int r = aleatoare[k++] % (i + 1);
127 int aux = sigma[r];
128 sigma[r] = sigma[i];
129 sigma[i] = aux;
130 }
131
132 BMP_image *intermediare;
133 intermediare = (BMP_image*)malloc(sizeof(BMP_image));
134
135 intermediare->inaltime = img->inaltime;
136 intermediare->latime = img->latime;
137
138 intermediare->vector_valori = (pixel*)malloc((img->latime*img->inaltime) * sizeof(pixel));
139
140 for (int i = 0; i <= img->inaltime*img->latime - 1; i++)
141 intermediare->vector_valori[sigma[i]] = img->vector_valori[i];
142
143 return intermediare;
144}
145void criptare(BMP_image *img, unsigned int *aleatoare, char *secret_key)
146{
147 FILE *fin = fopen(secret_key, "rt");
148 if (fin == NULL)
149 {
150 fprintf(stderr, "nu s a gasit secret key");
151 system("pause");
152 exit(1);
153
154 }
155 unsigned int seed, SV;
156
157 fscanf(fin, "%u", &seed);
158 fscanf(fin, "%u", &SV);
159
160 int i;
161 img->vector_valori[0].b = SV ^ img->vector_valori[0].b ^ aleatoare[img->inaltime*img->latime - 1];
162 img->vector_valori[0].g = (SV >> 8) ^ img->vector_valori[0].g ^ (aleatoare[img->inaltime*img->latime - 1] >> 8);
163 img->vector_valori[0].r = (SV >> 16) ^ img->vector_valori[0].r ^ (aleatoare[img->inaltime*img->latime - 1] >> 16);
164
165 for (i = 1; i <= img->inaltime*img->latime - 1; i++)
166 {
167 img->vector_valori[i].b = img->vector_valori[i - 1].b ^ img->vector_valori[i].b ^ aleatoare[img->inaltime*img->latime - 1 + i];//ma duc cu -1 mereu unde am aleatoriu
168 img->vector_valori[i].g = img->vector_valori[i - 1].g ^ img->vector_valori[i].g ^ (aleatoare[img->inaltime*img->latime - 1 + i] >> 8);
169 img->vector_valori[i].r = img->vector_valori[i - 1].r ^ img->vector_valori[i].r ^ (aleatoare[img->inaltime*img->latime - 1 + i] >> 16);
170 }
171 fclose(fin);
172}
173void creare_img(BMP_image *img, char *nume_img_sursa, char *nume_img_dest)
174{
175 FILE *fin = NULL;
176 FILE *fout = NULL;
177 fin = fopen(nume_img_sursa, "rb");
178 fout = fopen(nume_img_dest, "wb");
179
180 if (fin == NULL)
181 {
182 perror("fopen");
183 fprintf(stderr, "can't open file %s", nume_img_sursa);
184 exit(1);
185 }
186
187 if (fout == NULL)
188 {
189 perror("fopen");
190 fprintf(stderr, "can't open file %s", nume_img_dest);
191 exit(1);
192 }
193
194 unsigned char c;
195 int i, j;
196
197 //padding :
198 int padding;
199 if (img->latime % 4 != 0)
200 padding = 4 - (3 * img->latime) % 4;
201 else
202 padding = 0;
203
204 char header[54];
205 fread(header, sizeof(char), 54, fin);
206 fwrite(header, sizeof(char), 54, fout);
207
208 /*for (i = 0; i < 54; i++)
209 {
210 fread(&c, sizeof(char), 1, fin);
211 fwrite(&c, sizeof(char), 1, fout);
212 fflush(fout);
213 }*/
214
215 // pixel p;
216 for (i = img->inaltime - 1; i >= 0; i--)
217 {
218 for (j = 0; j < img->latime; j++)
219 {
220
221 fwrite(&img->vector_valori[i*img->latime + j].b, sizeof(char), 1, fout);
222 fflush(fout);
223 fwrite(&img->vector_valori[i*img->latime + j].g, sizeof(char), 1, fout);
224 fflush(fout);
225 fwrite(&img->vector_valori[i*img->latime + j].r, sizeof(char), 1, fout);
226 fflush(fout);
227 }
228 if (i != 0)
229 fseek(fout, padding, SEEK_CUR);
230 }
231
232 char *end_of_file = (char*)calloc(padding, sizeof(char));
233 fwrite(end_of_file, sizeof(char), padding, fout);
234
235 free(end_of_file);
236 fclose(fin);
237 fclose(fout);
238}
239void testul_chi_patrat(BMP_image *img)
240{
241 unsigned int *frecventa_blue = (int*)malloc(256 * sizeof(unsigned int));
242 unsigned int *frecventa_green = (int*)malloc(256 * sizeof(unsigned int));
243 unsigned int *frecventa_red = (int*)malloc(256 * sizeof(unsigned int));
244
245 memset(frecventa_blue, 0, sizeof(int) * 256);
246 memset(frecventa_green, 0, sizeof(int) * 256);
247 memset(frecventa_red, 0, sizeof(int) * 256);
248
249 int k, i;
250
251 double suma_blue = 0, suma_green = 0, suma_red = 0;
252 double frecventa_medie = (img->inaltime*img->latime) / 256.0;
253
254 for (i = 0; i < img->latime*img->inaltime; i++)
255 {
256 frecventa_blue[(unsigned char)img->vector_valori[i].b]++;
257 frecventa_green[(unsigned char)img->vector_valori[i].g]++;
258 frecventa_red[(unsigned char)img->vector_valori[i].r]++;
259 }
260
261 for (i = 0; i < 256; i++)
262 {
263 suma_blue = suma_blue + ((frecventa_blue[i] - frecventa_medie)*(frecventa_blue[i] - frecventa_medie)) / frecventa_medie;
264 suma_green = suma_green + ((frecventa_green[i] - frecventa_medie)*(frecventa_green[i] - frecventa_medie)) / frecventa_medie;
265 suma_red = suma_red + ((frecventa_red[i] - frecventa_medie)*(frecventa_red[i] - frecventa_medie)) / frecventa_medie;
266 }
267
268 printf("Red = %.2f \nGreen = %.2f \nBlue = %.2f \n\n", suma_red, suma_green, suma_blue);
269
270 free(frecventa_blue);
271 free(frecventa_green);
272 free(frecventa_red);
273
274}
275BMP_image* decriptare(BMP_image *img, unsigned int *aleatoare, char *secret_key)
276{
277 FILE *fin = fopen(secret_key, "rt");
278 if (fin == NULL)
279 {
280 fprintf(stderr, "nu s a gasit secret key");
281 system("pause");
282 exit(1);
283
284 }
285 unsigned int seed, SV;
286
287 fscanf(fin, "%u", &seed);
288 fscanf(fin, "%u", &SV);
289
290 BMP_image *vector_decriptat = (BMP_image*)malloc(sizeof(BMP_image));
291 vector_decriptat->vector_valori = (pixel*)malloc((img->inaltime * img->latime) * sizeof(pixel));
292
293 vector_decriptat->inaltime = img->inaltime;
294 vector_decriptat->latime = img->latime;
295
296 vector_decriptat->vector_valori[0].b = SV ^ img->vector_valori[0].b ^ (aleatoare[img->inaltime * img->latime - 1]);
297 vector_decriptat->vector_valori[0].g = (SV >> 8) ^ img->vector_valori[0].g ^ (aleatoare[img->inaltime * img->latime - 1] >> 8);
298 vector_decriptat->vector_valori[0].r = (SV >> 16) ^ img->vector_valori[0].r ^ (aleatoare[img->inaltime * img->latime - 1] >> 16);
299
300 for (int i = 1; i < img->inaltime * img->latime; i++)
301 {
302 vector_decriptat->vector_valori[i].b = img->vector_valori[i - 1].b ^ img->vector_valori[i].b ^ aleatoare[img->inaltime*img->latime - 1 + i];//ma duc cu -1 mereu unde am aleatoriu
303 vector_decriptat->vector_valori[i].g = img->vector_valori[i - 1].g ^ img->vector_valori[i].g ^ (aleatoare[img->inaltime*img->latime - 1 + i] >> 8);
304 vector_decriptat->vector_valori[i].r = img->vector_valori[i - 1].r ^ img->vector_valori[i].r ^ (aleatoare[img->inaltime*img->latime - 1 + i] >> 16);
305 }
306
307 unsigned int *sigma = (unsigned int*)malloc((img->inaltime*img->latime) * sizeof(unsigned int));
308
309 for (int i = 0; i <= img->inaltime*img->latime - 1; i++)
310 sigma[i] = i;
311
312 for (int i = img->latime*img->inaltime - 1, k = 0; i >= 1; i--)
313 {
314 unsigned int r = aleatoare[k++] % (i + 1);
315 int aux = sigma[r];
316 sigma[r] = sigma[i];
317 sigma[i] = aux;
318 }
319 BMP_image *img_decriptata = (BMP_image*)malloc(sizeof(BMP_image));
320 img_decriptata->vector_valori = (pixel*)malloc((img->inaltime * img->latime) * sizeof(pixel));
321
322 img_decriptata->inaltime = img->inaltime;
323 img_decriptata->latime = img->latime;
324
325 unsigned int *sigma_invers = (unsigned int*)malloc((img->inaltime*img->latime) * sizeof(unsigned int));
326 for (long i = (long)(img->latime*img->inaltime) - 1; i >= 0; i--)
327 sigma_invers[sigma[i]] = i;
328
329 for (unsigned i = 0; i < img->latime*img->inaltime; i++)
330 {
331 img_decriptata->vector_valori[sigma_invers[i]] = vector_decriptat->vector_valori[i];
332 }
333 return img_decriptata;
334}
335
336#endif
337// |--------------------------------------|---/||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\
338// | PARTEA A 2 A - TEMPLATE MATCHING |---/||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\
339// |--------------------------------------|---/||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\
340
341#if 1
342typedef struct
343{
344 int indiceI;
345 int indiceJ;
346 double corelatie;
347 pixel culoare;
348
349}detectie;
350
351typedef struct
352{
353 int inaltime;
354 int latime;
355 pixel **matrice;
356}BMP_matrice;
357
358void grayscale_image(char* nume_fisier_sursa, char* nume_fisier_destinatie)
359{
360 FILE *fin, *fout;
361 unsigned int dim_img, latime_img, inaltime_img;
362 unsigned char pRGB[3], header[54], aux;
363
364 //printf("nume_fisier_sursa = %s \n", nume_fisier_sursa);
365
366 fin = fopen(nume_fisier_sursa, "rb");
367 if (fin == NULL)
368 {
369 printf("nu am gasit imaginea sursa din care citesc");
370 return;
371 }
372
373 fout = fopen(nume_fisier_destinatie, "wb+");
374
375 fseek(fin, 2, SEEK_SET);
376 fread(&dim_img, sizeof(unsigned int), 1, fin);
377 //printf("Dimensiunea imaginii in octeti: %u\n", dim_img);
378
379 fseek(fin, 18, SEEK_SET);
380 fread(&latime_img, sizeof(unsigned int), 1, fin);
381 fread(&inaltime_img, sizeof(unsigned int), 1, fin);
382 //printf("Dimensiunea imaginii in pixeli (latime x inaltime): %u x %u\n", latime_img, inaltime_img);
383
384 //copiaza octet cu octet imaginea initiala in cea noua
385 fseek(fin, 0, SEEK_SET);
386 unsigned char c;
387 while (fread(&c, 1, 1, fin) == 1)
388 {
389 fwrite(&c, 1, 1, fout);
390 fflush(fout);
391 }
392 fclose(fin);
393
394 //calculam padding-ul pentru o linie
395 int padding;
396 if (latime_img % 4 != 0)
397 padding = 4 - (3 * latime_img) % 4;
398 else
399 padding = 0;
400
401 //printf("padding = %d \n", padding);
402
403 fseek(fout, 54, SEEK_SET);
404 int i, j;
405 for (i = 0; i < inaltime_img; i++)
406 {
407 for (j = 0; j < latime_img; j++)
408 {
409 //citesc culorile pixelului
410 fread(pRGB, 3, 1, fout);
411 //fac conversia in pixel gri
412 aux = 0.299*pRGB[2] + 0.587*pRGB[1] + 0.114*pRGB[0];
413 pRGB[0] = pRGB[1] = pRGB[2] = aux;
414 fseek(fout, -3, SEEK_CUR);
415 fwrite(pRGB, 3, 1, fout);
416 fflush(fout);
417 }
418 fseek(fout, padding, SEEK_CUR);
419 }
420 fclose(fout);
421}
422BMP_matrice* creare_matrice(char *nume_img_sursa)
423{
424 FILE *fin = NULL;
425 FILE *fout = NULL;
426 fin = fopen(nume_img_sursa, "rb");
427 fout = fopen("test_citire.bmp", "wb");
428 if (fin == NULL)
429 {
430 fprintf(stderr, "Imaginea %s nu a putut fi gasita", nume_img_sursa);
431 system("pause");
432 exit(1);
433 }
434 if (fout == NULL)
435 {
436 fprintf(stderr, "Imaginea %s nu a putut fi gasita", "test_citire.bmp");
437 system("pause");
438 exit(1);
439 }
440
441 BMP_matrice *img = (BMP_matrice*)malloc(sizeof(BMP_matrice));
442 ///
443 fseek(fin, 18, SEEK_SET);
444 fread(&img->latime, sizeof(unsigned int), 1, fin);
445 fread(&img->inaltime, sizeof(unsigned int), 1, fin);
446 //printf("Dimensiunea imaginii in pixeli (latime x inaltime): %u x %u\n", img->latime, img->inaltime);
447 ///
448
449 img->matrice = (pixel**)malloc(img->inaltime * sizeof(pixel*));
450 for (int i = 0; i < img->inaltime; i++)
451 img->matrice[i] = (pixel*)malloc(img->latime * sizeof(pixel));
452
453 char *temp_pixel = (char*)malloc(3 * sizeof(char));
454
455 fseek(fin, 0, SEEK_SET);
456 char header[54];
457 fread(header, sizeof(char), 54, fin);
458 fwrite(header, sizeof(char), 54, fout);
459
460 int padding;
461 if (img->latime % 4 != 0)
462 padding = 4 - (3 * img->latime) % 4;
463 else
464 padding = 0;
465
466 fseek(fin, 54, SEEK_SET);
467 unsigned char a = 0;
468 for (int i = img->inaltime - 1; i >= 0; i--)
469 {
470 for (int j = 0; j < img->latime; j++)
471 {
472 fread(temp_pixel, sizeof(char), 3, fin);
473 // fwrite(temp_pixel, sizeof(char), 3, fout);
474 //fflush(fout);
475 img->matrice[i][j].b = temp_pixel[0];
476 img->matrice[i][j].g = temp_pixel[1];
477 img->matrice[i][j].r = temp_pixel[2];
478 fwrite(&img->matrice[i][j].b, sizeof(char), 1, fout);
479 fwrite(&img->matrice[i][j].g, sizeof(char), 1, fout);
480 fwrite(&img->matrice[i][j].r, sizeof(char), 1, fout);
481 fflush(fout);
482 //fflush(fin);
483 }
484
485 fseek(fin, padding, SEEK_CUR);
486 fwrite(&a, sizeof(char), padding, fout);
487 //fseek(fout, padding, SEEK_CUR);
488
489 }
490 //printf(". ");
491
492 /*for (int j = 0; j < img->inaltime; j++)
493 for (int k = 0; k < img->latime; k++)
494 printf("%u ", img->matrice[j][k].b);
495 printf("\n\n\n\n\n\n");*/
496
497 fclose(fin);
498 fclose(fout);
499 free(temp_pixel);
500 return img;
501}
502double deviatie_s(double S_mediu, BMP_matrice *sablon)
503{
504 double suma_s = 0;
505 double n = (double)(sablon->latime * sablon->inaltime);
506
507 for (int i = 0; i < sablon->inaltime; i++)
508 for (int j = 0; j < sablon->latime; j++)
509 {
510 suma_s = suma_s + (sablon->matrice[i][j].r - S_mediu)*(sablon->matrice[i][j].r - S_mediu);
511 }
512 suma_s = sqrt(suma_s / (n - 1));
513 return suma_s;
514}
515double deviatie_fi(int i, int j, double fi_mediu, BMP_matrice *sablon, BMP_matrice *img)
516{
517 double suma_fi = 0;
518 double n = (double)(sablon->latime * sablon->inaltime);
519
520 for (int k = i; k < i + sablon->inaltime; k++)
521 for (int q = j; q < j + sablon->latime; q++)
522 {
523 suma_fi = suma_fi + (img->matrice[k][q].r - fi_mediu)*(img->matrice[k][q].r - fi_mediu);
524 }
525
526 suma_fi = sqrt(suma_fi / (n - 1));
527 return suma_fi;
528}
529void contur_fereastra(BMP_matrice **img, int W, int H, detectie *detectii, int i)
530{
531 //printf("contur1\n");
532 for (int k = detectii[i].indiceI; k < detectii[i].indiceI + H; k++)
533 {
534 (*img)->matrice[k][detectii[i].indiceJ].r = detectii[i].culoare.r;
535 (*img)->matrice[k][detectii[i].indiceJ].g = detectii[i].culoare.g;
536 (*img)->matrice[k][detectii[i].indiceJ].b = detectii[i].culoare.b;
537
538 (*img)->matrice[k][detectii[i].indiceJ + W - 1].r = detectii[i].culoare.r;
539 (*img)->matrice[k][detectii[i].indiceJ + W - 1].g = detectii[i].culoare.g;
540 (*img)->matrice[k][detectii[i].indiceJ + W - 1].b = detectii[i].culoare.b;
541 }
542 //printf("contur2\n");
543 for (int k = detectii[i].indiceJ; k < detectii[i].indiceJ + W; k++)
544 {
545 (*img)->matrice[detectii[i].indiceI][k].r = detectii[i].culoare.r;
546 (*img)->matrice[detectii[i].indiceI][k].g = detectii[i].culoare.g;
547 (*img)->matrice[detectii[i].indiceI][k].b = detectii[i].culoare.b;
548
549 (*img)->matrice[detectii[i].indiceI + H - 1][k].r = detectii[i].culoare.r;
550 (*img)->matrice[detectii[i].indiceI + H - 1][k].g = detectii[i].culoare.g;
551 (*img)->matrice[detectii[i].indiceI + H - 1][k].b = detectii[i].culoare.b;
552 }
553
554 //for (int i = 0; i < (*size_detectii); i++)
555 // contur_fereastra(&img, W, H, (*detectii), i);
556}
557double calculeaza_S_mediu(BMP_matrice *sablon, double *S_mediu)
558{
559 for (int i = 0; i < sablon->inaltime; i++)
560 for (int j = 0; j < sablon->latime; j++)
561 *S_mediu = *S_mediu + sablon->matrice[i][j].r;
562 *S_mediu = *S_mediu / (double)(sablon->latime * sablon->inaltime);
563
564 return *S_mediu;
565}
566double calculeaza_fi_mediu(BMP_matrice *img, BMP_matrice *sablon, double *fi_mediu, int i, int j)
567{
568 for (int k = i; k < i + sablon->inaltime; k++)
569 for (int q = j; q < j + sablon->latime; q++)
570 *fi_mediu = *fi_mediu + img->matrice[k][q].r;
571
572 *fi_mediu = *fi_mediu / (sablon->latime*sablon->inaltime);
573 return *fi_mediu;
574}
575double suprapunere(detectie *di, detectie *dj, BMP_matrice *sablon)
576{
577 double arie_di, arie_dj, intersectie, reuniune;
578 if (di->indiceI + sablon->inaltime <= dj->indiceI || di->indiceJ + sablon->latime <= dj->indiceJ)
579 return 0;
580 if (dj->indiceI + sablon->inaltime <= di->indiceI || di->indiceJ + sablon->latime <= di->indiceJ)
581 return 0;
582
583 arie_di = sablon->inaltime * sablon->latime;
584 arie_dj = arie_di;
585 intersectie = (sablon->inaltime - abs(di->indiceI - dj->indiceI))*(sablon->latime - abs(di->indiceJ - dj->indiceJ));
586 reuniune = arie_di + arie_dj - intersectie;
587 return intersectie / reuniune;
588
589}
590void eliminare_non_maxim(int *size_detectii, BMP_matrice *sablon, detectie **detectii)
591{
592 int aux = 0;
593 detectie *new_detectii;
594 new_detectii = (detectie*)malloc((*size_detectii) * sizeof(detectie));
595
596 for (int i = 0; i < (*size_detectii); i++)
597 {
598 if ((*detectii)[i].corelatie == 0)
599 continue;
600 new_detectii[aux] = (*detectii)[i];
601 aux++;
602 for (int j = i + 1; j < (*size_detectii); j++)
603 if (suprapunere(detectii[i], detectii[j], sablon) > 0.2)
604 (*detectii[i]).corelatie = 0;
605 }
606 for (int i = 0; i < aux; i++)
607 (*detectii)[i] = new_detectii[i];
608 (*size_detectii) = aux;
609 free(new_detectii);
610}
611int comparator(const void *c1, const void *c2)
612{
613 detectie *a = ((detectie*)c1);
614 detectie* b = ((detectie*)c2);
615 if (b->corelatie > a->corelatie)
616 return 1;
617 return -1;
618}
619void sorteaza(detectie *detectii, int size_detectii)
620{
621 qsort(detectii, size_detectii, sizeof(detectie), comparator);
622 /*for (int i = 0; i < size_detectii; i++)
623 printf("c = %f\n", detectii[i].corelatie);*/
624
625}
626BMP_matrice* matching_si_corelatie(char *nume_img_sursa_GS, char **vector_sabloane, float prag, detectie **detectii, int *size_detectii, char *nume_img_sursa)
627{
628 printf("Se proceseaza ");
629 *size_detectii = 0;
630 int test = 0;
631 double dev_s;
632 double dev_fi;
633 double corelatie = 0;
634 BMP_matrice *img = creare_matrice(nume_img_sursa_GS);
635
636
637 BMP_matrice *sablon = creare_matrice(vector_sabloane[0]);
638 int W = sablon->latime;
639 int H = sablon->inaltime;
640
641
642 double fi_mediu = 0;
643 double S_mediu = 0;
644
645 for (int nr_sablon = 0; nr_sablon < 10; nr_sablon++)
646 {
647 BMP_matrice *sablon = creare_matrice(vector_sabloane[nr_sablon]);
648 // printf("NUMAR SABLON = %d\n", nr_sablon);
649 printf(". ");
650 S_mediu = calculeaza_S_mediu(sablon, &S_mediu);
651 dev_s = deviatie_s(S_mediu, sablon);
652
653 for (int i = 0; i < img->inaltime - sablon->inaltime; i++)
654 {
655 for (int j = 0; j < img->latime - sablon->latime; j++)
656 {
657 calculeaza_fi_mediu(img, sablon, &fi_mediu, i, j);
658 dev_fi = deviatie_fi(i, j, fi_mediu, sablon, img);
659 //printf("i = %d, j = %d\n", i, j);
660 for (int k = i; k < i + sablon->inaltime; k++)
661 {
662 for (int q = j; q < j + sablon->latime; q++)
663 corelatie += (img->matrice[k][q].r - fi_mediu) * (sablon->matrice[k - i][q - j].r - S_mediu);
664
665 }
666
667 corelatie /= (dev_fi*dev_s);
668 corelatie = corelatie / (sablon->inaltime*sablon->latime);
669
670 if (corelatie >= prag)
671 {
672
673
674 test++;
675
676 if (*size_detectii == 0)
677 (*detectii) = (detectie*)malloc(sizeof(detectie) * presumed_detections);
678 else if ((*size_detectii) >= presumed_detections)
679 (*detectii) = (detectie*)realloc((*detectii), sizeof(detectie)*(1 + *size_detectii));
680
681 (*detectii)[*size_detectii].corelatie = corelatie;
682 (*detectii)[*size_detectii].indiceI = i;
683 (*detectii)[*size_detectii].indiceJ = j;
684
685 switch (nr_sablon)
686 {
687 case 0:
688 {
689 (*detectii)[*size_detectii].culoare.r = 255;
690 (*detectii)[*size_detectii].culoare.g = 0;
691 (*detectii)[*size_detectii].culoare.b = 0;
692 }
693 break;
694
695 case 1:
696 {
697 (*detectii)[*size_detectii].culoare.r = 255;
698 (*detectii)[*size_detectii].culoare.g = 255;
699 (*detectii)[*size_detectii].culoare.b = 0;
700 }
701 break;
702
703 case 2:
704 {
705 (*detectii)[*size_detectii].culoare.r = 0;
706 (*detectii)[*size_detectii].culoare.g = 255;
707 (*detectii)[*size_detectii].culoare.b = 0;
708 }
709 break;
710
711 case 3:
712 {
713 (*detectii)[*size_detectii].culoare.r = 0;
714 (*detectii)[*size_detectii].culoare.g = 255;
715 (*detectii)[*size_detectii].culoare.b = 0;
716 }
717 break;
718
719 case 4:
720 {
721 (*detectii)[*size_detectii].culoare.r = 255;
722 (*detectii)[*size_detectii].culoare.g = 0;
723 (*detectii)[*size_detectii].culoare.b = 255;
724 }
725 break;
726
727 case 5:
728 {
729 (*detectii)[*size_detectii].culoare.r = 0;
730 (*detectii)[*size_detectii].culoare.g = 0;
731 (*detectii)[*size_detectii].culoare.b = 255;
732 }
733 break;
734
735 case 6:
736 {
737 (*detectii)[*size_detectii].culoare.r = 192;
738 (*detectii)[*size_detectii].culoare.g = 192;
739 (*detectii)[*size_detectii].culoare.b = 192;
740 }
741 break;
742
743 case 7:
744 {
745
746 (*detectii)[*size_detectii].culoare.r = 255;
747 (*detectii)[*size_detectii].culoare.g = 140;
748 (*detectii)[*size_detectii].culoare.b = 0;
749 }
750 break;
751
752 case 8:
753 {
754 (*detectii)[*size_detectii].culoare.r = 128;
755 (*detectii)[*size_detectii].culoare.g = 0;
756 (*detectii)[*size_detectii].culoare.b = 128;
757 }
758 break;
759
760 case 9:
761 {
762 (*detectii)[*size_detectii].culoare.r = 128;
763 (*detectii)[*size_detectii].culoare.g = 0;
764 (*detectii)[*size_detectii].culoare.b = 0;
765 }
766 break;
767
768 default:
769 break;
770 }
771 (*size_detectii)++;
772 }
773
774 corelatie = 0;
775 }
776 }
777 }
778 BMP_matrice *img_originala = creare_matrice(nume_img_sursa);
779 /*for (int i = 0; i < (*size_detectii); i++)
780 contur_fereastra(&img_originala, W, H, (*detectii), i);*/
781
782 printf("size detectii = %d\n", (*size_detectii));
783 sorteaza(*detectii, *size_detectii);
784 printf("sortat\n");
785 eliminare_non_maxim(&(*size_detectii), sablon,(&(*detectii)));
786 printf("size detectii dupa eliminare = %d\n", (*size_detectii));
787
788 for (int i = 0; i < (*size_detectii); i++)
789 contur_fereastra(&img_originala, W, H, (*detectii), i);
790
791 free(sablon);
792 printf("\n");
793 return img_originala;
794}
795
796void afisare_matrice(BMP_matrice *img, char *nume_img_sursa, char *nume_img_dest)
797{
798 FILE *fin = NULL;
799 FILE *fout = NULL;
800 fin = fopen(nume_img_sursa, "rb");
801 fout = fopen(nume_img_dest, "wb");
802
803 if (fin == NULL)
804 {
805 perror("fopen");
806 fprintf(stderr, "can't open file %s", nume_img_sursa);
807 exit(1);
808 }
809
810 if (fout == NULL)
811 {
812 perror("fopen");
813 fprintf(stderr, "can't write in file %s", nume_img_dest);
814 exit(1);
815 }
816
817 unsigned char c;
818 int i, j;
819
820 //padding :
821 int padding;
822 if (img->latime % 4 != 0)
823 padding = 4 - (3 * img->latime) % 4;
824 else
825 padding = 0;
826
827 char header[54];
828 fread(header, sizeof(char), 54, fin);
829 fwrite(header, sizeof(char), 54, fout);
830 fclose(fin);
831 /*for (i = 0; i < 54; i++)
832 {
833 fread(&c, sizeof(char), 1, fin);
834 fwrite(&c, sizeof(char), 1, fout);
835 fflush(fout);
836 }*/
837
838 // pixel p;
839 for (i = img->inaltime - 1; i >= 0; i--)
840 {
841 for (j = 0; j < img->latime; j++)
842 {
843 fwrite(&img->matrice[i][j].b, sizeof(char), 1, fout);
844 fflush(fout);
845 fwrite(&img->matrice[i][j].g, sizeof(char), 1, fout);
846 fflush(fout);
847 fwrite(&img->matrice[i][j].r, sizeof(char), 1, fout);
848 fflush(fout);
849 }
850 if (i != 0)
851 fseek(fout, padding, SEEK_CUR);
852 }
853
854 char *end_of_file = (char*)calloc(padding, sizeof(char));
855 fwrite(end_of_file, sizeof(char), padding, fout);
856
857 free(end_of_file);
858
859 fclose(fout);
860}
861
862#endif
863#if 1
864int main()////////////////////////////////////////////////////////////////////////////////////////////////////
865{
866 printf("A intrat in main : \n\n");
867
868 // ---PARTEA INTAI--- //
869
870#if 0
871 char *nume_img_sursa = (char*)malloc(100 * sizeof(char));
872 char *nume_img_dest = (char*)malloc(100 * sizeof(char));
873 char *nume_img_decriptata = (char*)malloc(100 * sizeof(char));
874 char *secret_key = (char*)malloc(100 * sizeof(char));
875
876
877 /// CITIRE SI LINIARIZARE + TEST CHI ///
878 printf("\nCum sa se numeasca imaginea sursa pe care vrei sa o criptezi : \n");
879 scanf("%s", nume_img_sursa);
880
881 BMP_image *imagine_sursa = citire_si_liniarizare(nume_img_sursa);
882 printf("TESTUL CHI INAINTE DE CRIPTARE :\n\n");
883 testul_chi_patrat(imagine_sursa);
884
885 /// XORSHIFT32 ///
886
887
888 printf("\nCare este numele fisierului care contine cheia secreta : \n");
889 scanf("%s", secret_key);
890 FILE *fin = fopen(secret_key, "rt");
891 unsigned int seed;
892 fscanf(fin, "%u", &seed);
893 unsigned int *aleatoare = xorshift32(seed, imagine_sursa->latime*imagine_sursa->inaltime * 2 - 1);
894 fclose(fin);
895 /// PERRMUTARE ///
896 BMP_image *imagine_permutata = permutare(imagine_sursa, aleatoare);
897 //creare_img(imagine_permutata, nume_img_sursa, "peppers_permutat.bmp");
898
899
900 /// CRIPTARE + TEST CHI///
901 printf("\nCum sa se numeasca imaginea criptata : \n");
902 scanf("%s", nume_img_dest);
903
904 criptare(imagine_permutata, aleatoare, secret_key);
905 creare_img(imagine_permutata, nume_img_sursa, nume_img_dest);
906 printf("TESTUL CHI DUPA CRIPTARE :\n\n");
907 testul_chi_patrat(imagine_permutata);
908
909 /// DECRIPTARE ///
910
911 printf("\nCum sa se numeasca imaginea decriptata : \n");
912 scanf("%s", nume_img_decriptata);
913 BMP_image *imagine_partial_decriptata = decriptare(imagine_permutata, aleatoare, secret_key);
914 printf("\nSe creeaza imaginea decriptata...\n");
915 creare_img(imagine_partial_decriptata, nume_img_sursa, nume_img_decriptata);
916 printf("\nImaginea decriptata a fost creata\n");
917 /// DEZALOCARE DE MEMORIE ///
918
919 free(imagine_permutata->vector_valori);
920 free(imagine_permutata);
921 free(imagine_sursa->vector_valori);
922 free(imagine_sursa);
923 free(aleatoare);
924#endif
925 // ---PARTEA A 2 A--- //
926
927#if 1
928 char *imagine_sursa_1 = (char*)malloc(100 * sizeof(char));
929 char *nume_img_finala = (char*)malloc(100 * sizeof(char));
930
931 char **vector_sabloane;
932 BMP_matrice *img_matrice;
933
934 vector_sabloane = (char**)malloc(10 * sizeof(char*));
935 for (int i = 0; i < 10; i++)
936 vector_sabloane[i] = (char*)malloc(10 * sizeof(char));
937 printf("Cum se numeste imaginea sursa ? : ");
938 scanf("%s", imagine_sursa_1);
939 grayscale_image(imagine_sursa_1, "test_grayscaled.bmp");
940
941 /// ////////////////////////////////
942
943 grayscale_image("cifra0.bmp", "cifra0_gs.bmp");
944 grayscale_image("cifra1.bmp", "cifra1_gs.bmp");
945 grayscale_image("cifra2.bmp", "cifra2_gs.bmp");
946 grayscale_image("cifra3.bmp", "cifra3_gs.bmp");
947 grayscale_image("cifra4.bmp", "cifra4_gs.bmp");
948 grayscale_image("cifra5.bmp", "cifra5_gs.bmp");
949 grayscale_image("cifra6.bmp", "cifra6_gs.bmp");
950 grayscale_image("cifra7.bmp", "cifra7_gs.bmp");
951 grayscale_image("cifra8.bmp", "cifra8_gs.bmp");
952 grayscale_image("cifra9.bmp", "cifra9_gs.bmp");
953
954 vector_sabloane[0] = "cifra0_gs.bmp";
955 vector_sabloane[1] = "cifra1_gs.bmp";
956 vector_sabloane[2] = "cifra2_gs.bmp";
957 vector_sabloane[3] = "cifra3_gs.bmp";
958 vector_sabloane[4] = "cifra4_gs.bmp";
959 vector_sabloane[5] = "cifra5_gs.bmp";
960 vector_sabloane[6] = "cifra6_gs.bmp";
961 vector_sabloane[7] = "cifra7_gs.bmp";
962 vector_sabloane[8] = "cifra8_gs.bmp";
963 vector_sabloane[9] = "cifra9_gs.bmp";
964
965 /// ////////////////////////////////
966
967 detectie *detectii = NULL;
968 float prag;
969 printf("Pragul dorit? : ");
970 scanf("%f", &prag);
971 int size_detectii = 0;
972
973 img_matrice = matching_si_corelatie("test_grayscaled.bmp", vector_sabloane, prag, &detectii, &size_detectii, imagine_sursa_1);
974 printf("Cum sa se numeasca imaginea finala? : ");
975 scanf("%s", nume_img_finala);
976 printf("\n");
977
978 afisare_matrice(img_matrice, imagine_sursa_1, nume_img_finala);
979
980 sorteaza(detectii, size_detectii);
981 /// DEZALOCARE MEMORIE ///
982
983#endif
984 system("pause");
985}
986#endif
987#endif