#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include <stdlib.h>
#include<windows.h>
#include <math.h>
#include <time.h>
#include <string.h>


struct obraz
{
	char *nazwa_pliku;
	char *typ_obrazu;
	int szerokosc;
	int wysokosc;
	int max_wart_szar;
	int **piksele;
};

void odczyt_pliku_do_struktury(struct obraz *biblioteka_obrazow, int wielkosc_biblioteki_obrazow, int *flaga_zaladowania_obrazu);
void sprawdz_komentarz(FILE *plik);
struct obraz* dodawanie_obrazu_do_biblioteki(struct obraz *biblioteka_obrazow, int *wielkosc_biblioteki_obrazow, int *flaga_zaladowania_do_biblioteki_wew);
struct obraz* usuwanie_obrazu_z_biblioteki(struct obraz *biblioteka_obrazow, int *wielkosc_biblioteki_obrazow, int numer_edytowanego_obrazu, int *flaga_usuniecia_obrazu_wew);
void zapis_do_pliku(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_zapisu);

void progowanie(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu);
void negatyw(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu);
void obrot_90(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_edycji);
void odbicie_wzgl_osi_pionowej(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu);
void odbicie_wzgl_osi_poziomej(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu);
void histogram(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu);
void szum_pieprz_sol(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu);
void filtr_medianowy(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_filtru);
void filtr_Gaussa(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_filtru);

void sortowanie(int *tablica_sortowanie);


// system( "cls" );

