API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 9th, 2016
59
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.14 KB | None | 0 0
raw download clone embed print report
  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <math.h>
  6. #include <time.h>
  7.  
  8.  
  9. struct IMAGE
  10. {
  11.     int height;
  12.     int width;
  13.     int max;
  14.     int **data;
  15. };
  16. int SOBEL_POZIOMY[9] = {
  17.     1,  2,  1,
  18.     0,  0,  0,
  19.     -1, -2, -1
  20. };
  21. int GAUSS1[9] = {
  22.     1, 2, 1,
  23.     2, 4, 2,
  24.     1, 2, 1
  25. };
  26. struct IMAGE* newIMAGE(int height, int width, int max);
  27. struct IMAGE* loadIMAGE(char *name);
  28. void saveIMAGE(struct IMAGE *img);
  29. void skipCOMMENT(FILE *fp);
  30. void freeIMAGE(struct IMAGE **img);
  31. void odbicie_poziom(struct IMAGE *img);
  32. void odbicie_pion(struct IMAGE * img);
  33. void progowanie(struct IMAGE *img);
  34. void erozja(struct IMAGE * img);
  35. void histogram(struct IMAGE *img);
  36. void filtr(struct IMAGE * img, int * fil, int size);
  37.  
  38. int main()
  39. {
  40.     int numer;
  41.     int exit = 0;
  42.     struct IMAGE *img = NULL;
  43.     char name[50];
  44.     while (!exit)
  45.     {
  46.         printf("Menu:\n");
  47.         printf("1:wczytaj obraz\n");
  48.         printf("2:zapisz obraz\n");
  49.         printf("3:wykonaj erozje (UWAGA: opcja dostepna tylko dla obrazow binarnych)\n");
  50.         printf("4:odbij w poziomie\n");
  51.         printf("5:odbij w pionie\n");
  52.         printf("6:progowanie\n");
  53.         printf("7:utworz histogram\n");
  54.         printf("8:zastosuj filtr Gaussa\n");
  55.         printf("9:zastosuj filtr Sobela\n");
  56.         printf("10:zakoncz program\n");
  57.         scanf("%d", &numer);
  58.         switch (numer)
  59.         {
  60.         case 1:
  61.             printf("Podaj nazwe pliku z dopiskiem '.pgm'\n");
  62.             scanf("%s", name);
  63.             img = loadIMAGE(name);
  64.             if (img == NULL)
  65.             {
  66.                 printf("nie ma takiego pliku");
  67.                 return 0;
  68.             }
  69.             break;
  70.         case 2:
  71.             saveIMAGE(img);
  72.             break;
  73.         case 3:
  74.             erozja(img);
  75.             break;
  76.         case 4:
  77.             odbicie_poziom(img);
  78.             break;
  79.         case 5:
  80.             odbicie_pion(img);
  81.             break;
  82.         case 6:
  83.             progowanie(img);
  84.             break;
  85.         case 7:
  86.             histogram(img);
  87.             break;
  88.         case 8:
  89.             filtr(img, SOBEL_POZIOMY, sizeof(SOBEL_POZIOMY));
  90.             break;
  91.         case 9:
  92.             filtr(img, GAUSS1, sizeof(GAUSS1));
  93.             break;
  94.         case 10:
  95.             exit = 1;
  96.             printf("KONIEC\n");
  97.             freeIMAGE(&img);
  98.             return 0;
  99.             break;
  100.         default:
  101.             printf("zly numer\n");
  102.             break;
  103.         }
  104.     }
  105.     return 0;
  106. }
  107.  
  108. struct IMAGE* newIMAGE(int width, int height, int max)
  109. {
  110.     int i;
  111.     struct IMAGE* img = NULL;
  112.     img = (struct IMAGE *) malloc(sizeof(struct IMAGE));
  113.     if (img == NULL)
  114.     {
  115.         printf("blad w alokacji pamieci");
  116.         return NULL;
  117.     }
  118.     img->height = height;
  119.     img->width = width;
  120.     img->max = max;
  121.     img->data = (int**)calloc(height, sizeof(int*));
  122.     if (img->data == NULL)
  123.     {
  124.         printf("blad w alokacji pamieci");
  125.         free(img);
  126.         return NULL;
  127.     }
  128.     for (i = 0; i < height; i++)
  129.     {
  130.         img->data[i] = (int*)calloc(width, sizeof(int));
  131.         if (img->data == NULL)
  132.         {
  133.             printf("blad w alokacji pamieci");
  134.             freeIMAGE(&img);
  135.             return NULL;
  136.         }
  137.     }
  138.     return img;
  139. }
  140.  
  141.  
  142. void freeIMAGE(struct IMAGE **img)
  143. {
  144.     int i;
  145.     if (*img == NULL) return;
  146.     if ((*img)->data != NULL)
  147.     {
  148.         for (i = 0; i < (*img)->height; i++)
  149.         {
  150.             if ((*img)->data[i] != NULL) free((*img)->data[i]);
  151.         }
  152.         //free(*img);
  153.         //*img = NULL;
  154.     }
  155.     else return;
  156.     free((*img)->data);
  157.     free(*img);
  158.     *img = NULL;
  159. }
  160.  
  161. void saveIMAGE(struct IMAGE* img)
  162. {
  163.     int i, j;
  164.     char name[30];
  165.     FILE *fp;
  166.     if (img == NULL)
  167.     {
  168.         printf("Nie wczytales obrazu");
  169.         return;
  170.     }
  171.     printf("Podaj nazwe pliku z dopiskiem '.PGM':\n");
  172.     scanf("%s", name);
  173.     fp = fopen(name, "wt");
  174.     if (fp == NULL)
  175.     {
  176.         printf("blad w utowrzeniu pliku\n");
  177.         return;
  178.     }
  179.     fprintf(fp, "P2\n%d %d\n%d\n", img->width, img->height, img->max);
  180.     for (i = 0; i < img->height; i++)
  181.     {
  182.         for (j = 0; j < img->width; j++)
  183.         {
  184.             fprintf(fp, "%d ", img->data[i][j]);
  185.         }
  186.         fprintf(fp, "\n");
  187.     }
  188.     fclose(fp);
  189. }
  190.  
  191. struct IMAGE* loadIMAGE(char *name)
  192. {
  193.     FILE *fp;
  194.     char buf[3];
  195.     int w, h, max, i, j, value;
  196.     struct IMAGE* img;
  197.     fp = fopen(name, "rt");
  198.     if (fp == NULL) return NULL;
  199.     fscanf(fp, "%2s", buf);
  200.     if (buf[0] != 'P' || (buf[1] != '2' && buf[1] != '5'))
  201.     {
  202.         printf("typ pliku rozny od .pgm");
  203.         fclose(fp);
  204.         return NULL;
  205.     }
  206.     skipCOMMENT(fp);
  207.     if (fscanf(fp, "%d%d%d", &w, &h, &max) != 3)
  208.     {
  209.         printf("typ pliku rozny od .pgm");
  210.         fclose(fp);
  211.         return NULL;
  212.     }
  213.     img = newIMAGE(w, h, max);
  214.     if (img == NULL)
  215.     {
  216.         printf("blad w tworzeniu pamieci dla obrazka");
  217.         fclose(fp);
  218.         return NULL;
  219.     }
  220.     for (i = 0; i < img->height; i++)
  221.     {
  222.         for (j = 0; j < img->width; j++)
  223.         {
  224.             if (fscanf(fp, "%d", &value) != 1)
  225.             {
  226.                 freeIMAGE(&img);
  227.                 fclose(fp);
  228.                 return NULL;
  229.             }
  230.             img->data[i][j] = value;
  231.         }
  232.     }
  233.     fclose(fp);
  234.     return img;
  235. }
  236.  
  237. void skipCOMMENT(FILE *fp)
  238. {
  239.     int ch;
  240.     while (1)
  241.     {
  242.         do
  243.         {
  244.             ch = fgetc(fp);
  245.         } while (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t');
  246.  
  247.         if (ch == '#')
  248.         {
  249.             do
  250.             {
  251.                 ch = fgetc(fp);
  252.             } while (ch != '\r' && ch != '\n' && ch >= 0);
  253.         }
  254.         else
  255.         {
  256.             ungetc(ch, fp);//zwraca wczytany znak do pliku
  257.             return;
  258.         }
  259.     }
  260. }
  261. void odbicie_pion(struct IMAGE * img)
  262. {
  263.     int **temp, i, j, k;
  264.     if (img == NULL)
  265.     {
  266.         printf("Nie wczytales obrazu");
  267.         return;
  268.     }
  269.     temp = (int**)calloc(img->height, sizeof(int));
  270.     for (i = 0; i < img->height; i++)
  271.     {
  272.         temp[i] = (int*)calloc(img->width, sizeof(int));
  273.     }
  274.     for (i = 0; i < img->height; i++)
  275.     {
  276.         k = (img->height) - 1 - i;
  277.         for (j = 0; j < img->width; j++)
  278.         {
  279.             temp[i][j] = img->data[k][j];
  280.         }
  281.     }
  282.     for (i = 0; i < img->height; i++)
  283.     {
  284.         for (j = 0; j < img->width; j++)
  285.         {
  286.             img->data[i][j] = temp[i][j];
  287.         }
  288.     }
  289.     for (i = 0; i < img->height; i++)
  290.     {
  291.         free(temp[i]);
  292.     }
  293.     free(temp);
  294. }
  295. void odbicie_poziom(struct IMAGE *img)
  296. {
  297.     int **temp, i, j, k;
  298.     if (img == NULL)
  299.     {
  300.         printf("Nie wczytales obrazu");
  301.         return;
  302.     }
  303.     temp = (int**)calloc(img->height, sizeof(int));
  304.     for (i = 0; i < img->height; i++)
  305.     {
  306.         temp[i] = (int*)calloc(img->width, sizeof(int));
  307.     }
  308.     for (i = 0; i < img->height; i++)
  309.     {
  310.         for (j = 0; j < img->width; j++)
  311.         {
  312.             k = (img->width) - 1 - j;
  313.             temp[i][j] = img->data[i][k];
  314.         }
  315.     }
  316.     for (i = 0; i < img->height; i++)
  317.     {
  318.         for (j = 0; j < img->width; j++)
  319.         {
  320.             img->data[i][j] = temp[i][j];
  321.         }
  322.     }
  323.     for (i = 0; i < img->height; i++)
  324.     {
  325.         free(temp[i]);
  326.     }
  327.     free(temp);
  328.  
  329. }
  330. void progowanie(struct IMAGE *img)
  331. {
  332.     int i, j, prog;
  333.     if (img == NULL)
  334.     {
  335.         printf("Nie wczytales obrazu");
  336.         return;
  337.     }
  338.     prog = img->max / 2;
  339.     for (i = 0; i < img->height; i++)
  340.     {
  341.         for (j = 0; j < img->width; j++)
  342.         {
  343.             if (img->data[i][j] >= prog)
  344.             {
  345.                 img->data[i][j] = img->max;
  346.             }
  347.             else img->data[i][j] = 0;
  348.         }
  349.     }
  350. }
  351.  
  352. void histogram(struct IMAGE *img) {
  353.     FILE * hist;
  354.     int * tab_hist;
  355.     int i, j;
  356.  
  357.     tab_hist = (int*)malloc((img->max + 1) * sizeof(int));
  358.  
  359.     if (tab_hist == NULL) {
  360.         printf("Brak pamieci\n");
  361.         return;
  362.     }
  363.  
  364.     for (i = 0; i < img->max + 1; i++) {
  365.         tab_hist[i] = 0;
  366.     }
  367.  
  368.     hist = fopen("histogram.CSV", "wt");
  369.  
  370.     if (hist == NULL) {
  371.         printf("Nie udalo sie otworzyc pliku do zapisu\n");
  372.         return;
  373.     }
  374.  
  375.     for (i = 0; i < img->height; i++) {
  376.         for (j = 0; j < img->width; j++) {
  377.             tab_hist[img->data[i][j]]++;
  378.         }
  379.     }
  380.  
  381.     for (i = 0; i < img->max + 1; i++) {
  382.         fprintf(hist, "%d;%d\n", i, tab_hist[i]);
  383.     }
  384.  
  385.     free(tab_hist);
  386.     fclose(hist);
  387. }
  388. void erozja(struct IMAGE * img) {
  389.     int i, j, k, m;
  390.     int temp;
  391.     int ** tab2;
  392.     tab2 = (int**)malloc((img->height)*sizeof(int*));
  393.     if (tab2 == NULL) {
  394.         printf("Brak pamieci\n");
  395.         return;
  396.     }
  397.     for (i = 0; i < img->height; i++) {
  398.         tab2[i] = (int*)malloc((img->width)*sizeof(int));
  399.         if (tab2[i] == NULL) {
  400.             printf("Brak pamieci\n");
  401.             for (j = 0; i < img->height; j++)
  402.                 free(tab2[j]);
  403.             free(tab2);
  404.             return;
  405.         }
  406.     }
  407.  
  408.     for (i = 0; i < img->height; i++) {
  409.         for (j = 0; j < img->width; j++) {
  410.             tab2[i][j] = img->data[i][j];
  411.         }
  412.     }
  413.  
  414.     for (i = 0; i < img->height; i++) {
  415.         for (j = 0; j < img->width; j++) {
  416.             temp = 0;
  417.             for (k = 0; k < 3; k++) {
  418.                 for (m = 0; m < 3; m++) {
  419.                     if (i == 0 || j == 0 || i == img->width - 1 || j == img->height - 1) {
  420.                         temp = 0;
  421.                     }
  422.                     else {
  423.                         temp = temp + tab2[i + k - 1][j + m - 1];
  424.                     }
  425.                 }
  426.             }
  427.             if (temp == 9) {
  428.                 img->data[i][j] = 1;
  429.             }
  430.             else
  431.                 img->data[i][j] = 0;
  432.         }
  433.     }
  434.     for (i = 0; i < img->height; i++) {
  435.         free(tab2[i]);
  436.     }
  437.     free(tab2);
  438. }
  439. void filtr(struct IMAGE * img, int * fil, int size) {
  440.     int **tab;
  441.     printf("%d     ", size);
  442.     size = size / sizeof(int);
  443.  
  444.     int suma, suma_wag = 0, i, j, k, m, rozm = (int)sqrt(size);
  445.     int przesun = rozm / 2;
  446.     tab = (int**)malloc(img->height*sizeof(int*));
  447.     for (i = 0; i < img->height; i++)
  448.     {
  449.         tab[i] = (int*)malloc(img->width*sizeof(int));
  450.     }
  451.  
  452.     for (i = 0; i < img->height; i++)
  453.     {
  454.         for (j = 0; j < img->width; j++)
  455.         {
  456.             tab[i][j] = img->data[i][j];
  457.         }
  458.     }
  459.  
  460.     for (i = 0; i < size; i++)
  461.     {
  462.         suma_wag = suma_wag + fil[i];
  463.     }
  464.     for (i = przesun; i < ((img->height) - przesun); i++) {
  465.         for (j = przesun; j < ((img->width) - przesun); j++) {
  466.             suma = 0;
  467.             for (k = 0; k < rozm; k++) {
  468.                 for (m = 0; m < rozm; m++) {
  469.                     suma = suma + fil[k*rozm + m] * (tab[i + k - przesun][j + m - przesun]);
  470.                 }
  471.             }
  472.             if (suma_wag != 0)
  473.                 suma = suma / suma_wag;
  474.             if (suma < 0)
  475.                 suma = 0;
  476.             if (suma > img->max)
  477.                 suma = img->max;
  478.             img->data[i][j] = suma;
  479.         }
  480.     }
  481.     for (i = 0; i < img->height; i++)
  482.         free(tab[i]);
  483.     free(tab);
  484. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!