rGJkizPj

1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4#include <math.h>
5
6//#define WINDOWS  /* uncomment this line to use it for windows.*/
7#ifndef WINDOWS
8#define abs_path "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/"
9#else
10#define abs_path ""
11#endif
12
13#define u_char_t unsigned char
14#define double_64_t double
15#define u_int32_t unsigned int
16#define int32_t signed int
17#define u_int8_t unsigned char
18
19typedef struct {
20    u_char_t red_color;
21    u_char_t green_color;
22    u_char_t blue_color;
23} u_rgb24_t;
24
25typedef struct {
26    u_int32_t width;
27    u_int32_t height;
28} size;
29
30typedef struct {
31    u_int32_t r;
32    u_int32_t sv;
33} secret_key;
34
35typedef struct {
36    double_64_t treshold;
37    u_int32_t pos_x;
38    u_int32_t pos_y;
39} u_template_matching;
40
41typedef struct {
42    u_template_matching *pointer;
43    u_int32_t size;
44} u_template_correlations;
45
46void                     __load_image(char image_file[255], u_rgb24_t **image, u_char_t* header_info, u_int32_t *width, u_int32_t *height, u_int8_t type);
47//void                   __chi_test(char *image_file, u_char_t *header);
48void                     __outline_drawer(char image_file[], char window[], u_rgb24_t color);
49void                     __get_secret_key(char secret_key_file[255], secret_key *data);
50void                     __encrypt_image(u_rgb24_t **image, secret_key data, u_int32_t *r, u_int32_t width, u_int32_t height);
51void                     __save_image(char image_file[], u_rgb24_t **image, u_char_t header_info[], u_int32_t width, u_int32_t height);
52void                     __decrypt_image(u_rgb24_t **image, secret_key data, u_int32_t *r, u_int32_t width, u_int32_t height);
53u_int32_t                __xorshift32(u_int32_t seed);
54u_template_correlations  __template_matching(u_rgb24_t **image, size image_size, u_rgb24_t **sheet, size sheet_size, double_64_t treshold);
55
56void __load_image(char image_file[255], u_rgb24_t **image, u_char_t *header_info, u_int32_t *width, u_int32_t *height, u_int8_t type) {
57    int32_t counter1 = 0, counter2 = 0, padding = 0;
58    FILE *fp;
59    fp = fopen(image_file, "rb+");
60
61    if (fp == NULL) {
62        printf("\nEroare la deschiderea fisierului aflat la adresa: %s\n", image_file);
63        return;
64    }
65    fseek(fp, 0, SEEK_SET);
66    fread(&(*header_info), 54, 1, fp);
67    fseek(fp, 18, SEEK_SET);
68//    fread(&(*height), sizeof(u_int32_t), 1, fp);
69//    fread(&(*width), sizeof(u_int32_t), 1, fp);
70    *height = *(u_int32_t *) &(header_info)[18];
71    *width = *(u_int32_t *) &(header_info)[22];
72
73    if(*width % 4 != 0)
74        padding = 4 - (3 * (*width)) % 4;
75
76    fseek(fp, 54, SEEK_SET);
77    *image = (u_rgb24_t *) malloc((*height) * (*width) * sizeof(u_rgb24_t));
78
79    if (type == 0) {
80        for (counter1 = (*height) - 1; counter1 >= 0; counter1--) {
81            for (counter2 = 0; counter2 < (*width); counter2++) {
82                fread(&(*image)[counter1 * (*width) + counter2].blue_color, 1, sizeof(u_char_t), fp);
83                fread(&(*image)[counter1 * (*width) + counter2].green_color, 1, sizeof(u_char_t), fp);
84                fread(&(*image)[counter1 * (*width) + counter2].red_color, 1, sizeof(u_char_t), fp);
85            }
86            fseek(fp, padding, SEEK_CUR);
87        }
88    } else {
89        for (counter1 = 0; counter1 < *height; counter1++) {
90            for (counter2 = 0; counter2 < (*width); counter2++) {
91                fread(&(*image)[counter1 * (*width) + counter2].blue_color, 1, sizeof(u_char_t), fp);
92                fread(&(*image)[counter1 * (*width) + counter2].green_color, 1, sizeof(u_char_t), fp);
93                fread(&(*image)[counter1 * (*width) + counter2].red_color, 1, sizeof(u_char_t), fp);
94            }
95            fseek(fp, padding, SEEK_CUR);
96        }
97    }
98
99    fclose(fp);
100}
101
102void __load_image_matrix(char image_file[255], u_rgb24_t ***image, u_char_t *header_info, u_int32_t *width, u_int32_t *height) {
103    u_int32_t counter1, counter2, padding = 0;
104    FILE *fp;
105    fp = fopen(image_file, "rb+");
106
107    if (fp == NULL) {
108        printf("\nEroare la deschiderea fisierului aflat la adresa: %s\n", image_file);
109        return;
110    }
111
112    fseek(fp, 0, SEEK_SET);
113    fread(&(*header_info), 54, 1, fp);
114    fseek(fp, 18, SEEK_SET);
115    *height = *(u_int32_t *) &(header_info)[18];
116    *width = *(u_int32_t *) &(header_info)[22];
117
118    if(*width % 4 != 0)
119        padding = 4 - (3 * (*width)) % 4;
120
121    fseek(fp, 54, SEEK_SET);
122    *image = (u_rgb24_t **) malloc((*height) * sizeof(u_rgb24_t*));
123
124    for (counter1 = 0; counter1 < (*height); counter1++) {
125        (*image)[counter1] = (u_rgb24_t *) malloc((*width) * sizeof(u_rgb24_t));
126        for (counter2 = 0; counter2 < (*width); counter2++) {
127            fread(&(*image)[counter1][counter2].blue_color, 1, sizeof(unsigned char), fp);
128            fread(&(*image)[counter1][counter2].green_color, 1, sizeof(unsigned char), fp);
129            fread(&(*image)[counter1][counter2].red_color, 1, sizeof(unsigned char), fp);
130        }
131        fseek(fp, padding, SEEK_CUR);
132    }
133
134    fclose(fp);
135}
136
137void __get_secret_key(char secret_key_file[255], secret_key *data) {
138    FILE *fp;
139
140    fp = fopen(secret_key_file, "rw");
141
142    if (fp == NULL) {
143        printf("\nEroare la deschiderea fisierului aflat la adresa: %s\n", secret_key_file);
144        return;
145    }
146
147    fscanf(fp, "%d", &(*data).r);
148    fscanf(fp, "%d", &(*data).sv);
149
150}
151
152u_int32_t __xorshift32(u_int32_t seed) {
153    u_int32_t x = seed;
154    x ^= x << 13;
155    x ^= x >> 17;
156    x ^= x << 5;
157    seed = x;
158    return x;
159}
160
161void __encrypt_image(u_rgb24_t **image, secret_key data, u_int32_t *r, u_int32_t width, u_int32_t height) {
162    u_int32_t counter, counter2, number, *permutation = NULL, int_aux;
163    int32_t counter1;
164    u_rgb24_t *aux = NULL;
165
166   permutation = (u_int32_t *) malloc((width * height) * sizeof(u_int32_t));
167   aux = (u_rgb24_t *) malloc((width * height) * sizeof(u_rgb24_t));
168
169    for (counter = 0; counter < width*height; counter++) {
170        permutation[counter] = counter;
171    }
172
173
174    for (counter = width*height - 1; counter >= 1; counter--) {
175        number = r[width*height-counter]%(counter+1);
176        int_aux = permutation[counter];
177        permutation[counter] = permutation[number];
178        permutation[number] = int_aux;
179    }
180
181    for (counter = 0; counter < width*height; counter++) {
182        aux[permutation[counter]] = (*image)[counter];
183    }
184
185    free(permutation);
186
187//    printf("\nafter-perm(R,G,B) = (%d, %d, %d)\n", (*image)[0].red_color, (*image)[0].blue_color, (*image)[0].green_color);
188
189//    printf("%p\n", *image);
190    *image = aux;
191//    printf("%p", *image);
192    u_char_t r_prim, g_prim, b_prim;
193
194    printf("\nperm(R,G,B) = (%d, %d, %d)\n", aux[0].red_color, aux[0].green_color, aux[0].blue_color);
195
196    (*image)[0].red_color = (u_char_t)((data.sv >> 16 & 0xFF)) ^ (*image)[0].red_color ^ (u_char_t)(r[width * height] >> 16 & 0xFF);
197    (*image)[0].green_color = (u_char_t)((data.sv >> 8) & 0xFF) ^ (*image)[0].green_color ^ (u_char_t)(r[width * height + 0] >> 8 & 0xFF);
198    (*image)[0].blue_color = (u_char_t)(data.sv & 0xFF) ^ (*image)[0].blue_color ^ (u_char_t)(r[width * height + 0] & 0xFF);
199
200    r_prim = (*image)[0].red_color;
201    g_prim = (*image)[0].green_color;
202    b_prim = (*image)[0].blue_color;
203
204
205
206    printf("\nsv(R,G,B) = (%d, %d, %d)\n", r_prim, g_prim, b_prim);
207
208
209    for (counter = 1; counter < width * height; counter++) {
210        (*image)[counter].red_color = (u_char_t) (r_prim) ^ (*image)[counter].red_color ^ (u_char_t)(r[width*height + counter] >> 16 & 0xFF);
211        (*image)[counter].green_color = (u_char_t) (g_prim) ^ (*image)[counter].green_color ^ (u_char_t)(r[width*height + counter] >> 8 & 0xFF);
212        (*image)[counter].blue_color = (u_char_t) (b_prim) ^ (*image)[counter].blue_color ^ (u_char_t)(r[width*height + counter] & 0xFF);
213
214        r_prim = (*image)[counter].red_color;
215        g_prim = (*image)[counter].green_color;
216        b_prim = (*image)[counter].blue_color;
217    }
218
219}
220
221void __decrypt_image(u_rgb24_t **image, secret_key data, u_int32_t *r, u_int32_t width, u_int32_t height) {
222    u_int32_t counter, *permutation = NULL, number, int_aux, *reverse_permutation = NULL;
223
224    permutation = (u_int32_t *) malloc((width * height) * sizeof(u_int32_t));
225    reverse_permutation = (u_int32_t *) malloc((width * height) * sizeof(u_int32_t));
226
227    for (counter = 0; counter < width*height; counter++) {
228        permutation[counter] = counter;
229    }
230
231    for (counter = width*height - 1; counter >= 1; counter--) {
232        number = r[width*height-counter]%(counter+1);
233        int_aux = permutation[counter];
234        permutation[counter] = permutation[number];
235        permutation[number] = int_aux;
236    }
237
238    for (counter = 0; counter < width*height; counter++) {
239        reverse_permutation[permutation[counter]] = counter;
240    }
241
242    u_char_t r_prim, g_prim, b_prim;
243    u_char_t r_sec, g_sec, b_sec;
244    u_rgb24_t *aux = NULL;
245
246    aux = (u_rgb24_t *) malloc((width * height) * sizeof(u_rgb24_t));
247
248    r_sec = (*image)[0].red_color;
249    g_sec = (*image)[0].green_color;
250    b_sec = (*image)[0].blue_color;
251
252    (*image)[0].red_color = (u_char_t)((data.sv >> 16 & 0xFF)) ^ (*image)[0].red_color ^ (u_char_t)(r[width * height] >> 16 & 0xFF);
253    (*image)[0].green_color = (u_char_t)((data.sv >> 8) & 0xFF) ^ (*image)[0].green_color ^ (u_char_t)(r[width * height + 0] >> 8 & 0xFF);
254    (*image)[0].blue_color = (u_char_t)(data.sv & 0xFF) ^ (*image)[0].blue_color ^ (u_char_t)(r[width * height + 0] & 0xFF);
255
256    r_prim = r_sec;
257    g_prim = g_sec;
258    b_prim = b_sec;
259
260
261
262    printf("\nsv(R,G,B) = (%d, %d, %d)\n", r_prim, g_prim, b_prim);
263
264
265    for (counter = 1; counter < width * height; counter++) {
266        r_sec = (*image)[counter].red_color;
267        g_sec = (*image)[counter].green_color;
268        b_sec = (*image)[counter].blue_color;
269
270        (*image)[counter].red_color = (u_char_t) (r_prim) ^ (*image)[counter].red_color ^ (u_char_t)(r[width*height + counter] >> 16 & 0xFF);
271        (*image)[counter].green_color = (u_char_t) (g_prim) ^ (*image)[counter].green_color ^ (u_char_t)(r[width*height + counter] >> 8 & 0xFF);
272        (*image)[counter].blue_color = (u_char_t) (b_prim) ^ (*image)[counter].blue_color ^ (u_char_t)(r[width*height + counter] & 0xFF);
273
274        r_prim = r_sec;
275        g_prim = g_sec;
276        b_prim = b_sec;
277    }
278
279    for (counter = 0; counter < width*height; counter++) {
280        aux[reverse_permutation[counter]] = (*image)[counter];
281    }
282
283    *image = aux;
284
285    free(permutation);
286    free(reverse_permutation);
287}
288
289void __save_image(char image_file[], u_rgb24_t **image, u_char_t *header_info, u_int32_t width, u_int32_t height) {
290    int32_t counter1, counter2, padding = 0;
291    FILE *fp;
292
293    fp = fopen(image_file, "wb+");
294    if (fp == NULL) {
295        printf("\nEroare la deschiderea fisierului aflat la adresa: %s\n", image_file);
296        return;
297    }
298
299    fwrite(header_info, 54, 1, fp);
300    fflush(fp);
301
302    if(width % 4 != 0)
303        padding = 4 - (3 * (width)) % 4;
304
305    for (counter1 = (height) - 1; counter1 >= 0; counter1--) {
306        for (counter2 = 0; counter2 < (width); counter2++) {
307            fwrite(&(*image)[counter1 * (width) + counter2].blue_color, 1, sizeof(u_char_t), fp); fflush(fp);
308            fwrite(&(*image)[counter1 * (width) + counter2].green_color, 1, sizeof(u_char_t), fp); fflush(fp);
309            fwrite(&(*image)[counter1 * (width) + counter2].red_color, 1, sizeof(u_char_t), fp); fflush(fp);
310        }
311        for (counter2 = 0; counter2 < padding; counter2++) {
312            fwrite(0, 1, sizeof(u_char_t), fp);
313            fflush(fp);
314        }
315    }
316
317    fclose(fp);
318
319}
320
321void __save_image_matrix(char image_file[], u_rgb24_t ***image, u_char_t *header_info, u_int32_t width, u_int32_t height) {
322    u_int32_t counter1, counter2, padding = 0;
323    FILE *fp;
324
325    fp = fopen(image_file, "wb+");
326
327    if (fp == NULL) {
328        printf("\nEroare la deschiderea fisierului aflat la adresa: %s\n", image_file);
329        return;
330    }
331
332    fwrite(header_info, 54, 1, fp);
333    fflush(fp);
334
335    if (width % 4 != 0)
336        padding = 4 - (3*(width)) % 4;
337
338    for (counter1 = 0; counter1 < height; counter1++) {
339        for (counter2 = 0; counter2 < width; counter2++) {
340            fwrite(&(*image)[counter1][counter2].blue_color, 1, sizeof(u_char_t), fp); fflush(fp);
341            fwrite(&(*image)[counter1][counter2].green_color, 1, sizeof(u_char_t), fp); fflush(fp);
342            fwrite(&(*image)[counter1][counter2].red_color, 1, sizeof(u_char_t), fp); fflush(fp);
343        }
344        for (counter2 = 0; counter2 < padding; counter2++) {
345            fwrite(0, 1, sizeof(u_char_t), fp);
346            fflush(fp);
347        }
348    }
349}
350
351void __chi_test(char *image_file, u_int32_t width, u_int32_t height, u_rgb24_t *image) {
352    double_64_t th_frequency;
353    width = width + (4 - (width%4))%4;
354    th_frequency = (double_64_t) (width * height) / 256;
355    double_64_t *chi = (double_64_t *) calloc(3, sizeof(double_64_t));
356    u_int32_t *red = (u_int32_t *) calloc(256, sizeof(u_int32_t));
357    u_int32_t *green = (u_int32_t *) calloc(256, sizeof(u_int32_t));
358    u_int32_t *blue = (u_int32_t *) calloc(256, sizeof(u_int32_t));
359    u_int32_t counter;
360
361    for (counter = 0; counter < width*height; counter++) {
362        red[image[counter].red_color]++;
363        green[image[counter].green_color]++;
364        blue[image[counter].blue_color]++;
365    }
366
367    for (counter = 0; counter < 256; counter++) {
368        chi[0] = chi[0] + ((red[counter] - th_frequency) * (red[counter] - th_frequency))/th_frequency;
369        chi[1] = chi[1] + ((green[counter] - th_frequency) * (green[counter] - th_frequency))/th_frequency;
370        chi[2] = chi[2] + ((blue[counter] - th_frequency) * (blue[counter] - th_frequency))/th_frequency;
371    }
372
373    printf("RED: %.2f, GREEN: %.2f, BLUE: %.2f\n", chi[0], chi[1], chi[2]);
374
375}
376
377double_64_t intensity(u_rgb24_t **image, u_int32_t position_y, u_int32_t position_x) {
378    return image[position_y][position_x].red_color;
379}
380
381double_64_t average_intensity(u_rgb24_t **image, u_int32_t position_y, u_int32_t position_x, size sheet_size, u_int32_t sheet_pixels) {
382    u_int32_t counter1, counter2;
383    double_64_t average = 0;
384
385    for (counter1 = position_y; counter1 < position_y + sheet_size.height; counter1++) {
386        for (counter2 = position_x; counter2 < position_x + sheet_size.width; counter2++) {
387            average += intensity(image, counter1, counter2);
388        }
389    }
390
391    return (average/sheet_pixels);
392}
393
394double_64_t deviation(u_rgb24_t **image, u_int32_t position_y, u_int32_t position_x, size sheet_size, u_int32_t sheet_pixels) {
395    u_int32_t counter1, counter2;
396    double_64_t deviation_sum = 0;
397
398    for (counter1 = position_y; counter1 < position_y + sheet_size.height; counter1++) {
399        for (counter2 = position_x; counter2 < position_x + sheet_size.width; counter2++) {
400            deviation_sum += ((intensity(image, counter1, counter2) - average_intensity(image, position_y, position_x, sheet_size, sheet_pixels)) * (intensity(image, counter1, counter2) - average_intensity(image, position_y, position_x, sheet_size, sheet_pixels)));
401        }
402    }
403
404    return (sqrt(deviation_sum/(sheet_pixels - 1)));
405}
406
407u_template_correlations __template_matching_2(u_rgb24_t **image, size image_size, u_rgb24_t **sheet, size sheet_size, double_64_t treshold) {
408    u_template_correlations data;
409    u_int32_t sheet_pixels, counter1, counter2, counter3, counter4, counter5 = 0;
410
411    sheet_pixels = sheet_size.width * sheet_size.height;
412
413    double_64_t sheet_average_intensity = average_intensity(sheet, 0, 0, sheet_size, sheet_pixels);
414    double_64_t sheet_deviation = deviation(sheet, 0, 0, sheet_size, sheet_pixels);
415
416    double_64_t sum;
417    double_64_t image_average_intensity;
418    double_64_t image_deviation;
419
420    for (counter1 = 0; counter1 < image_size.height - sheet_size.height; counter1++) {
421        for (counter2 = 0; counter2 < image_size.width - sheet_size.width; counter2++) {
422            sum = 0;
423            image_average_intensity = average_intensity(image, counter1, counter2, sheet_size, sheet_pixels);
424            image_deviation = deviation(image, counter1, counter2, sheet_size, sheet_pixels);
425
426            for (counter3 = 0; counter3 < sheet_size.height; counter3++) {
427                for (counter4 = 0; counter4 < sheet_size.width; counter4++) {
428                    sum += ((intensity(image, counter1+counter3, counter2+counter4) - image_average_intensity) * (intensity(sheet, counter3, counter4) - sheet_average_intensity) / (image_deviation * sheet_deviation));
429                }
430            }
431
432            sum /= sheet_pixels;
433//            printf("%.2f\n", sum);
434            if (sum >= treshold) {
435                printf("%.2f\n", sum);
436            }
437        }
438    }
439    return data;
440}
441
442//double_64_t average_grayscale_pixels_intensity(u_rgb24_t **image, u_int32_t pos_x, u_int32_t pos_y, size sheet_size, size image_size) {
443//    double_64_t average = 0;
444//    u_int32_t counter1, counter2, k=0;
445//
446//    for (counter1 = 0; counter1 < sheet_size.height; counter1++) {
447//        for (counter2 = 0; counter2 < sheet_size.width; counter2++) {
448////            printf("%d\n", (*image)[pos_y*image_size.width + pos_x + counter1*image_size.width + counter2].red_color);
449//            average += (*image)[pos_y*image_size.width + pos_x + counter1*image_size.width + counter2].red_color;
450//        }
451//    }
452//    average /= (sheet_size.width * sheet_size.height);
453////    printf("\n%d - %d\n", sheet_size.width, sheet_size.height);
454//    return average;
455//}
456//
457//double_64_t pixel_deviation(u_rgb24_t **image, u_int32_t pos_x, u_int32_t pos_y, size sheet_size, size image_size) {
458//    double_64_t deviation = 0, average;
459//    u_int32_t counter1, counter2;
460//
461//    average = average_grayscale_pixels_intensity(image, pos_x, pos_y, sheet_size, image_size);
462//    for (counter1 = 0; counter1 < sheet_size.height; counter1++) {
463//        for (counter2 = 0; counter2 < sheet_size.width; counter2++) {
464//            deviation += ((*image)[pos_y*image_size.width + pos_x + counter1*image_size.width + counter2].red_color - average) * ((*image)[pos_y*image_size.width + pos_x + counter1*image_size.width + counter2].red_color - average);
465//        }
466//    }
467//    deviation /= (sheet_size.width * sheet_size.height - 1);
468//    deviation = sqrt(deviation);
469//    return deviation;
470//}
471//
472//u_template_correlations __template_matching(u_rgb24_t **image, size image_size, u_rgb24_t **sheet, size sheet_size, double_64_t treshold) {
473//    u_int32_t counter1, counter2, counter3, counter4, is_realloc = 0, counter5 = 0;
474//    u_template_matching *correlations = NULL;
475//    u_template_correlations data;
476//    correlations = (u_template_matching *) malloc(sizeof(u_template_matching));
477//    data.pointer = correlations;
478//
479//    double_64_t sheet_pixel_deviation = pixel_deviation(sheet, 0, 0, sheet_size, sheet_size);
480//    //The average of grayscale pixels intensity of the sheet
481//    double_64_t sheet_pixels_intensity = average_grayscale_pixels_intensity(sheet, 0, 0, sheet_size, sheet_size);
482////    printf("Average intensity: %f\n", sheet_pixels_intensity);
483////    printf("Standard pixel deviation: %f", sheet_pixel_deviation);
484//    double_64_t sum, image_pixels_intensity, image_pixel_deviation;
485////    return data;
486//    //s(i, j) - s|
487//    for (counter1 = 0; counter1 < image_size.height - sheet_size.height; counter1++) {
488//        for (counter2 = 0; counter2 < image_size.width - sheet_size.width; counter2++) {
489//            sum = 0;
490//            image_pixels_intensity = average_grayscale_pixels_intensity(image, counter2, counter1, sheet_size, image_size);
491//            image_pixel_deviation = pixel_deviation(image, counter2, counter1, sheet_size, image_size);
492//            for (counter3 = 0; counter3 < sheet_size.height; counter3++) {
493//                for (counter4 = 0; counter4 < sheet_size.width; counter4++) {
494//                    sum+= (((*image)[counter1 * image_size.width + counter2 + counter3 * image_size.width + counter4].red_color - image_pixels_intensity) * ((*sheet)[counter3*sheet_size.width + counter4].red_color - sheet_pixels_intensity))/(image_pixel_deviation * sheet_pixel_deviation);
495//                }
496//            }
497////            sum /= (image_pixel_deviation * sheet_pixel_deviation);
498//            sum /= (sheet_size.width * sheet_size.height);
499//            printf("%.2f\n", sum);
500//            if (sum >= treshold) {
501//                if (is_realloc == 0) {
502//                    correlations[counter5].treshold = sum;
503//                    correlations[counter5].pos_x = counter2;
504//                    correlations[counter5].pos_y = counter1;
505//                    is_realloc = 1;
506//                } else {
507//                    correlations = realloc(correlations, (counter5+1) * sizeof(u_template_matching));
508//                    correlations[counter5].treshold = sum;
509//                    correlations[counter5].pos_x = counter2;
510//                    correlations[counter5].pos_y = counter1;
511//                }
512//                counter5++;
513//            }
514//        }
515//    }
516//    data.size = counter5;
517//
518//    return data;
519//};
520    char image_file[] = "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/date/criptografie/peppers.bmp";
521
522int main() {
523    char secret_key_file[] = "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/date/criptografie/secret_key.txt"
524//    char image_file[] = "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/date/criptografie/encrypted/peppers_encrypted.bmp";
525    char encrypted_image_file[] = "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/date/criptografie/encrypted/peppers_decrypted.bmp";
526    char grayscale_image[] = "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/date/recunoasterePatternuri/test_grayscale.bmp";
527
528    char grayscale_image_saved[] = "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/date/recunoasterePatternuri/test_grayscale_saved.bmp";
529    char grayscale_sheet[] = "/Users/zamfi/Desktop/Proiect Programare Procedurala - 4 Ianuarie 2019 - Zamfira Costin-Andrei - Grupa 131/date/recunoasterePatternuri/cifra0_grayscale.bmp";
530    u_char_t header_info[54], header_info_sheet[54];
531
532    u_int32_t *r = NULL;
533    u_rgb24_t *image = NULL;
534    u_rgb24_t *sheet = NULL;
535    secret_key data;
536
537    u_int32_t width = 0, height = 0, counter;
538    u_int32_t width_sheet = 0, height_sheet = 0;
539
540    u_template_correlations corr_array;
541
542    size image_size;
543    size sheet_size;
544
545//    __load_image(encrypted_image_file, &image, header_info, &width, &height);
546
547//    __chi_test(image_file, width, height, image);
548//    __load_image(image_file, &image, header_info, &width, &height, 0);
549//    __get_secret_key(secret_key_file, &data);
550//    __chi_test(image_file, width, height, image);
551
552//    r = (u_int32_t *) malloc((2*width*height)*sizeof(u_int32_t));
553//    r[0] = data.r;
554//    for (counter = 1; counter < (2*width*height); counter++) {
555//        r[counter] = __xorshift32(r[counter-1]);
556//    }
557
558    u_rgb24_t **image_matrix;
559    u_rgb24_t **sheet_matrix;
560
561    __load_image_matrix(grayscale_image, &image_matrix, header_info, &width, &height);
562    __load_image_matrix(grayscale_sheet, &sheet_matrix, header_info_sheet, &width_sheet, &height_sheet);
563
564//    __save_image_matrix(grayscale_image_saved, &image_matrix, header_info, width, height);
565
566    image_size.width = width;
567    image_size.height = height;
568    sheet_size.width = width_sheet;
569    sheet_size.height = height_sheet;
570
571    corr_array = __template_matching_2(image_matrix, image_size, sheet_matrix, sheet_size, 0.5);
572//
573    printf("\nCorrelations: %u\n", corr_array.size);
574    free(image);
575    free(sheet);
576
577//    __encrypt_image(&image, data, r, width, height);
578//
579//    __save_image(encrypted_image_file, &image, header_info, width, height);
580//
581//    __decrypt_image(&image, data, r, width, height);
582//
583//    __save_image(encrypted_image_file, &image, header_info, width, height);
584    return 0;
585}