int main()
{
	int i;
	int j;

	int wybor_akcji;
	int bufor;
	int numer_edytowanego_obrazu;
	int wybor_narzedzia;
	//int bufor1;


	int wielkosc_biblioteki_obrazow = 1;

	int flaga_zaladowania_obrazu = 1;
	int flaga_zaladowania_do_biblioteki_wew = 1;
	int flaga_zaladowania_do_biblioteki = 1;
	int flaga_wyboru_obrazu = 1;
	int flaga_usuniecia_obrazu_wew = 1;
	int flaga_usuniecia_obrazu = 1;
	int flaga_zapisu = 1;
	int flaga_edycji = 1;
	int flaga_filtru = 1;
	// flaga = 0, dobrze     flaga = 1, zle

	struct obraz *biblioteka_obrazow = NULL;
	biblioteka_obrazow = malloc(wielkosc_biblioteki_obrazow * sizeof(struct obraz));

	/*printf("\n MENU\n");
	printf("Twoje opcje to:\n");
	printf("1. Zaladowanie obraz z pliku.\n");
	printf("2. Wyswietlenie biblioteki obrazow.\n");
	printf("3. Wybor aktywnego obrazu.\n");
	printf("4. Zapis aktywnego obrazu do pliku.\n");
	printf("5. Usuwanie aktywnego obrazu z biblioteki.\n");
	printf("6. Narzedzia edycji.\n");
	printf("0. Wyjscie z programu.\n");*/


	while (1)
	{

		printf("\n MENU\n");
		printf("Twoje opcje to:\n");
		printf("1. Zaladowanie obraz z pliku.\n");
		printf("2. Wyswietlenie biblioteki obrazow.\n");
		printf("3. Wybor aktywnego obrazu.\n");
		printf("4. Zapis aktywnego obrazu do pliku.\n");
		printf("5. Usuwanie aktywnego obrazu z biblioteki.\n");
		printf("6. Narzedzia edycji.\n");
		printf("0. Wyjscie z programu.\n");



		printf("\nWybierz ktoras z opcji z menu:\n");
		do
		{
			while (scanf("%d", &wybor_akcji) == 0)
			{
				printf("BLAD, podales zly typ zmiennej, sproboj jeszcze raz wybrac dobra opcje z menu.\n");
				while ((bufor = getchar()) != '\n');
			}
			while ((bufor = getchar()) != '\n');

			if (wybor_akcji < 0 || wybor_akcji > 6)
			{
				printf("BLAD - nie ma takiej opcji. Wybierz jeszcze raz.\n");
			}
		} while (wybor_akcji < 0 || wybor_akcji > 6);



		switch (wybor_akcji)
		{
		case 1: // CASE 1 dodawanie obrazow do biblioteki

			odczyt_pliku_do_struktury(biblioteka_obrazow, wielkosc_biblioteki_obrazow, &flaga_zaladowania_obrazu);

			if (flaga_zaladowania_obrazu == 0)
			{
				printf("Wybrany obraz zostal pozytywnie zaladowany.\n");
				biblioteka_obrazow = dodawanie_obrazu_do_biblioteki(biblioteka_obrazow, &wielkosc_biblioteki_obrazow, &flaga_zaladowania_do_biblioteki_wew);

				if (flaga_zaladowania_do_biblioteki_wew == 0)  // flaga_zaladowania_do_biblioteki
				{
					printf("Wybrany obraz zostal pozytywnie dodany do bilioteki.\n");
					flaga_zaladowania_do_biblioteki = 0;
					wielkosc_biblioteki_obrazow++;

				}
				else// (flaga_zaladowania_do_biblioteki == 1)
				{
					printf("Nie udalo sie dodac obrazu do biblioteki.\n");
					//flaga_zaladowania_do_biblioteki = 0;
					break;
				}
			}
			else// (flaga_zaladowania_obrazu == 1)
			{
				printf("Nie zaladowano obrazu.\n");
			}
			break;

		case 2: //  CASE 2 wyswietlanie bilioteki

			if (flaga_zaladowania_do_biblioteki == 0) // obraz dodany
			{
				for (i = 0; i < wielkosc_biblioteki_obrazow - 1; i++)
				{
					printf("\n%d ELEMENT BIBLIOTEKI OBRAZOW: %s\n", i + 1, biblioteka_obrazow[i].nazwa_pliku);
				}
			}
			else // flaga = 1, brak obrazu w bibliotece
			{
				printf("Biblioteka obrazow jest pusta.\n");
			}

			break;

		case 3: // CASE 3 wybor obrazu

			if (flaga_zaladowania_do_biblioteki == 0) // obraz dodany
			{
				printf("\nObrazy dostepne w bibliotece:\n");
				for (i = 0; i < wielkosc_biblioteki_obrazow - 1; i++)
				{
					printf("\n%d.%s\n", i + 1, biblioteka_obrazow[i].nazwa_pliku);
				}

				printf("\nPodaj numer obrazu ktory chcesz edytowac.\n");
				do
				{
					while (scanf("%d", &numer_edytowanego_obrazu) == 0)
					{
						printf("BLAD, bledny typ danych.");
						while ((bufor = getchar()) != '\n');
					}
					while ((bufor = getchar()) != '\n');

					if (numer_edytowanego_obrazu < 1 || numer_edytowanego_obrazu > wielkosc_biblioteki_obrazow - 1)
					{
						printf("BLAD - nie ma takiego obrazu. Wybierz jeszcze raz. ");      /// wcisniecie 0 spowoduje powrot do menu glownego
					}

				} while (numer_edytowanego_obrazu < 0 || numer_edytowanego_obrazu > wielkosc_biblioteki_obrazow - 1);

				flaga_wyboru_obrazu = 0;
				printf("\nPracujesz na obrazie numer %d o nazwie %s.\n", numer_edytowanego_obrazu, biblioteka_obrazow[numer_edytowanego_obrazu - 1].nazwa_pliku);



			}
			else // flaga = 1, brak obrazu w bibliotece
			{
				printf("Biblioteka obrazow jest pusta.\n");
				flaga_wyboru_obrazu = 1;
			}

			break;

		case 4:// ZAPIS

			if (flaga_zaladowania_do_biblioteki == 0)
			{
				if (flaga_wyboru_obrazu == 0)
				{
					zapis_do_pliku(biblioteka_obrazow, numer_edytowanego_obrazu, &flaga_zapisu);
					if (flaga_zapisu == 0)
					{
						printf("Obraz zostal pozytywnie zapisany.\n");
					}
				}
				else
				{
					printf("Nie wybrano aktywnego obrazu!\n");
				}
			}
			else
			{
				printf("Biblioteka obrazow jest pusta.\n");
			}

			break;

		case 5: // CASE 4 usuwanie obrazu

			if (flaga_zaladowania_do_biblioteki == 0) // gdy biblioteka ma obraz
			{
				if (flaga_wyboru_obrazu == 0) // gdy wybralismy obraz
				{
					biblioteka_obrazow = usuwanie_obrazu_z_biblioteki(biblioteka_obrazow, &wielkosc_biblioteki_obrazow, numer_edytowanego_obrazu, &flaga_usuniecia_obrazu_wew);
					if (flaga_usuniecia_obrazu_wew == 0)
					{
						printf("Obraz zostal pomyslnie usuniety.\n");
						flaga_usuniecia_obrazu = 0;
						flaga_wyboru_obrazu = 1;
						wielkosc_biblioteki_obrazow--;

						if (wielkosc_biblioteki_obrazow == 1)             // gdy mamy 1 obraz, wielksoc biblioteki to 2 -> jedna komorka zapelniona, jedna pusta ;
						{                                                 // usuniecie obrazu spowoduje zmniejszenie rozmiaru do 1; w bibliotece nie bedzie obrazow, nie bedzie tez zaladowanego obrazu
							flaga_zaladowania_do_biblioteki = 1;
							flaga_zaladowania_obrazu = 1;
						}
					}
					else // flaga = 1
					{
						printf("Nie udalo sie usunac obrazu.\n");
						flaga_usuniecia_obrazu = 1;
					}
				}
				else // flaga = 1
				{
					printf("Nie wybrano aktywnego obrazu!\n");
				}
			}
			else // flaga = 1
			{
				printf("Biblioteka obrazow jest pusta.\n");
			}

			printf(" \nWielkosc biblioteki obrazow: %d.\n", wielkosc_biblioteki_obrazow);
			break;

		case 6: // CASE 5 edycja obrazu

				/*printf("\n Edycja aktywnego obrazu.\n");
				printf("1. Progowanie.\n");
				printf("2. Negatyw.\n");
				printf("3. Odbicie o kat 90 stopni.\n");
				printf("4. Odbicie wzgledem osi pionowej.\n");
				printf("5. Odbicie wzgledem osi poziomej.\n");
				printf("6. Histogram.\n");
				printf("7. Szum pieprz i sol.\n");
				printf("8. Filtr Gaussa.\n");
				printf("9. Filtr medianowy.\n");
				printf("10. Wyjscie z edytora obrazow/Powrot do menu glownego.\n");*/

			do // petla wyboru opcji z menu
			{

				printf("\n Edycja aktywnego obrazu.\n");
				printf("1. Progowanie.\n");
				printf("2. Negatyw.\n");
				printf("3. Odbicie o kat 90 stopni.\n");
				printf("4. Odbicie wzgledem osi pionowej.\n");
				printf("5. Odbicie wzgledem osi poziomej.\n");
				printf("6. Histogram.\n");
				printf("7. Szum pieprz i sol.\n");
				printf("8. Filtr Gaussa.\n");
				printf("9. Filtr medianowy.\n");
				printf("10. Wyjscie z edytora obrazow/Powrot do menu glownego.\n");

				printf("\nWybierz ktores z narzedzi lub wcisnij 10 aby wrocic do menu glownego:\n");

				do
				{
					while (scanf("%d", &wybor_narzedzia) == 0)
					{
						printf("BLAD, podales zly typ zmiennej.\n");
						while ((bufor = getchar()) != '\n');
					}
					while ((bufor = getchar()) != '\n'); // w razie gdy podamy 5__6

					if (wybor_narzedzia < 1 || wybor_narzedzia > 10)
					{
						printf("BLAD - nie ma takiej opcji. Wybierz jeszcze raz.");
					}
				} while (wybor_narzedzia < 1 || wybor_narzedzia > 10);


				switch (wybor_narzedzia) // kolejne narzedzia
				{
				case 1: // PROGOWANIE

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							progowanie(biblioteka_obrazow, numer_edytowanego_obrazu);
							printf("Zastosowano progowanie.\n");
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}

					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 2: // NEGATYW

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							negatyw(biblioteka_obrazow, numer_edytowanego_obrazu);
							printf("Zastosowano negatyw.\n");
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 3: // 90 STOPNI

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							obrot_90(biblioteka_obrazow, numer_edytowanego_obrazu, &flaga_edycji);

							if (flaga_edycji == 0)
							{
								printf("Zastosowano obrot o kat 90 stopni.\n");

								/*// zamieniamy wartosci szerokosci i wysokosci
								bufor1 = biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc;
								biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc = biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc;
								biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc = bufor1;*/

							}
							else //flaga_edycji = 1
							{
								printf("Nie zastosowano obrot o kat 90 stopni.\n");
							}
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 4: // OS PIONOWA

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							odbicie_wzgl_osi_pionowej(biblioteka_obrazow, numer_edytowanego_obrazu);
							printf("Zastosowano obrot wokol osi pionowej.\n");
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 5: // OS POZIOMA

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{


							odbicie_wzgl_osi_poziomej(biblioteka_obrazow, numer_edytowanego_obrazu);
							printf("Zastosowano obrot wokol osi poziomej.\n");
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 6: //HISTOGRAM

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							histogram(biblioteka_obrazow, numer_edytowanego_obrazu);
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 7: // PIEPRZ I SOL

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							szum_pieprz_sol(biblioteka_obrazow, numer_edytowanego_obrazu);
							printf("Obraz zastal zaszumiony.\n");
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 8: // GAUSS

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							filtr_Gaussa(biblioteka_obrazow, numer_edytowanego_obrazu, &flaga_filtru);
							if (flaga_filtru == 0)
							{
								printf("Odfiltrowano obraz.\n");
							}
							else // flaga_filtru = 1
							{
								printf("Nie udalo sie odfiltrowac obrazu.\n");
							}
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				case 9: // MEDIANA

					if (flaga_zaladowania_do_biblioteki == 0)
					{
						if (flaga_wyboru_obrazu == 0)
						{
							filtr_medianowy(biblioteka_obrazow, numer_edytowanego_obrazu, &flaga_filtru);
							if (flaga_filtru == 0)
							{
								printf("Odfiltrowano obraz.\n");
							}
							else // flaga_filtru = 1
							{
								printf("Nie udalo sie odfiltrowac obrazu.\n");
							}
						}
						else
						{
							printf("Nie wybrano aktywnego obrazu!\n");
						}
					}
					else
					{
						printf("Biblioteka obrazow jest pusta.\n");
					}

					break;

				default:
					if (wybor_narzedzia != 10)
						printf("Nie wybrales zadnej opcji!\n");
					break;


				}//koniec switcha narzedzi

			} while (wybor_narzedzia != 10);

			break; // koniec  case'a edycji


		default:
			printf("Nie wybrales zadnej opcji!\n");
			break;

		case 0: // CASE 0 wyjscie z programu

			for (i = 0; i < wielkosc_biblioteki_obrazow; i++)
			{
				biblioteka_obrazow[i].nazwa_pliku = NULL;
				biblioteka_obrazow[i].typ_obrazu = NULL;

				free(biblioteka_obrazow[i].nazwa_pliku);
				free(biblioteka_obrazow[i].typ_obrazu);

				for (j = 0; j < biblioteka_obrazow[i].wysokosc; j++)
				{
					free(biblioteka_obrazow[i].piksele[j]);   // breakpoint
				}
				biblioteka_obrazow[i].piksele = NULL;
				free(biblioteka_obrazow[i].piksele);
			}
			free(biblioteka_obrazow);

			exit(10);
			break;



		}// koniec switch-menu
	}// koniec while-menu
}// koniec main

