Facebook
From Obese Baboon, 2 Years ago, written in C.
Embed
Download Paste or View Raw
Hits: 202
  1. #include<stdio.h>
  2. #include<conio.h>
  3. #include<stdlib.h>
  4.  
  5. struct obrazek
  6. {
  7.         char tytul[30];
  8.         char format[2];
  9.         int szerokosc;
  10.         int wysokosc;
  11.         int glebokosc;
  12.         int **dane;
  13. };
  14. void komentarze(FILE *obraz)
  15. {
  16.         char a;
  17.         char kom[120];
  18.         do
  19.     {
  20.                 while (fscanf(obraz, "%c", &a) && (a == 32 || a == 'n' || a == ''));//pomija spacje konce lini
  21.                 if (a == '#')
  22.         {
  23.                         fgets(kom, 120, obraz);
  24.                 }
  25.  
  26.                 else
  27.         {
  28.                         fseek(obraz, -1, SEEK_CUR);//znak zostal juz pobrany do sprawdzenia, a jesli nie jest # to chcemy go pobrac jeszcze raz do zapisu
  29.                 }
  30.         }
  31.         while ((fscanf(obraz, "%c", &a) && (a == 32 || a == 'n' || a == '')));
  32.         fseek(obraz, -1, SEEK_CUR);
  33. }
  34. void alokacja( struct obrazek*tablica, int szer, int wys)
  35. {
  36.         int i = 0;
  37.         int j = 0;
  38.     tablica->dane= realloc(0, wys* sizeof(tablica->dane));
  39.     for (i; i < wys; i++)
  40.     {
  41.                 tablica->dane[i]= realloc(0, szer * sizeof(tablica->dane[i]));
  42.         }
  43. }
  44. void wczytywanieobrazu(struct obrazek* tablica, int rozmiar)
  45. {
  46.         char nazwa[120];
  47.         char nazwa2[200];
  48.         int i = 0;
  49.         int j = 0;
  50.         int n;
  51.         char c;
  52.  
  53.         printf("podaj nazwe obrazu do odczytu n");
  54.         scanf("%s", &tablica->tytul);
  55.         strcpy(nazwa, tablica->tytul);
  56.         strcat(nazwa, ".pgm");
  57.         while ((c = getchar()) != 'n' && c != EOF);
  58.         FILE*obraz;
  59.         obraz = fopen(nazwa, "r");
  60.  
  61.         if ((obraz = fopen(nazwa, "r")) == NULL)
  62.     {
  63.                 printf("blad przy odzycie pliku, podaj nazwe jeszcze raz n");
  64.         }
  65.         fseek(obraz, 0, SEEK_SET);
  66.  
  67.         komentarze( obraz);
  68.         fscanf(obraz, "%c ", &tablica->format[0]); //zapis pierwszego znaku
  69.         komentarze(obraz);
  70.         fscanf(obraz, "%c ", &tablica->format[1]); // zapis drugiego znaku
  71.         komentarze(obraz);
  72.         fscanf(obraz, "%d", &tablica->szerokosc);
  73.         komentarze(obraz);
  74.         fscanf(obraz, "%d", &tablica->wysokosc);
  75.         komentarze(obraz);
  76.         fscanf(obraz, "%d ", &tablica->glebokosc);
  77.  
  78.         //rozpoczecie zapisu samego obrazu
  79.  
  80.         alokacja( tablica, tablica->szerokosc, tablica->wysokosc);
  81.  
  82.  
  83.         for (i; i < tablica->wysokosc; i++)
  84.         {
  85.                 for (j; j < tablica->szerokosc; j++)
  86.         {
  87.                         komentarze(obraz);
  88.                         fscanf(obraz, "%d ", &n);
  89.                         tablica->dane[i][j] = n;
  90.                 }
  91.                 j = 0;
  92.         }
  93.         fclose(obraz);
  94.         }
  95.  
  96. void dodawanieObrazu(struct obrazek* tablica, struct obrazek *struktury, int rozmiar)
  97. {
  98.         int i = 0;
  99.         int j = 0;
  100.         struct obrazek *pomoc;
  101.         pomoc = &struktury[rozmiar - 1];
  102.         struktury[rozmiar - 1].format[0] = tablica->format[0];
  103.     struktury[rozmiar - 1].format[1] = tablica->format[1];
  104.         struktury[rozmiar - 1].wysokosc = tablica->wysokosc;
  105.         struktury[rozmiar - 1].szerokosc = tablica->szerokosc;
  106.         struktury[rozmiar - 1].glebokosc = tablica->glebokosc;
  107.         alokacja(pomoc, tablica->szerokosc, tablica->wysokosc);
  108.         for (i; i < tablica->wysokosc; i++)
  109.         {
  110.                 for (j; j < tablica->szerokosc; j++)
  111.         {
  112.                         struktury[rozmiar - 1].dane[i][j] = tablica->dane[i][j];
  113.                 }
  114.                 j = 0;
  115.         }
  116.  
  117. }
  118. void wyswietlanieObrazu(struct obrazek*struktury, int rozmiar)
  119. {
  120.         int i = 0;
  121.         int j = 0;
  122.         printf("%c", struktury[rozmiar - 1].format[0]);
  123.         printf("%c n", struktury[rozmiar - 1].format[1]);
  124.         printf("%d n", struktury[rozmiar - 1].wysokosc);
  125.         printf("%d n", struktury[rozmiar - 1].szerokosc);
  126.         printf("%d n", struktury[rozmiar - 1].glebokosc);
  127.         for (i; i < struktury[rozmiar - 1].wysokosc; i++)
  128.     {
  129.                 for (j; j < struktury[rozmiar - 1].szerokosc; j++)
  130.                 {
  131.                         printf("%d ", struktury[rozmiar - 1].dane[i][j]);
  132.                 }
  133.                 j = 0;
  134.                 printf("n");
  135.         }
  136. }
  137. void alokacja2(struct obrazek*tablica, int szer, int wys)
  138. {
  139.         int i = 0;
  140.         int j = 0;
  141.         tablica->dane= realloc(0, wys* sizeof(tablica->dane));
  142.     for (i; i < wys; i++)
  143.     {
  144.                 tablica->dane[i]= realloc(0, szer * sizeof(tablica->dane[i]));
  145.         }
  146.  
  147. }
  148.  
  149. struct obrazek  *usuwanie(struct obrazek*struktury, int rozmiar)
  150. {
  151.         struct obrazek * tym;
  152.         int a=0;
  153.         int i = 0;
  154.         int j = 0;
  155.         char c;
  156.         int numer=0;
  157.  
  158.         printf("podaj numer obrazu, ktory chcesz usunac n");
  159.         scanf("%d", &numer);
  160.         while ((c = getchar()) != 'n' && c != EOF);
  161.         a = numer;
  162.         for (a; a < rozmiar; a++)
  163.     {
  164.                 tym = &struktury[a - 1];//numer obrazu
  165.                 struktury[a - 1].format[0] = struktury[a].format[0];
  166.                 struktury[a - 1].format[1] = struktury[a].format[1];
  167.                 struktury[a - 1].szerokosc = struktury[a].szerokosc;
  168.                 struktury[a - 1].wysokosc = struktury[a].wysokosc;
  169.                 struktury[a - 1].glebokosc = struktury[a].glebokosc;
  170.                 alokacja2(tym, struktury[a - 1].szerokosc, struktury[a - 1].wysokosc);
  171.                 for (i; i < struktury[a - 1].wysokosc; i++)
  172.         {
  173.                         for (j; j < struktury[a - 1].szerokosc; j++)
  174.                         {
  175.                                 struktury[a - 1].dane[i][j] = struktury[a].dane[i][j];
  176.                         }
  177.                         j = 0;
  178.                 }
  179.         }
  180.         rozmiar--;
  181.         return struktury;
  182. }
  183. void negatyw(struct obrazek *tablica)
  184. {
  185.         int i = 0;
  186.         int n = 0;
  187.         int j = 0;
  188.  
  189.         for (i; i < tablica->wysokosc; i++)
  190.     {
  191.                 for (j; j < tablica->szerokosc; j++)
  192.                 {
  193.                         tablica->dane[i][j] = tablica->glebokosc - tablica->dane[i][j];
  194.                 }
  195.                 j = 0;
  196.         }
  197.         i = 0;
  198.         j = 0;
  199.  
  200. }
  201. void progowanie(struct obrazek *tablica)
  202. {
  203.         int prog =0;
  204.         printf("glebia szarosci tego obrazu to %d n", tablica->glebokosc);
  205.         printf(" wybierz poziom progowania od 0 do 255 n");
  206.         scanf("%d", &prog);
  207.                 int i = 0;
  208.                 int j = 0;
  209.                 for (i; i < tablica->wysokosc; i++)
  210.         {
  211.                         for (j; j < tablica->szerokosc; j++)
  212.                         {
  213.                                 if (tablica->dane[i][j] < prog)
  214.                     tablica->dane[i][j] = tablica->glebokosc;
  215.                                 else
  216.                                      tablica->dane[i][j] = 0;
  217.                         }
  218.                         j = 0;
  219.  
  220.                 }
  221.  
  222. }
  223. void histogram(struct obrazek tablica)
  224. {
  225.         int * tym;
  226.         int i = 0;
  227.         int j = 0;
  228.         tym = calloc(tablica.glebokosc, sizeof(tablica));//tworzenie tablicy glebokosc
  229.         for (i; i < tablica.wysokosc; i++)
  230.     {
  231.                 for (j; j < tablica.szerokosc; j++)
  232.                 {
  233.                         tym[tablica.dane[i][j]] = tym[tablica.dane[i][j]] + 1;//jesli dany piksel ma dana glebokosc to do komorki z tym numerem dodaje sie jeden
  234.                 }
  235.                 j = 0;
  236.         }
  237.         i = 0;
  238.         FILE *plik;
  239.         plik = fopen("histogram.csv", "w+");//tworzenie pliku z wartosciami tablicy glebokosc
  240.  
  241.         if ((plik = fopen("histogram.csv", "w+")) == NULL)
  242.     {
  243.                 printf("blad przy tworzeniu pliku n");
  244.         }
  245.         for (i; i < tablica.glebokosc; i++)
  246.         {
  247.                 fprintf(plik, "%d n", tym[i]);
  248.         }
  249.         fclose(plik);
  250. }
  251. void obrot(struct obrazek *tablica)
  252. {
  253.         int k = 0;
  254.         int i = 0;
  255.         int j = 0;
  256.     char c;
  257.         printf("podaj k-krotnosc kata 90 stopni obrotu od 1 do 4 n");
  258.         scanf("%d", &k);
  259.         while ((c = getchar()) != 'n' && c != EOF);
  260.  
  261.         switch (k) {
  262.         case 4:break;
  263.  
  264.         case 1:
  265.                         alokacja2(tablica, tablica->wysokosc, tablica->szerokosc);
  266.                         tablica->szerokosc = tablica->wysokosc;
  267.                         tablica->wysokosc = tablica->szerokosc;
  268.                         for (i; i < tablica->wysokosc; i++)
  269.                         {
  270.                                 for (j; j < tablica->szerokosc; j++)
  271.                 {
  272.                                         tablica->dane[i][j] = tablica->dane[j][tablica->szerokosc - 1 - i];
  273.                                 }
  274.                                 j = 0;
  275.  
  276.                         }
  277.                         i = 0;
  278.                         j = 0;
  279.                         break;
  280.         case 2:
  281.                         for (i; i < tablica->wysokosc; i++)
  282.                         {
  283.                                 for (j; j < tablica->szerokosc; j++)
  284.                 {
  285.                                         tablica->dane[i][j] = tablica->dane[tablica->wysokosc - i - 1][tablica->szerokosc - j - 1];
  286.                                 }
  287.                                 j = 0;
  288.                         }
  289.  
  290.                 i = 0;
  291.                 j = 0;
  292.                 break;
  293.  
  294.         case 3:
  295.                         alokacja2(tablica, tablica->wysokosc, tablica->szerokosc);
  296.                         tablica->szerokosc = tablica->wysokosc;
  297.                         tablica->wysokosc = tablica->szerokosc;
  298.                         for (i; i < tablica->wysokosc; i++)
  299.             {
  300.                                 for (j; j < tablica->szerokosc; j++)
  301.                                 {
  302.                                         tablica->dane[i][j] = tablica->dane[tablica->szerokosc - 1 - j][i];
  303.                                 }
  304.                                 j = 0;
  305.                         }
  306.                         i = 0;
  307.                         j = 0;
  308.                         break;
  309.         default:
  310.                         printf("podales zla wielokrotnosc kata 90 stopni. n");
  311.                         return 0;
  312.                         break;
  313.         }
  314.  
  315.  
  316. }
  317. void szum(struct obrazek *tablica)
  318. {
  319.     srand(time(NULL));
  320.     int i, j, k, l;
  321.     for (i = 0; i < tablica->wysokosc; i++)
  322.     {
  323.         for (j = 0; j < tablica->szerokosc; j++)
  324.         {
  325.             k = rand() % 20 + 1;
  326.             if (k == 5)
  327.             {
  328.                 l = rand() % 2 + 1;
  329.                 if (l == 1)
  330.                     tablica->dane[i][j] = 0;
  331.                 else
  332.                     tablica->dane[i][j] = tablica->glebokosc;
  333.             }
  334.         }
  335.     }
  336. }
  337.  
  338. void filtrMedianowy(struct obrazek *tablica)
  339. {
  340.     int macierz[9];
  341.     int i, j, k, l, m, n, y, z;
  342.     for (i = 1; i < (tablica->wysokosc)-1; i++)
  343.     {
  344.         for (j = 1; j < (tablica->szerokosc)-1; j++)
  345.         {
  346.             l = 1;
  347.             m = 1;
  348.             for (k = 0; k < 9; k++)
  349.             {
  350.                 if ((k == 3) || (k == 6))
  351.                 {
  352.                     m--;
  353.                     l = 1;
  354.                 }
  355.                 macierz[k] = tablica->dane[i - l][j - m];
  356.                 l--;
  357.             }
  358.             for (y = 0; y < 8; y++)
  359.             {
  360.                 for (z = 0; z < 8; z++)
  361.                 {
  362.                     if (macierz[z] > macierz[z + 1])
  363.                     {
  364.                         n = macierz[z];
  365.                         macierz[z] = macierz[z + 1];
  366.                         macierz[z + 1] = n;
  367.                     }
  368.                 }
  369.             }
  370.             tablica->dane[i][j] = macierz[4];
  371.         }
  372.     }
  373. }
  374. void zapisObrazu (struct obrazek*tablica)
  375. {
  376.     int i, j;
  377.     char c;
  378.     char nazwa[120];
  379.     printf("podaj nazwe obrazu do zapisu n");
  380.         scanf("%s", &nazwa);
  381.         strcat(nazwa, ".pgm");
  382.         printf("%s n", nazwa);
  383.         while ((c = getchar()) != 'n' && c != EOF);
  384.         FILE*obraz;
  385.         obraz = fopen(nazwa, "w+");
  386.  
  387.         if ((obraz = fopen(nazwa, "w+")) == NULL)
  388.     {
  389.                 printf("blad przy odzycie pliku, podaj nazwe jeszcze raz n");
  390.         }
  391.  
  392.         fprintf(obraz, "%c", tablica->format[0]); //zapis pierwszego znaku
  393.         fprintf(obraz, "%c n", tablica->format[1]); // zapis drugiego znaku
  394.         fprintf(obraz, "%d n", tablica->szerokosc);
  395.         fprintf(obraz, "%d n", tablica->wysokosc);
  396.         fprintf(obraz, "%d n", tablica->glebokosc);
  397.         //rozpoczecie zapisu samego obrazu
  398.         for (i; i < tablica->wysokosc; i++)
  399.     {
  400.                 for (j; j < tablica->szerokosc; j++)
  401.                 {
  402.                          fprintf(obraz, "%d ", tablica->dane[i][j]);
  403.                 }
  404.                 j = 0;
  405.                 fprintf(obraz, " n");
  406.  
  407.         }
  408.         fclose(obraz);
  409. }
  410.  
  411. void main()
  412. {
  413.         int x = 0;
  414.         int y = 0;
  415.         int i =0;
  416.         int j =0;
  417.         int z = 0;
  418.         int nr= 0;
  419.         int nrobrazu = 0;
  420.         int rozmiar=0;
  421.         int zabieranie = 0;
  422.         char c;
  423.         struct obrazek *tablica;
  424.         struct obrazek *struktury;
  425.         struct obrazek a;
  426.         tablica = &a;
  427.         struktury = calloc(0, sizeof(*struktury));
  428.         struktury=realloc(struktury, 10 * sizeof(*struktury));
  429.  
  430.         for (;;)
  431.         {
  432.                 printf("1 - dodanie obrazun");
  433.                 printf("2 - usuniecie obrazu n");
  434.                 printf("3 - wyswietlanie obrazu n ");
  435.                 printf("4 - obrot obrazu o k * 90 stopni n");
  436.                 printf("5 - wykonanie negatywu n");
  437.                 printf("6 - wykonanie progowania n");
  438.                 printf("7 - wykonanie histogramu n");
  439.                 printf("8 - zapis przetwarzanego obrazu n");
  440.                 printf("9 - koniec programu n");
  441.                 printf("podaj liczbe n");
  442.                 scanf("%d", &z);
  443.                 while ((c = getchar()) != 'n' && c != EOF);//czysci bufor nie da rady wpisac 1 1 1 np
  444.                 switch (z) {
  445.                 case 1: // dodawanie
  446.                         wczytywanieobrazu(tablica, rozmiar);
  447.                         rozmiar = rozmiar + 1;
  448.                         dodawanieObrazu(tablica, struktury, rozmiar);
  449.                         break;
  450.  
  451.                 case 2: // usuwanie
  452.                         struktury =usuwanie(struktury, rozmiar);
  453.                         rozmiar--;
  454.                         break;
  455.  
  456.                 case 3: //wyswietlanie
  457.                         do {
  458.                                 printf("podaj numer obrazu n");
  459.                                 scanf("%d", &nrobrazu);
  460.                                 while ((c = getchar()) != 'n' && c != EOF);
  461.                                 if (nrobrazu > rozmiar) printf("nie ma jeszcze tyle obrazow n");
  462.                         } while (nrobrazu>rozmiar);
  463.  
  464.                         wyswietlanieObrazu(struktury, nrobrazu);
  465.                         break;
  466.  
  467.                 case 4:
  468.                         printf("podaj numer obrazu do wykonania obrotu n");
  469.                         scanf("%d", &nr);
  470.                         while ((c = getchar()) != 'n' && c != EOF);
  471.                         if (nr >= (rozmiar + 1) || nr <= 0) {
  472.                                 printf("nie ma obrazu o takim numerze n");
  473.                                 break;
  474.  
  475.                         }
  476.                         obrot(&struktury[nr - 1]);
  477.                         nr = 0;
  478.                         break;
  479.  
  480.                 case 5:
  481.                         printf("podaj numer obrazu do wykonania negatywu n");
  482.                         scanf("%d", &nr);
  483.                         while ((c = getchar()) != 'n' && c != EOF);
  484.                         if (nr >= (rozmiar+1) || nr <= 0) {
  485.                                 printf("nie ma obrazu o takim numerze n");
  486.                                 break;
  487.                         }
  488.                         negatyw(&struktury[nr-1]);
  489.                         nr = 0;
  490.                         break;
  491.  
  492.                 case 6:
  493.                         printf("podaj numer obrazu do wykonania progowania n");
  494.                         scanf("%d", &nr);
  495.                         while ((c = getchar()) != 'n' && c != EOF);
  496.                         if (nr >= (rozmiar + 1) || nr <= 0) {
  497.                                 printf("nie ma obrazu o takim numerze n");
  498.                                 break;
  499.                         }
  500.                         progowanie(&struktury[nr-1]);
  501.                         nr = 0;
  502.                         break;
  503.  
  504.                 case 7:
  505.                         printf("podaj numer obrazu do wykonania histogramu n");
  506.                         scanf("%d", &nr);
  507.                         while ((c = getchar()) != 'n' && c != EOF);
  508.                         if (nr >= (rozmiar + 1) || nr <= 0) {
  509.                                 printf("nie ma obrazu o takim numerze n");
  510.                                 break;
  511.                         }
  512.                         histogram(struktury[nr - 1]);
  513.                         nr = 0;
  514.                         break;
  515.  
  516.         case 8:
  517.             printf("podaj numer obrazu do zapisu n");
  518.                         scanf("%d", &nr);
  519.                         while ((c = getchar()) != 'n' && c != EOF);
  520.                         if (nr >= (rozmiar + 1) || nr <= 0) {
  521.                                 printf("nie ma obrazu o takim numerze n");
  522.                                 break;
  523.                         }
  524.                         zapisObrazu(&struktury[nr - 1]);
  525.                         nr = 0;
  526.                         break;
  527.  
  528.         case 9:
  529.                         return 0;
  530.                         break;
  531.  
  532.                 default:
  533.                         printf("w menu nie ma takiego numeru n");
  534.                         break;
  535.                 }
  536.         }
  537.         system("pause");
  538. }