API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 20th, 2017
157
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 20.64 KB | None | 0 0
raw download clone embed print report
  1. /********************************modul.h****************************************/
  2. #ifndef MODUL_H
  3. #define MODUL_H
  4. #define MAX 512
  5.  
  6. typedef struct     /*struktura do przechowywania danych o obrazie*/
  7. {
  8.   int wymx, wymy, szarosci;
  9.   int *tab;
  10.   char numer[2];
  11. } dane;
  12.  
  13. void wyswietl(char *) ;
  14. void assert (int, char *);
  15. int negatyw (dane *);
  16. int progowanie (dane *, int);
  17. int zmiana_poziomow (dane *,int, int);
  18. int konturowanie (dane *);
  19. int rozciaganie_histogramu (dane *);
  20. int konwersja_do_szarosci (dane *);
  21.  
  22.  
  23.  
  24. #endif
  25. /*********************************modul.c*************************************/
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include "modul.h"
  30.  
  31.  
  32.  
  33. #define MAX 512
  34. #define DL_LINII 1024
  35.  
  36.  
  37.  
  38. void wyswietl(char *n_pliku) {
  39.   char polecenie[DL_LINII];    
  40.  
  41.   strcpy(polecenie,"display ");
  42.   strcat(polecenie,n_pliku);    
  43.   strcat(polecenie," &");
  44.   printf("%s\n",polecenie);    
  45.   system(polecenie);            
  46. }
  47.  
  48. /*************************************************************************
  49. *                                                                        *
  50. * Funkcja wyswietlajaca bledy asercji. Konczy dzialanie programu, jesli  *
  51. * zostanie wywolana z innego miejsca programu                            *
  52. *                                                                        *
  53. **************************************************************************/
  54.  
  55. void assert (int warunek, char *komunikat)
  56. {
  57.   if (warunek)       /*Jesli warunek zostaje spelniony*/
  58.     {
  59.       printf("Blad asercji: %s\n",komunikat);              /*Wyswietl komunikat*/
  60.       printf("Program nie moze kontynuowac.");
  61.       exit(-1);           /*Wyjscie z programu*/
  62.     }
  63. }
  64.  
  65. /************************************************************************
  66.  *                                                                      *
  67.  * Funkcja robiaca negatyw obrazu o zadanych wymiarach i skali szarosci *
  68.  *                                                                      *
  69.  ************************************************************************/
  70.  
  71. int negatyw (dane *obraz)
  72. {
  73.   int a, b;    /*Zmienne pomocnicze do wypelniania tablicy*/
  74.  
  75.   for(a=0; a<obraz->wymy; a++)
  76.     {
  77.       for(b=0; b<obraz->wymx; b++)
  78.     {
  79.       obraz->tab[obraz->wymx*a+b]=obraz->szarosci-obraz->tab[obraz->wymx*a+b];    
  80.  /*Zmiana wartosci odcieni dla poszczegolnych pikseli*/
  81.     }
  82.     }
  83. }
  84.  
  85. /************************************************************************
  86.  *                                                                      *
  87.  * Funkcja progujaca obraz o przez uzytkownika progu (liczba podana w   *
  88.  * procentach).                                                         *
  89.  *                                                                      *
  90.  ************************************************************************/
  91.  
  92. int progowanie (dane *obraz, int prog)
  93. {
  94.   int a, b;
  95.   prog=prog*obraz->szarosci/100;    /*Zamien wartosc procentowa progu na liczbe w zaleznosci od stopnia szarosci*/
  96.   for(a=0; a<obraz->wymy; a++)
  97.     {
  98.       for(b=0; b<obraz->wymx; b++)              /*Dla kazdego piksela*/
  99.     {
  100.       if (obraz->tab[obraz->wymx*a+b]>prog)      /*Jezeli wieksze niz prog*/
  101.         {
  102.           obraz->tab[obraz->wymx*a+b]=obraz->szarosci;     /*Ustaw wartosc na maks*/
  103.         }
  104.       else
  105.         {
  106.           obraz->tab[obraz->wymx*a+b]=0;  /*Jesli nie, min*/
  107.         }
  108.     }
  109.     }
  110. }
  111.  
  112. /***********************************************************************
  113.  *                                                                     *
  114.  * Funkcja robiaca zmiane poziomow obrazu. Uzytkowanik podaje nowe     *
  115.  * wartosci czerni i bieli wyrazone w procentach.                      *
  116.  *                                                                     *
  117.  ***********************************************************************/
  118.  
  119. int zmiana_poziomow (dane *obraz,int czern, int biel)
  120. {
  121.   czern=czern*obraz->szarosci/100;  /*Zamiana wartosci czerni z procentow na liczbe zalezna od skali szarosci*/
  122.   biel=biel*obraz->szarosci/100;  /*Analogicznie dla wartosci czerni*/
  123.   int a, b;
  124.   for(a=0; a<obraz->wymy; a++)
  125.     {
  126.       for(b=0;b<obraz->wymx; b++)
  127.     {
  128.       if (obraz->tab[obraz->wymx*a+b]>czern && obraz->tab[obraz->wymx*a+b]<biel)
  129.         { /*Jezeli znajduje sie w zakresie pomiedzy nowymi wartosciami*/
  130.           obraz->tab[obraz->wymx*a+b]=(obraz->tab[obraz->wymx*a+b]-czern)*obraz->szarosci/(biel-czern);
  131.         } /*Oblicz nowa wartosc korzystajac ze wzoru*/
  132.       else
  133.         {
  134.           if(obraz->tab[obraz->wymx*a+b]<=czern)  /*Jesli mniejszy/rowny czern*/
  135.         {
  136.           obraz->tab[obraz->wymx*a+b]=0;    /*Ustaw wartosc na min*/
  137.         }
  138.           else
  139.         {
  140.           obraz->tab[obraz->wymx*a+b]=obraz->szarosci;   /*Jesli nie, max*/
  141.         }
  142.         }
  143.     }
  144.     }
  145. }
  146.  
  147. /**********************************************************************
  148.  *                                                                    *
  149.  * Funkcja wykonujaca operacje konturowania                           *
  150.  *                                                                    *
  151.  **********************************************************************/
  152.  
  153.  
  154.  
  155. int konturowanie (dane *obraz)
  156. {
  157.   int a,b;
  158.   for (a=0; a<obraz->wymy; a++)
  159.     {
  160.       for (b=0; b<obraz->wymx; b++)
  161.     {
  162.       obraz->tab[obraz->wymx*a+b]=abs(obraz->tab[obraz->wymx*a+b+1]-obraz->tab[obraz->wymx*a+b])+abs(obraz->tab[obraz->wymx*(a+1)+b]-obraz->tab[obraz->wymx*a+b]); /*Oblicz nowa wartosc korzystajac ze wzoru*/
  163.     }
  164.     }
  165. }
  166.  
  167. /*********************************************************************
  168.  *                                                                   *
  169.  * Funkcja wykonujaca operacje rozciagniecia histogramu. Funkcja     *
  170.  * szuka najmniejszej i najwiekszej wartosci, po czym oblicza nowe   *
  171.  * wartosci korzystajac ze wzoru.                                    *
  172.  *                                                                   *
  173.  *********************************************************************/
  174.  
  175.  
  176.  
  177.  
  178. int rozciaganie_histogramu (dane *obraz)
  179. {
  180.   int a, b;
  181.   int min=obraz->tab[0];     /*Min jako pierwszy element*/
  182.   int max=min;            /*Max jako pierwszy element*/
  183.   for(a=0; a<obraz->wymy; a++)
  184.     {
  185.       for(b=0; b<obraz->wymx; b++)
  186.     {
  187.       if (obraz->tab[obraz->wymx*a+b]<min)
  188.         {
  189.           min=obraz->tab[obraz->wymx*a+b];    /*Jesli mniejszy niz min: zamien min na nowa wartosc*/
  190.         }
  191.       if(obraz->tab[obraz->wymx*a+b]>max)
  192.         {
  193.           max=obraz->tab[obraz->wymx*a+b];    /*Analogicznie max*/
  194.         }
  195.     }
  196.       for(a=0; a<obraz->wymy; a++)
  197.     {
  198.       for(b=0; b<obraz->wymx; b++)
  199.         {
  200.           obraz->tab[obraz->wymx*a+b]=(obraz->tab[obraz->wymx*a+b]-min)*obraz->szarosci/(max-min);
  201.         } /*Korzystajac ze wzoru oblicz nowa wartosc*/
  202.     }
  203.     }
  204. }
  205.  
  206. /************************************************************************
  207.  *                                                                      *
  208.  * Funkcja wykonujaca operacje kowersji obrazu kolorowego do obrazu     *
  209.  * bialo-czarnego. Funkcja dla kazdego piksela, ktory sklada sie z      *
  210.  * trzech liczb (dlatego tablica do wypelnienia jest 3 razy wieksza)    *
  211.  * wyciaga srednia arytmetyczna z jego skladowych i kazdemu kolorowi    *
  212.  * przyporzadkowuje wartosc sredniej.                                   *
  213.  *                                                                      *
  214.  ************************************************************************/
  215.  
  216.  
  217.  
  218. int konwersja_do_szarosci (dane *obraz)
  219. {
  220.   int a, b;
  221.  
  222.   for(a=0; a<obraz->wymy; a++)
  223.     {
  224.       for(b=0; b<3*obraz->wymx; b=b+3) /*Dla tablicy, ktora ma 3 razy wiecej miejsca niz tablica .pgm*/
  225.     {    /*Skacze o 3 miejsca, gdyz tyle liczb sklada sie na jeden piksel*/
  226.       obraz->tab[3*obraz->wymx*a+b]=(obraz->tab[3*obraz->wymx*a+b]+obraz->tab[3*obraz->wymx*a+b+1]+obraz->tab[3*obraz->wymx*a+b+2])/3;   /*Wartosc pierwszej skladowej to teraz srednia wszystkich trzech*/
  227.       obraz->tab[3*obraz->wymx*a+b+1]= obraz->tab[3*obraz->wymx*a+b];
  228.       obraz->tab[3*obraz->wymx*a+b+2]= obraz->tab[3*obraz->wymx*a+b];
  229.     } /*Przypisz pozostalym skladowym te sama wartosc*/
  230.     }
  231. }
  232. /**************************************main.c***************************************/
  233.  
  234. #include <stdio.h>
  235. #include <stdlib.h>
  236. #include <string.h>
  237. #include <math.h>
  238. #include <string.h>
  239. #include "modul.h"
  240.  
  241.  
  242.  
  243. #define MAX 512
  244. #define DL_LINII 1024
  245.  
  246.  
  247.  
  248. /************************************************************************************************
  249.  * Funkcja czytajaca obrazy i rozpoznajaca ich rozszerzenie. Numer magiczny zapisuje do tablicy *
  250.  * numer[] w strukturze "dane", wymiary, liczbe odcieni i piksele zapisuje odpowiednio do       *
  251.  * wymx/wymy, szarosci, *tab.                                                                   *
  252.  * Funkcja zwraca ilosc pikseli                                                                 *
  253.  ************************************************************************************************/
  254.  
  255. int czytaj(FILE *plik_we, dane *obraz) {
  256.   char buf[DL_LINII];    
  257.   int znak;              
  258.   int koniec=0;          
  259.   int i,j;
  260.  
  261.   if (plik_we==NULL) {
  262.     fprintf(stderr,"Blad: Nie podano uchwytu do pliku\n");
  263.     return(0);
  264.   }
  265.  
  266.   /* Sprawdzenie "numeru magicznego" - powinien być P2 lub P3*/
  267.   if (fgets(buf,DL_LINII,plik_we)==NULL)   /* Wczytanie pierwszej linii pliku do bufora */
  268.     koniec=1;                              /* Nie udalo sie? Koniec danych! */
  269.  
  270.   if ( (buf[0]!='P') || ((buf[1]!='2')&&buf[1]!='3') || koniec) {  /* Czy jest magiczne "P2" lub "P3"? */
  271.     fprintf(stderr,"Blad: To nie jest plik PGM lub PPM\n");
  272.     return(0);
  273.   }
  274.  
  275.   obraz->numer[0]='P';              /*Pierwszy element tablicy jako P, drugi zalezny od wczytanego pliku*/
  276.   obraz->numer[1]=buf[1];
  277.  
  278.  
  279.   /* Pominiecie komentarzy */
  280.   do {
  281.     if ((znak=fgetc(plik_we))=='#') {         /* Czy linia rozpoczyna sie od znaku '#'? */
  282.       if (fgets(buf,DL_LINII,plik_we)==NULL)  /* Przeczytaj ja do bufora                */
  283.     koniec=1;                   /* Zapamietaj ewentualny koniec danych */
  284.     }  else {
  285.       ungetc(znak,plik_we);                   /* Gdy przeczytany znak z poczatku linii */
  286.     }                                         /* nie jest '#' zwroc go                 */
  287.   } while (znak=='#' && !koniec);   /* Powtarzaj dopoki sa linie komentarza */
  288.                                     /* i nie nastapil koniec danych         */
  289.  
  290.  
  291.   /* Pobranie wymiarow obrazu i liczby odcieni szarosci */
  292.   if (fscanf(plik_we,"%d %d %d",&(obraz->wymx),&(obraz->wymy),&(obraz->szarosci))!=3) {
  293.     fprintf(stderr,"Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n");
  294.     return(0);
  295.   }
  296.  
  297.   if (obraz->numer[1]=='2')
  298.     {    
  299.       obraz->tab =(int *) malloc(obraz->wymx*obraz->wymy*sizeof(int));    /*alokacja pamieci dla tablicy pikseli*/
  300.      
  301.   /* Pobranie obrazu .pgm i zapisanie w tablicy tab*/
  302.  
  303.       for (i=0;i<obraz->wymy;i++) {
  304.     for (j=0;j<obraz->wymx;j++) {
  305.       if (fscanf(plik_we,"%d",&(obraz->tab[obraz->wymx*i+j]))!=1) {  
  306.         fprintf(stderr,"Blad: Niewlasciwe wymiary obrazu\n");
  307.         return(0);
  308.       }
  309.     }
  310.       }
  311.     }
  312.  
  313.  if (obraz->numer[1]=='3')
  314.     {
  315.       obraz->tab =(int *) malloc(3*obraz->wymx*obraz->wymy*sizeof(int)); /*alokacja pamieci dla .ppm*/
  316.   /* Pobranie obrazu .ppm i zapisanie w tablicy tab*/
  317.      
  318.       for (i=0;i<obraz->wymy;i++)
  319.     {
  320.       for (j=0;j<3*obraz->wymx;j++)
  321.         {
  322.           if (fscanf(plik_we,"%d",&(obraz->tab[3*obraz->wymx*i+j]))!=1)
  323.         {
  324.           fprintf(stderr,"Blad: Niewlasciwe wymiary obrazu\n");
  325.           return(0);
  326.         }
  327.         }
  328.     }
  329.     }
  330.  
  331.  
  332.  
  333.   return obraz->wymx*obraz->wymy;   /* Czytanie zakonczone sukcesem    */
  334. }                       /* Zwroc liczbe wczytanych pikseli */
  335.  
  336.  
  337. /*****************************************************************************
  338.  *                                                                           *
  339.  * Funkcja zapisujaca obraz do pliku o zadanej nazwie. Zaleznie od pobranego *
  340.  * pliku zapisuje w formacie .pgm lub .ppm                                   *
  341.  *                                                                           *
  342.  *****************************************************************************/
  343.  
  344. int zapisz(FILE *plik_wyjsciowy, dane *obraz)
  345. {
  346.   int a, b;    /*Zmienne pomocnicze do wypelniania tablicy*/
  347.   if(obraz->numer[1]=='2')
  348.     {
  349.       fprintf(plik_wyjsciowy,"P2\n");   /*Zapisanie numeru magicznego */
  350.  
  351.       fprintf(plik_wyjsciowy,"%d %d %d\n",obraz->wymx,obraz->wymy,obraz->szarosci);  
  352.  /*Zapisanie rozmiaru obrazu i skali szarosci*/
  353.       for(a=0;a<obraz->wymy;a++)
  354.     {
  355.       for(b=0;b<obraz->wymx; b++)
  356.         {
  357.           fprintf(plik_wyjsciowy,"%d ",obraz->tab[obraz->wymx*a+b]);
  358.   /*Wypelnienie tablicy*/
  359.         }
  360.     }
  361.    }
  362.  
  363. if(obraz->numer[1]=='3')
  364.     {
  365.       fprintf(plik_wyjsciowy,"P3\n");   /*Zapisanie numeru magicznego */
  366.  
  367.       fprintf(plik_wyjsciowy,"%d %d %d\n",obraz->wymx,obraz->wymy,obraz->szarosci);  
  368.  /*Zapisanie rozmiaru obrazu i skali szarosci*/
  369.       for(a=0;a<obraz->wymy;a++)
  370.     {
  371.       for(b=0;b<3*obraz->wymx; b++)
  372.         {
  373.           fprintf(plik_wyjsciowy,"%d ",obraz->tab[3*obraz->wymx*a+b]);
  374.   /*Wypelnienie tablicy*/
  375.         }
  376.     }
  377.    }
  378. }
  379.  
  380.  
  381. int przetwarzaj_opcje(int argc, char **argv) {
  382.   int i, prog;   /*Zmienne pomocnicze i-do sprawdzania argumentow, prog-prog do progowania, a-do menu*/
  383.   char *nazwa_pliku_we, *nazwa_pliku_wy;  
  384.   int czern, biel;   /*Zmienne pomocnicze do nowych progow czerni i bieli*/
  385.   FILE *plik_we;   /*Uchwyty do plikow wej i wyj*/
  386.   FILE *plik_wy;
  387.   int zapis=0;    /*Zmienna pomocnicza, by zapisywac plik na koncu dzialania*/
  388.   int wyswietlic=0;    /*Zmienna pomocnicza, by wyswietlac plik na koncu dzialania*/
  389.   int odczytano=0,a=0;
  390.   char *nazwa;
  391.  
  392.  
  393.   dane *obrazek;
  394.   obrazek=(dane *)malloc(sizeof(dane));    /*alokacja pamieci na wskaznik na strukture danych*/
  395.  
  396.  plik_wy=stdout;        /* na wypadek gdy nie podano opcji "-o" */
  397.  
  398.   for (i=1; i<argc; i++) {
  399.     assert ((argv[i][0] != '-'),"To nie jest opcja!");  /* blad: to nie jest opcja - brak znaku "-" */
  400.    switch (argv[i][1]) {
  401.     case 'i': {                 /* opcja z nazwa pliku wejsciowego */
  402.       if (++i<argc)
  403.     {   /* wczytujemy kolejny argument jako nazwe pliku */
  404.     nazwa_pliku_we=argv[i];
  405.     if (strcmp(nazwa_pliku_we,"-")==0) /* gdy nazwa jest "-"        */
  406.       plik_we=stdin;            /* ustwiamy wejscie na stdin */
  407.     else                               /* otwieramy wskazany plik   */
  408.       plik_we=fopen(nazwa_pliku_we,"r");
  409.     }
  410.       else
  411.     {
  412.       assert(1,"Brak nazwy pliku");
  413.     }                  /* blad: brak nazwy pliku */
  414.       czytaj(plik_we,obrazek);
  415.       break;
  416.     }
  417.     case 'o':
  418.       {                 /* opcja z nazwa pliku wyjsciowego */
  419.     if (++i<argc)
  420.       {                       /* wczytujemy kolejny argument jako nazwe pliku */
  421.         nazwa_pliku_wy=argv[i];
  422.         if (strcmp(nazwa_pliku_wy,"-")==0)
  423.           {                              /* gdy nazwa jest "-"         */
  424.         plik_wy=stdout;          /* ustwiamy wyjscie na stdout */
  425.           }
  426.      
  427.         else
  428.           {                          /* otwieramy wskazany plik    */
  429.         plik_wy=fopen(nazwa_pliku_wy,"w");
  430.           }
  431.         zapis=1;
  432.       }
  433.     else
  434.       {
  435.         assert(1,"Brak nazwy pliku");
  436.       }                  /* blad: brak nazwy pliku */
  437.  
  438.      
  439.       break;
  440.       }
  441.     case 'p': {
  442.       if (++i<argc) {         /* wczytujemy kolejny argument jako wartosc progu */
  443.     if (sscanf(argv[i],"%d",&prog)==1)
  444.       {
  445.         progowanie(obrazek,prog); /*I uruchamiamy funkcje*/
  446.       }
  447.       }
  448.       else
  449.     assert(1,"Brak wartosci progu");          /* blad: brak wartosci progu */
  450.       break;
  451.     }
  452.     case 'n': {                 /* mamy wykonac negatyw */
  453.       negatyw(obrazek);
  454.       break;
  455.     }
  456.     case 'k': {                 /* mamy wykonac konturowanie */
  457.       konturowanie(obrazek);
  458.       break;
  459.     }
  460. case 'z':
  461.       {
  462.     if (++i<argc)
  463.       {                        
  464.         sscanf(argv[i],"%d",&czern)==1;  /*Wczytanie nowej wartosci czerni*/
  465.       }
  466.     else
  467.       {
  468. assert(1,"Brak nowej wartosci czerni.");
  469.       }
  470.     if (++i<argc)
  471.       {
  472.         if (sscanf(argv[i],"%d",&biel)==1)  /*Analogicznie bieli*/
  473.           {
  474.        
  475.         zmiana_poziomow(obrazek,czern,biel);
  476.           }
  477.         else
  478.           {
  479. assert(1,"Brak nowej wartosci bieli.");
  480.           }
  481.       }
  482.     break;  
  483.       }
  484.    
  485.     case 'h':
  486.       {
  487.     rozciaganie_histogramu(obrazek);
  488.     break;
  489.       }
  490.     case 'm':
  491.       {
  492.     if(++i<argc)
  493.       {
  494.         if (argv[i][0]=='s')      /*Jesli kolejny arument to s*/
  495.           if (obrazek->numer[1]==3)
  496.         {        
  497.           konwersja_do_szarosci(obrazek);
  498.         }
  499.           else
  500.         {
  501.           assert(1,"To nie jest plik .ppm");
  502.         }
  503.       }
  504.     break;
  505.       }
  506.     case 'd': {                 /* mamy wyswietlic obraz */
  507.       wyswietlic=1;
  508.       break;
  509.     }
  510.     default:                    /* nierozpoznana opcja */
  511.       assert(1,"Brak dozwolonej opcji.");
  512.     } /*koniec switch */
  513.   } /* koniec for */
  514.   if (zapis==1)   /*Jesli flaga na zapis jest postawiona, zapisz plik na koncu dzialania programu*/
  515.     {
  516.       zapisz(plik_wy,obrazek);
  517.     }
  518.   if (wyswietlic==1)  /*Analogicznie wyswietlanie*/
  519.     {
  520.       if (zapis==0)
  521.     {
  522.       nazwa_pliku_wy="tmp";
  523.       plik_wy=fopen(nazwa_pliku_wy,"w");
  524.       zapisz(plik_wy,obrazek);
  525.       fclose(plik_wy);
  526.     }
  527.       wyswietl(nazwa_pliku_wy);
  528.     }
  529.  
  530.  
  531. if (argc==1)
  532.   {
  533.      while(a!=10)       /*Wyswietlanie menu*/
  534.     {
  535.   printf("Dostepne opcje:\n");
  536.   printf("1. Odczyt pliku.\n");
  537.   printf("2. Zapis pliku.\n");
  538.   printf("3. Negatyw.\n");
  539.   printf("4. Wyswietlenie obrazu.\n");
  540.   printf("5. Konturowanie.\n");
  541.   printf("6. Progowanie.\n");
  542.   printf("7. Zmiana poziomow.\n");
  543.   printf("8. Rozciaganie histogramu.\n");
  544.   printf("9. Konwersja do szarosci.\n");
  545.   printf("10. Wyjscie z programu.\n");
  546.   printf("Twoj wybor: ");
  547.   scanf("%d", &a);
  548.  
  549.   switch (a)                    /*Menu*/
  550.     {
  551.     case 1:
  552.     {
  553.       printf("Podaj nazwe pliku do wczytania: ");
  554.       scanf("%s",nazwa);
  555.       plik_we=fopen(nazwa,"r");
  556.       if(plik_we!=NULL)
  557.     {
  558.       odczytano=czytaj(plik_we,obrazek);  /*Jezeli odczytano, czytaj zmienia wartosc*/
  559.     }
  560.       else
  561.     {
  562.       printf("Nie mozna wczytac pliku.");
  563.     }
  564.  
  565.     }
  566.     break;
  567.     case 2:
  568.       {
  569.     if (odczytano!=0)    /*Jezeli odczytano plik*/
  570.       {
  571.         printf("Podaj nazwe pliku do zapisu: ");
  572.         scanf("%s",nazwa);
  573.         plik_wy=fopen(nazwa,"w");        /*Otworz plik do pisania*/
  574.         zapisz(plik_wy,obrazek);    /*Funkcja zapisz*/
  575.         fclose(plik_wy);
  576.       }
  577.     else
  578.       {
  579.         printf("Nie wczytano pliku!\n");
  580.       }      
  581.       }
  582.       break;
  583.     case 3:
  584.       {
  585.     if (odczytano!=0)
  586.       {
  587.         negatyw(obrazek);          /*Funkcja negatyw*/
  588.       }
  589.     else
  590.       {
  591.         printf("Nie wczytano pliku!\n");
  592.       }
  593.       }
  594.       break;
  595.     case 4:
  596.       {
  597.     if (odczytano!=0)
  598.       {
  599.            
  600.  wyswietl(nazwa_pliku_wy);        /*Funkcja wyswietl*/
  601.       }
  602.     else
  603.       printf("Nie wczytano pliku!\n");
  604.       }
  605.       break;
  606.     case 5:
  607.       {
  608.     konturowanie(obrazek);
  609.       }
  610.       break;
  611.     case 6:
  612.       {
  613.     printf("Podaj procentowa wartosc progu (liczba od 0-100):\n");
  614.     scanf("%d",&prog);
  615.     progowanie(obrazek,prog);
  616.       }
  617.       break;
  618.     case 7:
  619.       {
  620.     printf("Podaj procentowa wartosc czerni i bieli (liczba od 0-100):\n");
  621.     scanf("%d%d",&czern,&biel);
  622.     zmiana_poziomow(obrazek,czern,biel);
  623.       }
  624.       break;
  625.     case 8:
  626.       {
  627.     rozciaganie_histogramu(obrazek);
  628.       }
  629.       break;
  630.     case 9:
  631.       {
  632.     konwersja_do_szarosci(obrazek);
  633.       }
  634.       break;
  635.     case 10:
  636.     {
  637.       printf("Koniec dzialania programu.\n");
  638.     }
  639.     break;
  640.     default:
  641.       {
  642.     printf("Nie ma takiej opcji w menu.\n");
  643.       }
  644.       break;
  645.     }
  646.     }
  647.  
  648.   }
  649.  
  650.  
  651.  
  652.  
  653.  
  654.  
  655.  
  656. }
  657.  
  658.  
  659.  
  660.  
  661.  
  662. int main(int argc, char ** argv) {
  663.  
  664.   przetwarzaj_opcje(argc,argv);  /*Uruchom fukncje przetwarzania*/
  665.  
  666.  
  667.  
  668.   return 0;
  669. }
  670.  
  671.  
  672. /*
  673.  
  674. SPRAWOZDANIE
  675.  
  676. Maciej Adamski, Przetwarzanie obrazów 2, 18.12.2016r.
  677.  
  678. TESTY OPROGRAMOWANIA
  679.  
  680. - przetestowanie kazdej z mozliwych opcji ([-p liczba],-n, -h itd) poprzez wywolanie programu
  681. Wynik: pozytywny
  682. - przetestowanie kazdej funkcji edycji obrazu (czy dziala poprawnie) poprzez wyswietlanie obrazu po edycji
  683. Wynik: pozytywny
  684. - przetestowanie opcji dot zapisu do pliku ze strumienia wejsciowego, wczytania z pliku na strumien wyjsciowy
  685.   oraz obu opcji na raz
  686. Wynik: pozytywny
  687. - przetestowanie zachowania programu podczas podania zbyt duzego progu, bieli i czerni
  688. Wynik: pozytywny (Komunikat o bledzie asercji)
  689. - przetestowania opcji, ktora nie zostala zdefiniowana w kodzie zrodlowym
  690. Wynik: pozytywny
  691. - przetestowanie zachowania programu podczas braku wartosci progu, czerni i bieli
  692. Wynik: pozytywny (Komunikat o bledzie asercji)
  693.  
  694.  
  695.  
  696.  
  697. Wszystkie testy zakonczyly sie pozytywnie, wiec mozna uznac, ze program dziala poprawnie dla dowolnych danych
  698. wejsciowych.
  699.  
  700.  
  701.  */
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!