void odczyt_pliku_do_struktury(struct obraz *biblioteka_obrazow, int wielkosc_biblioteki_obrazow, int *flaga_zaladowania_obrazu) // str_obraz
{
	int flagaBledu = 0;
	int flagaBledu1 = 0;

	int i, j;
	FILE *plik;

	biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].nazwa_pliku = malloc(100 * sizeof(char));
	biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].typ_obrazu = malloc(2 * sizeof(char));


	printf("Podaj nazwe pliku razem z rozszerzeniem.\n");
	scanf("%s", biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].nazwa_pliku);

	plik = fopen(biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].nazwa_pliku, "r"); // .pgm

	if (fopen(biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].nazwa_pliku, "r") == NULL)
	{
		*flaga_zaladowania_obrazu = 1;
		fflush(stdin);
	}
	else
	{
		sprawdz_komentarz(plik);
		fscanf(plik, "%c%c ", &biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].typ_obrazu[0], &biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].typ_obrazu[1]);

		sprawdz_komentarz(plik);
		fscanf(plik, "%d", &biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].szerokosc);

		sprawdz_komentarz(plik);
		fscanf(plik, "%d", &biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].wysokosc);

		sprawdz_komentarz(plik);
		fscanf(plik, "%d", &biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].max_wart_szar);


		biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].piksele = malloc(biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].wysokosc * sizeof(int*));

		if (biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].piksele != NULL)
		{
			for (i = 0; i < biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].wysokosc; i++)
			{
				biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].piksele[i] = malloc(biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].szerokosc * sizeof(int));

				if (biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].piksele[i] != NULL)
				{
					flagaBledu1 = 0;
				}
				else
				{
					flagaBledu1 = 1;
					printf("BLAD w tworzeniu pikseli w wierszu!\n");
					break;
				}
			}

			if (flagaBledu1)
			{
				for (j = 0; j <= i; j++)
				{
					free(biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].piksele[j]);
				}

				free(biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].piksele);

			}
		}
		else
		{
			printf("BLAD w tworzeniu pikseli w kolumnie!\n");
			flagaBledu = 1;
		}
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////


		if (flagaBledu == 0 || flagaBledu1 == 0)
		{
			sprawdz_komentarz(plik);

			for (i = 0; i < biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].wysokosc; i++)
			{
				for (j = 0; j < biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].szerokosc; j++)
				{
					sprawdz_komentarz(plik);
					fscanf(plik, "%d", &biblioteka_obrazow[wielkosc_biblioteki_obrazow - 1].piksele[i][j]);
				}
			}
			*flaga_zaladowania_obrazu = 0;
			fclose(plik);
		}
		else
		{
			printf("Nie zaladowano obrazu.\n");
			*flaga_zaladowania_obrazu = 1;
			fclose(plik);
		}
	}
	system("cls");
}

