1. #include <stdio.h>
2. #include <mpi.h>
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <time.h>
6. #include <stdint.h>
7. #define STB_IMAGE_IMPLEMENTATION
8. #include "stb_image.h"
9. #define STB_IMAGE_WRITE_IMPLEMENTATION
10. #include "stb_image_write.h"
11.  
12. #define MASTER 0
13.  
14. int min = -2, max = 3;
15.  
16. typedef struct {
17.     int blue;
18.     int green;
19.     int czerw;
20. }Pixel;
21.  
22. int main(int argc, char** argv) {
23.     /***** NASZ KOD*****/
24.     int numtasks, taskid;
25.     int source;
26.     MPI_Init(&argc, &argv);
27.     MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
28.     MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
29.     MPI_Status status;
30.     printf("MPI task %d has started...  ", taskid);
31.  
32.     int width, height, channels;
33.     unsigned char* img = stbi_load("aa.jpg", &width, &height, &channels, 0);
34.  
35.     int blur_channels = channels == 4 ? 2 : 1;
36.     int licznik = 0;
37.     size_t img_size = width * channels * height;
38.  
39.     int h = height / 3;
40.  
41.     Pixel* piksele = malloc(sizeof(Pixel) * width * height);
42.  
43.     //Pixel* tab1 = malloc(sizeof(Pixel) * width * h);
44.     //Pixel* tab2 = malloc(sizeof(Pixel) * width * h);
45.     //Pixel* tab3 = malloc(sizeof(Pixel) * width * h);
46.  
47.     int rozmiar = h * width;
48.  
49.     if (taskid == MASTER) {
50.  
51.         for (uint8_t* p = img; p != img + img_size; p += channels) {
52.             piksele[licznik].czerw = (uint8_t)(*p);
53.             piksele[licznik].green = (uint8_t)(*(p + 1));
54.             piksele[licznik].blue = (uint8_t)(*(p + 2));
55.             licznik++;
56.         }
57.         int tmp = 0;
58.         //for (int i = 0; i < h; i++) {
59.         //    for (int j = 0; j < width; j++) {
60.         //        tab1[i * width + j] = piksele[i * width + j];
61.         //        tab2[i * width + j] = piksele[(i + h) * width + j];
62.         //        tab3[i * width + j] = piksele[(i + 2 * h) * width + j];
63.  
64.         //        tmp++;
65.         //    }
66.         //}
67.  
68.         //MPI_Send(&rozmiar, 1, MPI_INT, 1, 0, MPI_COMM_WORLD);
69.         //MPI_Send(&piksele[rozmiar], h, MPI_CHAR, 1, 0, MPI_COMM_WORLD);
70.  
71.         for (int i = 1; i < 4; i++) {
72.             MPI_Send(&rozmiar, 1, MPI_INT, i, 1, MPI_COMM_WORLD);
73.             MPI_Send(&piksele[rozmiar], h*width, MPI_INT, i, 1, MPI_COMM_WORLD);
74.             rozmiar = rozmiar + h;
75.         }
76.  
77.  
78.         for (int i = 1; i < 4; i++) {
79.             source = i;
80.             MPI_Recv(&rozmiar, 1, MPI_INT, source, 1, MPI_COMM_WORLD, &status);
81.             MPI_Recv(&piksele[rozmiar], h*width, MPI_INT, source, 1, MPI_COMM_WORLD, &status);
82.         }
83.     }
84.  
85.     if (taskid > MASTER) {
86.         MPI_Recv(&rozmiar, 1, MPI_INT, MASTER, 0, MPI_COMM_WORLD, &status);
87.         MPI_Recv(&piksele[rozmiar], h, MPI_CHAR, MASTER, 0, MPI_COMM_WORLD, &status);
88.         for (int i = 0; i < h; i++) {
89.             for (int j = 0; j < width; j++) {
90.                 piksele[i * width + j].blue = 100;
91.                 piksele[i * width + j].green = 150;
92.                 piksele[i * width + j].czerw = 200;
93.             }
94.         }
95.         MPI_Send(&rozmiar, 1, MPI_INT, MASTER, 0, MPI_COMM_WORLD);
96.         MPI_Send(&piksele[rozmiar], h, MPI_CHAR, MASTER, 0, MPI_COMM_WORLD);
97.     }
98.  
99.     MPI_Finalize();
100.     ///////////////////////////////////////////////////////////
101.     /////////////////////
102.     /*
103.     int width, height, channels;
104.     unsigned char *img = stbi_load("potezny.jpg", &width, &height, &channels, 0);
105.     if (img == NULL) {
106.         printf("Error in loading the image\n");
107.         exit(1);
108.     }
109.     printf("Loaded image with a width of %dpx, a height of %dpx and %d channels\n", width, height, channels);
110.  
111.     int blur_channels = channels == 4 ? 2 : 1;
112.     int licznik = 0;
113.     size_t img_size = width * channels * height;
114.  
115.     Pixel* piksele = malloc(sizeof(Pixel) * width * height);
116.     Pixel* blur = malloc(sizeof(Pixel) * width * height);
117.  
118.     //Ta pentla daje kolorki do tablicy piksele gdzie wygodnie da sie ich uzywac
119.  
120.     for (unsigned char* p = img; p != img + img_size; p += channels) {
121.         piksele[licznik].czerw = (uint8_t)(*p);
122.         piksele[licznik].green = (uint8_t)(*(p + 1));
123.         piksele[licznik].blue = (uint8_t)(*(p + 2));
124.         licznik++;
125.     }
126.     int rank, n_ranks;
127.  
128.     int srednia_czerw = 0, srednia_g = 0, srednia_b = 0;
129.     int ile_r = 0;
130.     int ile_g = 0;
131.     int ile_b = 0;
132.  
133.     // First call MPI_Init
134.  
135.     MPI_Init(&argc, &argv);
136.     // Check that there are two ranks
137.     MPI_Comm_size(MPI_COMM_WORLD, &n_ranks);
138.     if (n_ranks != 3) {
139.         printf("This example requires exactly three ranks\n");
140.         MPI_Finalize();
141.         return(1);
142.     }
143.  
144.  
145.  
146.     // Get my rank
147.     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
148.  
149.     double start = MPI_Wtime();
150.  
151.     if (rank == 0) {
152.         for (int y = 0; y < height; y++){
153.             for (int x = 0; x < width; x++){
154.                 for (int i = min; i < max; i++){ // przesuwanie w poziomie
155.                     for (int j = min; j < max; j++){ // przesuwanie w pionie
156.                         if ((y + i < height && y + i >= 0) && (x + j < width && x + j >= 0)){
157.                             srednia_czerw += piksele[(y + i) * width + x + j].czerw;
158.                             ile_r++;
159.                         }
160.                     }
161.                 }
162.                 blur[y * width + x].czerw = srednia_czerw / ile_r;
163.                 ile_r = 0;
164.                 srednia_czerw = 0;
165.             }
166.         }
167.         //MPI_Send(blur->czerw, 16, MPI_CHAR, 3, 0, MPI_COMM_WORLD);
168.     }
169.  
170.     if (rank == 1) {
171.         for (int y = 0; y < height; y++) {
172.             for (int x = 0; x < width; x++) {
173.  
174.                 for (int i = min; i < max; i++) { // dla y
175.                     for (int j = min; j < max; j++) { // dla x
176.                         if ((y + i < height && y + i >= 0) && (x + j < width && x + j >= 0)) {
177.                             srednia_g += piksele[(y + i) * width + x + j].green;
178.                             ile_g++;
179.                         }
180.                     }
181.                 }
182.                 blur[y * width + x].green = srednia_g / ile_g;
183.                 ile_g = 0;
184.                 srednia_g = 0;
185.             }
186.         }
187.         MPI_Send(blur->green, 16, MPI_CHAR, 3, 0, MPI_COMM_WORLD);
188.     }
189.  
190.     if (rank == 2) {
191.         for (int y = 0; y < height; y++) {
192.             for (int x = 0; x < width; x++) {
193.  
194.                 for (int i = min; i < max; i++) { // dla y
195.                     for (int j = min; j < max; j++) { // dla x
196.                         if ((y + i < height && y + i >= 0) && (x + j < width && x + j >= 0)) {
197.                             srednia_b += piksele[(y + i) * width + x + j].blue;
198.                             ile_b++;
199.                         }
200.                     }
201.                 }
202.                 blur[y * width + x].blue = srednia_b / ile_b;
203.                 ile_b = 0;
204.                 srednia_b = 0;
205.             }
206.         }
207.     }
208.  
209.  
210.  
211.     double end = MPI_Wtime();
212.     MPI_Finalize();
213.  
214.     double czas = end-start;
215.     printf("Blur Zrobiony!\n");
216.     printf("Zadanie trwalo: %f [s]\n\n", czas);
217.  
218.     unsigned char* wynik = malloc(width * height * 3);
219.  
220.     int index = 0;
221.  
222.     for (int j = 0; j < height; j++)
223.     {
224.         for (int i = 0; i < width; i++)
225.         {
226.             wynik[index++] = (unsigned char)blur[j * width + i].czerw;
227.             wynik[index++] = (unsigned char)blur[j * width + i].green;
228.             wynik[index++] = (unsigned char)blur[j * width + i].blue;
229.  
230.         }
231.     }
232.  
233.     stbi_write_jpg("potezny_blur_oddzielnie2.jpg", width, height, 3, wynik, 100);
234.     stbi_image_free(img);
235.     free(piksele);
236.     free(wynik);
237.     free(blur);
238.  
239.     */
240.  
241. }