1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <conio.h>
5. #define CRT_SECURE_NO_WARNINGS
6.  
7. struct obraz
8. {
9.         char title[50];
10.         char standard;                                                      //deklaruje strukture na zmienne: standard,szerokosc,wysokosc,
11.         int szer;                                                          //skala szarosci, obraz(tablica dwuwymiarowa)
12.         int wys;
13.         int skal_szar;
14.         int **obraz;
15. };
16. void wczytajplik(struct obraz *tablica, int *licznik_obraz);         //wybor pliku, wczytywanie, alokowanie pamieci
17. void bufor();                                                        //funkcja czyszczaca bufor klawiatury
18. void drukujobraz(struct obraz* tablica, int *aktobraz);              //drukowanie obrazu w konsoli
19. void fri(struct obraz* o1);                                          //uwalnianie tablicy dwuwymiarowej
20. void zapiszobraz(struct obraz* tablica, int *aktobraz);
21. struct obraz* usunobraz(struct obraz* tablica, int *aktobraz, int licznik_obraz);
22. struct obraz* realokuj(struct obraz *tablica, int licznik_obraz);
23. void filtr_gaussa(struct obraz* tablica, int aktobraz, int **kopia);
24. void tworz_kopie(struct obraz* tablica, int aktobraz, int **kopia);
25. int main()
26. {
27.         struct obraz *tablica;                                          //tworze wskaznik na tablice struktur
28.         int licznik_obraz = 1, i, **kopia;                                           //licznik_obraz zlicza ile aktualnie w programie jest obrazow
29.         int aktobraz = 0;                                                  //wybiera ktory obraz jest aktywny (domyslnie 0)
30.         char menu;
31.         menu = 'z';
32.         tablica = malloc(1 * sizeof(struct obraz));                          //alokujê tablice na rozmiar 1 struktury
33.         while (menu != 'a')                                                 //petla pozwalajaca na wielokrotne wybieranie funckji z menu
34.         {
35.                 printf("nWybierz jedna opcje z Menuna. Wyjscienb. Dodaj obraznc. Pokaz obraz w konsolind. Lista obrazowne. Zapisz obraz do pliku .pgmnf. Usun aktywny obrazng. Filtr Gaussa");
36.                 while (_kbhit() == 0);                                          //petla oczekujace na wcisniecie przycisku na klawiaturze
37.                 menu = _getch();
38.                 switch (menu)
39.                 {
40.                 case 'a':
41.                         //WYJSCIE, czysci tablice 2-wym, tablice struktur
42.                         if (sizeof(tablica)>20 * sizeof(int))
43.                         {
44.                                 for (i = 0; i<licznik_obraz; i++)
45.                                 {
46.                                         fri(&tablica[i]);
47.                                 }
48.                         }
49.                         free(tablica);
50.                         break;
51.                 case 'b':                                               //wczytaj plik, inkrementuj licznik, realokuj tablice struktur
52.                         wczytajplik(tablica, &licznik_obraz);
53.                         licznik_obraz = licznik_obraz + 1;
54.                         tablica = realokuj(tablica, licznik_obraz);
55.                         break;
56.                 case 'c':
57.                         if (tablica[aktobraz].szer<31 && tablica[aktobraz].wys<31) {
58.                                 drukujobraz(tablica, &aktobraz);                     //wyswietl obraz w konsoli (dla obrazow mniejszych niz 30x30)
59.                         }
60.                         else {
61.                                 printf("nTEN OBRAZ JEST ZA DUZY ABY WYSWIETLIC GO W KONSOLIn");
62.                         }
63.                         break;
64.                 case 'd':
65.                         if (licznik_obraz == 1) {                               //wyswietla liste wczytanych obrazow
66.                                 printf("nNie wczytales jeszcze zadnych obrazow");
67.                         }
68.                         for (i = 1; i<licznik_obraz; i++)
69.                         {
70.                                 printf("nn%d. %s", i, tablica[i - 1].title);
71.                         }
72.                         if (licznik_obraz>1) {
73.                                 do
74.                                 {
75.                                         bufor();
76.                                         printf("nWybierz aktywny obraz:n");
77.                                         scanf("%d", &aktobraz);
78.                                 }                          //pozwala na wybranie aktywnego obrazu (tego ktory bedzie uzyty w nastepnych funkcjach)
79.                                 while (aktobraz >= licznik_obraz || aktobraz <= 0);
80.                         }
81.                         aktobraz--;
82.                         break;
83.                 case'e':
84.                         //funkcja zapisujaca aktywny obraz do pliku
85.                         zapiszobraz(tablica, &aktobraz);
86.                         break;
87.                 case'f':
88.                         usunobraz(tablica, &aktobraz, licznik_obraz);         //usuwam aktywny obraz i dekrementuje licznik obrazow
89.                         licznik_obraz--;
90.  
91.                         break;
92.                 case'g':
93.                         tworz_kopie(tablica, aktobraz, kopia);
94.                         printf("dadadn");
95.                         filtr_gaussa(tablica, aktobraz, kopia);
96.                         break;
97.                 default:
98.                         printf("nNIE MA TAKIEJ OPCJI W MENUn");           //jezeli uzytkownik wcisnal nieodpowiedni klawisz wyswietlam komunikat
99.                         break;
100.  
101.  
102.                 }
103.  
104.         }
105.         system("pause");
106.         return 0;
107. }
108. void bufor()
109. {
110.         int c;
111.         while ((c = getc(stdin)) != 'n'&&c != EOF);                           //czysci bufor klawiatury
112. }
113. void wczytajplik(struct obraz *tablica, int *licznik_obraz)
114. {
115.         char help;                                                      //zmienne pomocnicza do oczytywania z pliku
116.         int helps, i = 0, j = 0, k;
117.         char tytul[50];
118.         printf("nPodaj tytul obrazu: ");                                //wczytuje tytul pliku do otwarcia
119.         scanf("%s", tytul);
120.         strcpy(tablica[*licznik_obraz - 1].title, tytul);
121.         FILE *plik;
122.         plik = fopen(tytul, "r");                                             //otwieram plik
123.         while (plik == NULL)
124.         {
125.                 printf("nNIE MA TAKIEGO PLIKU");                               //zabezpieczenie przed nieotwartym plikiem
126.                 printf("nPodaj tytul obrazu: ");
127.                 scanf("%s", tytul);
128.                 plik = fopen(tytul, "r");
129.         }
130.         fseek(plik, 1, SEEK_SET);
131.         fscanf(plik, "%c", &help);
132.         tablica[*licznik_obraz - 1].standard = help;                             //odczytuje standard pliku
133.         fseek(plik, 1, SEEK_CUR);                                               //poczatek algorytmu obslugi komentarzy
134.         while (getc(plik) == '#')
135.         {
136.                 while (getc(plik) != 'n');
137.         }
138.         fseek(plik, -1, SEEK_CUR);                                       //i jego koniec
139.         fscanf(plik, "%d", &helps);
140.         tablica[*licznik_obraz - 1].wys = helps;
141.         fscanf(plik, "%d", &helps);                                        //odczytuje szerokosc,wysokosc,skale szarosci
142.         tablica[*licznik_obraz - 1].szer = helps;
143.         fseek(plik, 1, SEEK_CUR);                                          //poczatek algorytmu obslugi komentarzy
144.         while (getc(plik) == '#')
145.         {
146.                 while (getc(plik) != 'n');
147.         }
148.         fseek(plik, -1, SEEK_CUR);                                         //i jego koniec
149.         fscanf(plik, "%d", &helps);
150.         tablica[*licznik_obraz - 1].skal_szar = helps;
151.         fseek(plik, 1, SEEK_CUR);                                       //poczatek algorytmu obslugi komentarzy
152.         while (getc(plik) == '#')
153.         {
154.                 while (getc(plik) != 'n');
155.         }
156.         fseek(plik, -1, SEEK_CUR);                                         //i jego koniec
157.         tablica[*licznik_obraz - 1].obraz = malloc((tablica[*licznik_obraz - 1].szer + 1) * sizeof(*tablica[*licznik_obraz - 1].obraz));     //alokuje pamiec na tablice dwu_wym
158.         if (tablica[*licznik_obraz - 1].obraz != NULL)
159.         {
160.                 for (helps = 0; helps<tablica[*licznik_obraz - 1].szer + 1; helps++)
161.                 {
162.                         tablica[*licznik_obraz - 1].obraz[helps] = malloc((tablica[*licznik_obraz - 1].wys + 1) * sizeof(int));
163.                         if (tablica[*licznik_obraz - 1].obraz[helps] == NULL)                                                                 //zabezpieczenie przed wyciekiem pamieci w razie niepoprawnego alokowania
164.                         {
165.                                 printf("nBLAD ALOKACJI PAMIECI DLA TABLICY DWUWYMIAROWEJnSPROBOJ UROCHOMIC PROGRAM PONOWNIE");
166.                                 for (k = 0; k <= helps; k++)
167.                                 {
168.                                         free(tablica[*licznik_obraz - 1].obraz[k]);                 //czyszcze tablice "podrzedne" tablicy dwu_wym
169.                                 }
170.                                 free(tablica[*licznik_obraz - 1].obraz);                    //czyszcze tablice "matke"
171.  
172.                         }
173.                 }
174.         }
175.         else {
176.                 printf("nBLAD ALOKACJI PAMIECI DLA TABLICY DWUWYMIAROWEJnSPROBOJ UROCHOMIC PROGRAM PONOWNIE");
177.         }
178.         while (getc(plik) != EOF)                                         //petla wczytujaca piksele az do konca pliku
179.         {
180.                 fseek(plik, -1, SEEK_CUR);
181.                 if (j == 0)
182.                 {
183.                         if (getc(plik) == '#')                                   //sprawdzenie na poczatku linii nastepuje komentarz
184.                         {
185.                                 while (getc(plik) != 'n');
186.                         }
187.                         else { fseek(plik, -1, SEEK_CUR); }
188.                 }
189.                 fscanf(plik, "%d", &helps);
190.                 fseek(plik, 1, SEEK_CUR);
191.                 tablica[*licznik_obraz - 1].obraz[i][j] = helps;                //wczytuje 'piksele' do tablicy dwu_wym
192.                 j++;
193.                 if (j >= tablica[*licznik_obraz - 1].szer)
194.                 {
195.                         if (i<tablica[*licznik_obraz - 1].wys - 1) {
196.                                 if (getc(plik) == '#')                                      //sprawdzenie czy po koncu linii nastepuje kometarz
197.                                 {
198.                                         while (getc(plik) != 'n');
199.                                 }
200.                                 else { fseek(plik, -1, SEEK_CUR); }
201.  
202.                         }
203.                         j = 0;
204.                         i = i + 1;
205.                 }
206.                 if (i == tablica[*licznik_obraz - 1].wys && j == 0)                 //instrukcja zakonczy petle wczytujaca obraz po osiagnieciu ostatniego piksela
207.                 {
208.                         fseek(plik, -1, SEEK_END);
209.                 }
210.         }
211.         fclose(plik);
212. }
213. void drukujobraz(struct obraz* tablica, int *aktobraz)
214. {
215.         int i, j;
216.         printf("nStandard: P%c", tablica[*aktobraz].standard);
217.         printf("nSzerokosc: %d", tablica[*aktobraz].szer);
218.         printf("nWysokosc: %d", tablica[*aktobraz].wys);               //wypisuje parametry pliku
219.         printf("nSkala szarosci: %dnObraz:n", tablica[*aktobraz].skal_szar);
220.         for (i = 0; i<tablica[*aktobraz].wys; i++)
221.         {
222.                 for (j = 0; j<tablica[*aktobraz].szer; j++)
223.                 {
224.                         printf("%d ", tablica[*aktobraz].obraz[i][j]);          //drukuje piksele obrazu
225.  
226.                 }
227.                 printf("n");
228.         }
229. }
230. void fri(struct obraz* o1)
231. {
232.         int helps;
233.         for (helps = 0; helps<o1->szer + 1; helps++)
234.         {
235.                 free(o1->obraz[helps]);                                      //czyszcze tablice "podrzedne" tablicy dwu_wym
236.         }
237.         free(o1->obraz);                                                   //czyszcze tablice "matke"
238. }
239. struct obraz* realokuj(struct obraz *tablica, int licznik_obraz)
240. {
241.         //realokowanie tablicy o jenda strukture wiecej
242.         struct obraz *temp;
243.  
244. poczatek:
245.  
246.         temp = realloc(tablica, (licznik_obraz + 1) * sizeof(struct obraz));
247.         if (temp != NULL)                                           // sprawdzenie powodzenia realokacji
248.         {
249.                 tablica = temp;
250.         }
251.         else
252.         {
253.                 free(temp);
254.                 goto poczatek;
255.         }
256.         return tablica;                                             //zwracam wskaznik do realokowanej tablicy
257. }
258. void zapiszobraz(struct obraz* tablica, int *aktobraz)
259. {
260.         int i, j;
261.         FILE *plik;
262.         char nazwa[50];
263.         printf("nPodaj nazwe pliku do zapisu (razem z typem np. nazwa.pgm):n");       //pobieram nazwe pliku do zapisu
264.         scanf("%s", nazwa);
265.         plik = fopen(nazwa, "w");
266.         fprintf(plik, "P%cn", tablica[*aktobraz].standard);
267.         fprintf(plik, "%d %dn", tablica[*aktobraz].wys, tablica[*aktobraz].szer);         //zapisuje parametry obrazu do pliku
268.         fprintf(plik, "%dn", tablica[*aktobraz].skal_szar);
269.         for (i = 0; i<tablica[*aktobraz].wys; i++)
270.         {
271.                 for (j = 0; j<tablica[*aktobraz].szer; j++)
272.                 {
273.                         fprintf(plik, "%d", tablica[*aktobraz].obraz[i][j]);                          //zapisuje obraz do pliku
274.                         if (j<tablica[*aktobraz].szer - 1)
275.                         {
276.                                 fprintf(plik, " ");
277.                         }
278.                         if (j == tablica[*aktobraz].szer - 1)
279.                         {
280.                                 fprintf(plik, "n");
281.                         }
282.                 }
283.         }
284.         fclose(plik);
285.         printf("nZapisano plik %s", nazwa);
286. }
287. struct obraz* usunobraz(struct obraz* tablica, int *aktobraz, int licznik_obraz)
288. {
289.         int i = 1;
290.         fri(&tablica[*aktobraz]);                                   //zwalniam tablice dwuwymiarowa obrazu aktywnego
291.         for (i = *aktobraz; i<licznik_obraz; i++)                        //przesuwam 'obrazy' w tablicy struktur
292.         {
293.                 tablica[i] = tablica[i + 1];
294.         }
295.         tablica = realokuj(tablica, licznik_obraz - 1);                    //realokuje tablice struktur po usunieciu obrazu
296.         printf("nUsunieto obraz nr %dnUstawiam wskaznik aktywnego obrazu na 0", *aktobraz + 1);
297.         *aktobraz = 0;
298.         return 0;
299. }
300. void tworz_kopie(struct obraz* tablica, int aktobraz, int **kopia)
301. {
302.         int i, k;
303.         do
304.         {
305.                 kopia = malloc((tablica[aktobraz].szer + 1) * sizeof(int));
306.         } while (kopia == NULL);
307.         for (i = 0; i<tablica[aktobraz].szer + 1; i++)
308.         {
309.                 kopia[i] = malloc((tablica[aktobraz].wys + 1 * sizeof(int)));
310.                 if (kopia[i] == NULL)
311.                 {
312.                         printf("nBlad alokacji pamieci na kopie obrazu - sproboj uruchomic program ponownie");
313.                 }
314.         }
315.         for (i = 0; i<tablica[aktobraz].wys; i++)
316.         {
317.                 for (k = 0; k<tablica[aktobraz].szer; k++)
318.                 {
319.                         kopia[i][k] = tablica[aktobraz].obraz[i][k];
320.                 }
321.         }
322. }
323. void filtr_gaussa(struct obraz* tablica, int aktobraz, int **kopia)
324. {
325.         int x = 1, y, i = 0, piksel = 0;
326.         printf("nPodaj czy filtr Gaussa ma byc dodatni czy ujemny (1 albo 2):n1. Dodatnin2.Ujemnyn");
327.         while (i != 1 && i != 2)
328.         {
329.                 bufor();
330.                 scanf("%d", &i);
331.         }
332.         while (x<tablica[aktobraz].wys - 1)
333.         {
334.                 y = 1;
335.                 while (y<tablica[aktobraz].szer - 1)
336.                 {
337.                         if (i == 1) {
338.                                 piksel = kopia[x - 1][y - 1] + kopia[x - 1][y] * 2 + kopia[x - 1][y + 1] + kopia[x][y - 1] * 2 + kopia[x][y] * 4 + kopia[x][y + 1] * 2;
339.                                 piksel = piksel + kopia[x + 1][y - 1] + kopia[x + 1][y] * 2 + kopia[x + 1][y + 1];
340.                                 piksel = piksel / 16;
341.                                 tablica[aktobraz].obraz[x][y] = piksel;
342.                         }
343.                         if (i == 2)
344.                         {
345.                                 piksel = kopia[x - 1][y] * (-1) + kopia[x][y - 1] * (-1) + kopia[x][y] * 5 + kopia[x][y + 1] * (-1) + kopia[x + 1][y] * (-1);
346.                                 tablica[aktobraz].obraz[x][y] = piksel;
347.                         }
348.                         y++;
349.                 }
350.                 x++;
351.         }
352.  
353.  
354. }
355.