void sprawdz_komentarz(FILE *plik)
{
	char znak;
	fscanf(plik, "%c", &znak);


	while (znak == '#')
	{
		while (znak != '\n')
		{
			fscanf(plik, "%c", &znak);
		}

		fscanf(plik, "%c", &znak);
	}
	fseek(plik, -1, SEEK_CUR);

}

struct obraz* dodawanie_obrazu_do_biblioteki(struct obraz *biblioteka_obrazow, int *wielkosc_biblioteki_obrazow, int *flaga_zaladowania_do_biblioteki_wew)
{
	struct obraz *biblioteka_tymczasowa = NULL;
	biblioteka_tymczasowa = realloc(biblioteka_obrazow, (*wielkosc_biblioteki_obrazow + 1) * sizeof(struct obraz));

	if (biblioteka_tymczasowa != NULL)
	{
		biblioteka_obrazow = biblioteka_tymczasowa;
		*flaga_zaladowania_do_biblioteki_wew = 0;
		//*wielkosc_biblioteki_obrazow++;
	}
	else
	{
		*flaga_zaladowania_do_biblioteki_wew = 1;
	}
	/// czy tutaj jest ok BO tutaj powiekszamy tylko rozmiar tablicy, obraz zostal juz dodany w funkcji odczytu z pliku i jest na wolnym miejscu; return bibliotek zawsze czy tylko gdy sie udalo?
	return biblioteka_obrazow;
	system("cls");
}

