Facebook
From Mammoth Tapir, 1 Week ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 30
  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. }