struct obraz* usuwanie_obrazu_z_biblioteki(struct obraz *biblioteka_obrazow, int *wielkosc_biblioteki_obrazow, int numer_edytowanego_obrazu, int *flaga_usuniecia_obrazu_wew)
{

	int i;
	int j;

	struct obraz *biblioteka_tymczasowa = NULL;

	// czyscimy wszystko co zalokowane dynamicznie w danej strukturze
	free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].nazwa_pliku);
	free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].typ_obrazu);

	for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; j++)
	{
		free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[j]);
	}
	free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele);

	// nadpisujemy usuwana strukture kolejna
	for (i = (numer_edytowanego_obrazu - 1); i < (*wielkosc_biblioteki_obrazow); i++)
	{
		biblioteka_obrazow[i] = biblioteka_obrazow[i + 1];
	}


	// realokujemy pamiec biblioteki na o 1 mniejsza
	biblioteka_tymczasowa = realloc(biblioteka_obrazow, (*wielkosc_biblioteki_obrazow - 1) * sizeof(struct obraz));
	if (biblioteka_tymczasowa != NULL)
	{
		// czy tu tez nie powinno sie zwalnaic (free) ktorejs tablicy ?
		biblioteka_obrazow = biblioteka_tymczasowa;
		*flaga_usuniecia_obrazu_wew = 0;
	}
	else
	{
		printf("Realokacja zakonczona niepowodzeniem.\n");
		*flaga_usuniecia_obrazu_wew = 1;
		free(biblioteka_tymczasowa);
	}
	// czy tu zwracamy biblioteke zawsze nawet jak sienie udala realokacja pamieci?
	// wielkosc_biblioteki_obrazow nigdy nie bd mniejsza niz 1
	//*wielkosc_biblioteki_obrazow--;
	return biblioteka_obrazow;
	system("cls");
}

void zapis_do_pliku(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_zapisu)
{
	FILE *plik;

	int bufor;
	int k, j;
	char nazwa[20];
	*flaga_zapisu = 1;

	printf("Podaj nazwe pliku do ktorego chcesz zapisac obraz razem z rozszerzeniem.\n");

	while (scanf("%s", &nazwa) == 0)
	{
		printf("BLAD, podales zly typ zmiennej.\n");
		while ((bufor = getchar()) != '\n');
	}
	while ((bufor = getchar()) != '\n');


	plik = fopen(nazwa, "w");

	if (fopen(nazwa, "w") == NULL)
	{
		printf("Nie udalo sie otworzyc pliku!\n");
	}
	else
	{
		fprintf(plik, "%c%c\n", biblioteka_obrazow[numer_edytowanego_obrazu - 1].typ_obrazu[0], biblioteka_obrazow[numer_edytowanego_obrazu - 1].typ_obrazu[1]);
		fprintf(plik, "%d %d\n", biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc, biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc);
		fprintf(plik, "%d\n", biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar);



		for (k = 0; k < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; k++)
		{
			for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
			{
				fprintf(plik, "%d ", biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[k][j]);
				fprintf(plik, "\n");
			}
		}
		fprintf(plik, "\n");
		*flaga_zapisu = 0;
	}
	fclose(plik);
	system("cls");
}


void progowanie(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu)
{
	int i, j;
	int prog;
	int bufor;
	printf("Maksymalny zakres szarosci obrazu: %d.", biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar);

	printf("Podaj prog podzialu obrazu.\n");

	do
	{
		while (scanf("%d", &prog) == 0)
		{
			printf("BLAD, podales zly typ zmiennej, sproboj jeszcze raz.\n");
			while ((bufor = getchar()) != '\n');
		}
		while ((bufor = getchar()) != '\n');

		if (prog < 0 || prog > biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar)
		{
			printf("BLAD - podales zla liczbe. Wybierz jeszcze raz.");
		}
	} while (prog < 0 || prog > biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar);


	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
		{
			if (biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j] < prog)
			{
				biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j] = 0;
			}
			else
			{
				biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar;
			}
		}
	}
	system("cls");
}

void negatyw(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu)
{
	int i, j;
	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
		{
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar - biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j];
		}
	}
	system("cls");
}

void obrot_90(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_edycji)
{
	int i, j, k;
	int flagaBledu = 0;
	int flagaBledu1 = 0;
	int **tablica_tymczasowa;

	int bufor;
	*flaga_edycji = 1;

	tablica_tymczasowa = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc * sizeof(*tablica_tymczasowa));

	if (tablica_tymczasowa != NULL)
	{
		for (k = 0; k < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; k++)
		{
			tablica_tymczasowa[k] = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc * sizeof(int));
			if (tablica_tymczasowa[k] == NULL)
			{
				flagaBledu = 1;
				printf("BLAD w tworzeniu pamieci!\n");
				break;
			}
		}
		if (flagaBledu)
		{
			for (j = 0; j <= k; j++)
			{
				free(tablica_tymczasowa[j]);
			}

			free(tablica_tymczasowa);
		}
	}
	else
	{
		printf("Blad w tworzeniu pamieci!\n");
		flagaBledu = 1;
	}

	// napelniamy tymczasowa pikselami
	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; i++)
	{
		for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; j++)
		{
			tablica_tymczasowa[j][i] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[j][i];
		}
	}

	// czyscimy piksele
	for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; j++)
	{
		free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[j]);
	}
	free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele);


	// zamieniamy wartosci szerokosci i wysokosci
	bufor = biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc;
	biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc = biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc;
	biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc = bufor;
	// wysokosc to szerokosc !!!!
	// szerokosc t owysokosc !!!!


	// zmienamy rozmiary tablicy pikseli
	biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc * sizeof(*(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele)));
	if (biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele != NULL)
	{
		for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
		{
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i] = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc * sizeof(**(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele)));

			if (biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i] == NULL)
			{
				printf("Nie udalo sie zaalokowac pamieci w wierszu.\n");
				flagaBledu1 = 1;
				break;
			}
		}
		if (flagaBledu1)
		{
			for (j = 0; j <= k; j++)
			{
				free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[j]);
			}

			free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele);
		}
	}
	else
	{
		printf("Nie udalo sie zaalokowac pamieci w kolumnie.\n");
		flagaBledu1 = 1;
	}

	// przepisujemy piksele z tymczasowej do noweych pikseli
	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; i++)
	{
		for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; j++)
		{
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[j][i] = tablica_tymczasowa[i][j];
		}
	}


	// szyscimy tablice tymczasowa
	for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
	{
		free(tablica_tymczasowa[j]);
	}
	free(tablica_tymczasowa);

	if (flagaBledu != 1 || flagaBledu1 != 1)
	{
		*flaga_edycji = 0;
	}

	system("cls");
}

void odbicie_wzgl_osi_pionowej(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu)
{
	int i, j;
	int bufor;

	for (i = 0; i < (int)biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		for (j = 0; j < (int)(biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc / 2); j++)
		{
			bufor = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j];
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][(biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc - 1) - j];
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][(biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc - 1) - j] = bufor;

		}
	}
	system("cls");
}

void odbicie_wzgl_osi_poziomej(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu)
{
	int i, j;
	int bufor;

	for (i = 0; i < (int)(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc / 2); i++)
	{
		for (j = 0; j < (int)biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
		{

			bufor = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j];  // breakpoint
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc - 1) - j];
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc - 1) - j] = bufor;

			/*
			bufor = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j];  // breakpoint
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc - 1) - j];
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc - 1) - j] = bufor;*/

		}
	}
	system("cls");
}

void histogram(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu)
{
	int i, j;
	int *tablica_histogram;
	int wielkosc_tablicy = biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar + 1;

	tablica_histogram = calloc(wielkosc_tablicy, sizeof(int)); // calloc napelani tablice 0, tablica jednowymiarowa o ilosci komorek odp. ilosci rodzajow pikseli

	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
		{
			tablica_histogram[biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j]]++;  // nr. kom histogramu rowny aktualnej wartosci jest inkrementowany
		}
	}

	FILE *plik;
	plik = fopen("histogram.csv", "w");
	if ("histogram.csv" != NULL)
	{
		for (i = 0; i < wielkosc_tablicy; i++)
		{
			fprintf(plik, "%d;%d \n", i, tablica_histogram[i]);
		}
		fclose(plik);
		system("cls");
		printf("Hisogram zostal zapisany do pliku histogram.csv\n");
	}
	else
	{
		system("cls");
		printf("Blad - nie udalo sie utworzyc pliku.\n");
	}
	free(tablica_histogram);

}

void szum_pieprz_sol(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu)
{
	srand((unsigned int)time(NULL));

	int i;
	int poz_wysokosc, poz_szerokosc;
	int ilosc_pikseli;
	int ilosc_zaszumionych_pikseli;
	int kolor;
	//int procent;
	//int bufor;

	/*printf("Podaj jaki procent wszystkich pikseli chcesz zaszumic.\n");

	do
	{
	while (scanf("%d", &procent) == 0)
	{
	printf("BLAD, podales zly typ zmiennej, sproboj jeszcze raz.\n");
	while ((bufor = getchar()) != '\n');
	}
	while ((bufor = getchar()) != '\n');

	if (procent < 0 || procent > 100)
	{
	printf("BLAD - podales za duza liczbe.");
	}
	} while (procent < 0 || procent > 100);*/


	ilosc_pikseli = biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc * biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc;
	ilosc_zaszumionych_pikseli = (rand() % ilosc_pikseli) + 10000; // nie wiecej niz jest ich w sumie
																   //ilosc_zaszumionych_pikseli = ilosc_pikseli * (procent/100);

	for (i = 0; i < ilosc_zaszumionych_pikseli; i++)
	{
		poz_wysokosc = (rand() % biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc);
		poz_szerokosc = (rand() % biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc);
		kolor = (rand() % 2);

		if (kolor == 0)
		{
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[poz_wysokosc][poz_szerokosc] = 0;
		}
		else
		{
			biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[poz_wysokosc][poz_szerokosc] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].max_wart_szar;
		}

	}
	system("cls");
}

void filtr_medianowy(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_filtru)
{
	int i, j, r, s;
	int m, n;
	int flagaBledu = 0;
	int flagaBledu1 = 0;
	int licznik = 0;
	int temp;

	*flaga_filtru = 1;

	int tablica_sortowanie[9];


	int **tablica_tymczasowa;

	tablica_tymczasowa = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc * sizeof(*biblioteka_obrazow)); // tymczasowa przyjmuje rozmiar pikseli

	if (tablica_tymczasowa != NULL)
	{
		for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
		{
			tablica_tymczasowa[i] = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc * sizeof(biblioteka_obrazow));

			if (tablica_tymczasowa[i] == NULL)
			{
				flagaBledu = 1;
				printf("BLAD w tworzeniu pikseli w wierszu!\n");
				break;
			}

		}
		if (flagaBledu)
		{
			for (j = 0; j <= i; j++)
			{
				free(tablica_tymczasowa[j]);
			}

			free(tablica_tymczasowa);

		}
	}
	else
	{
		printf("BLAD w tworzeniu pikseli w kolumnie!\n");
		flagaBledu1 = 1;
	}

	// przypisujemy do tablicy tymczasowej tablice pikseli -- nie mozna przejsciowa = biblioteka?
	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
		{
			tablica_tymczasowa[i][j] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j];
		}
	}



	// napelnianie tablicy sortujacej i przypisanie mediany do tablicy tymczasowej
	for (i = 1; i < (biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc - 2); i++)
	{
		for (j = 1; j < (biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc - 2); j++)
		{

			licznik = 0;
			for (r = (i - 1); r < (i + 1); r++) // napelnianie tablicy sortujacej pikselami z wedrujacego okna 3x3
			{
				for (s = (j - 1); s < (j + 1); s++)
				{
					tablica_sortowanie[licznik] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[r][s];
					licznik++;
				}
			}

			//sortowanie(*tablica_sortowanie);

			for (m = 0; m < 9; m++)  // sortowanie babelkowe tablicy sortowania
			{
				for (n = m; n < 8; n++)
				{
					if (tablica_sortowanie[n] > tablica_sortowanie[n + 1])
					{
						temp = tablica_sortowanie[n];
						tablica_sortowanie[n] = tablica_sortowanie[n + 1];
						tablica_sortowanie[n + 1] = temp;
					}
				}
			}

			tablica_tymczasowa[i][j] = tablica_sortowanie[4];


		}
	}

	//czyscimy piksele
	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i]);
	}
	free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele);


	biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele = tablica_tymczasowa;


	if (flagaBledu != 1 || flagaBledu1 != 1)
	{
		*flaga_filtru = 0;
	}
	system("cls");
}

void filtr_Gaussa(struct obraz *biblioteka_obrazow, int numer_edytowanego_obrazu, int *flaga_filtru)

{
	int i, j, r, s, m;
	int flagaBledu = 0;
	int flagaBledu1 = 0;
	int suma_wag = 0;
	int licznik = 0;
	int suma = 0;

	*flaga_filtru = 1;

	int tablica_wag[9];
	tablica_wag[0] = 1;
	tablica_wag[1] = 2;
	tablica_wag[2] = 1;
	tablica_wag[3] = 2;
	tablica_wag[4] = 4;
	tablica_wag[5] = 2;
	tablica_wag[6] = 1;
	tablica_wag[7] = 2;
	tablica_wag[8] = 1;

	int tablica_piksele[9];

	int **tablica_tymczasowa;

	tablica_tymczasowa = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc * sizeof(*biblioteka_obrazow)); // tymczasowa przyjmuje rozmiar pikseli

	if (tablica_tymczasowa != NULL)
	{
		for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
		{
			tablica_tymczasowa[i] = malloc(biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc * sizeof(biblioteka_obrazow));

			if (tablica_tymczasowa[i] == NULL)
			{
				flagaBledu = 1;
				printf("BLAD w tworzeniu pikseli w wierszu!\n");
				break;
			}
		}
		if (flagaBledu)
		{
			for (j = 0; j <= i; j++)
			{
				free(tablica_tymczasowa[j]);
			}

			free(tablica_tymczasowa);
		}
	}
	else
	{
		printf("BLAD w tworzeniu pikseli w kolumnie!\n");
		flagaBledu1 = 1;
	}


	for (i = 0; i < 9; i++)      // liczmy sume wag
	{
		suma_wag = suma_wag + tablica_wag[i];
	}


	// przypisujemy do tablicy tymczasowej tablice pikseli -- nie mozna przejsciowa = biblioteka?
	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		for (j = 0; j < biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc; j++)
		{
			tablica_tymczasowa[i][j] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i][j];
		}
	}




	for (i = 0; i < (biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc - 2); i++)
	{
		for (j = 0; j < (biblioteka_obrazow[numer_edytowanego_obrazu - 1].szerokosc - 2); j++)
		{

			licznik = 0;
			for (r = i; r < (i + 3); r++) // napelnianie tablicy pikselami z wedrujacego okna 3x3
			{
				for (s = j; s < (j + 3); s++)
				{
					tablica_piksele[licznik] = biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[r][s];
					licznik++;
				}
			}


			for (m = 0; m < 9; m++)            // mnozymy dany piksel z tablicy pikseli przez odpowiadajaca mu wage i sumujemy
			{
				suma = (tablica_piksele[m] * tablica_wag[m]);
			}

			tablica_tymczasowa[i + 1][j + 1] = suma / suma_wag;

		}
	}


	//czyscimy piksele
	for (i = 0; i < biblioteka_obrazow[numer_edytowanego_obrazu - 1].wysokosc; i++)
	{
		free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele[i]);
	}
	free(biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele);



	biblioteka_obrazow[numer_edytowanego_obrazu - 1].piksele = tablica_tymczasowa;

	if (flagaBledu != 1 || flagaBledu1 != 1)
	{
		*flaga_filtru = 0;
	}
	system("cls");
}

void sortowanie(int *tablica_sortowanie)
{
	int m, n;
	int temp;

	for (m = 0; m < 9; m++)  // sortowanie babelkowe tablicy sortowania
	{
		for (n = m; n < 8; n++)
		{
			if (tablica_sortowanie[n] > tablica_sortowanie[n + 1])
			{
				temp = tablica_sortowanie[n];
				tablica_sortowanie[n] = tablica_sortowanie[n + 1];
				tablica_sortowanie[n + 1] = temp;
			}
		}
	}

}