#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

struct obrazek
{
	char tytul[30];
	char format[2];
	int szerokosc;
	int wysokosc;
	int glebokosc;
	int **dane;
};
void komentarze(FILE *obraz)
{
	char a;
	char kom[120];
	do
    {
		while (fscanf(obraz, "%c", &a) && (a == 32 || a == 'n' || a == ''));//pomija spacje konce lini
		if (a == '#')
        {
			fgets(kom, 120, obraz);
		}

		else
        {
			fseek(obraz, -1, SEEK_CUR);//znak zostal juz pobrany do sprawdzenia, a jesli nie jest # to chcemy go pobrac jeszcze raz do zapisu
		}
	}
	while ((fscanf(obraz, "%c", &a) && (a == 32 || a == 'n' || a == '')));
	fseek(obraz, -1, SEEK_CUR);
}
void alokacja( struct obrazek*tablica, int szer, int wys)
{
	int i = 0;
	int j = 0;
    tablica->dane= realloc(0, wys* sizeof(tablica->dane));
    for (i; i < wys; i++)
    {
		tablica->dane[i]= realloc(0, szer * sizeof(tablica->dane[i]));
	}
}
void wczytywanieobrazu(struct obrazek* tablica, int rozmiar)
{
	char nazwa[120];
	char nazwa2[200];
	int i = 0;
	int j = 0;
	int n;
	char c;

	printf("podaj nazwe obrazu do odczytu n");
	scanf("%s", &tablica->tytul);
	strcpy(nazwa, tablica->tytul);
	strcat(nazwa, ".pgm");
	while ((c = getchar()) != 'n' && c != EOF);
	FILE*obraz;
	obraz = fopen(nazwa, "r");

	if ((obraz = fopen(nazwa, "r")) == NULL)
    {
		printf("blad przy odzycie pliku, podaj nazwe jeszcze raz n");
	}
	fseek(obraz, 0, SEEK_SET);

	komentarze( obraz);
	fscanf(obraz, "%c ", &tablica->format[0]); //zapis pierwszego znaku
	komentarze(obraz);
	fscanf(obraz, "%c ", &tablica->format[1]); // zapis drugiego znaku
	komentarze(obraz);
	fscanf(obraz, "%d", &tablica->szerokosc);
	komentarze(obraz);
	fscanf(obraz, "%d", &tablica->wysokosc);
	komentarze(obraz);
	fscanf(obraz, "%d ", &tablica->glebokosc);

	//rozpoczecie zapisu samego obrazu

	alokacja( tablica, tablica->szerokosc, tablica->wysokosc);


	for (i; i < tablica->wysokosc; i++)
	{
		for (j; j < tablica->szerokosc; j++)
        {
			komentarze(obraz);
			fscanf(obraz, "%d ", &n);
			tablica->dane[i][j] = n;
		}
		j = 0;
	}
	fclose(obraz);
	}

void dodawanieObrazu(struct obrazek* tablica, struct obrazek *struktury, int rozmiar)
{
	int i = 0;
	int j = 0;
	struct obrazek *pomoc;
	pomoc = &struktury[rozmiar - 1];
	struktury[rozmiar - 1].format[0] = tablica->format[0];
    struktury[rozmiar - 1].format[1] = tablica->format[1];
	struktury[rozmiar - 1].wysokosc = tablica->wysokosc;
	struktury[rozmiar - 1].szerokosc = tablica->szerokosc;
	struktury[rozmiar - 1].glebokosc = tablica->glebokosc;
	alokacja(pomoc, tablica->szerokosc, tablica->wysokosc);
	for (i; i < tablica->wysokosc; i++)
	{
		for (j; j < tablica->szerokosc; j++)
        {
			struktury[rozmiar - 1].dane[i][j] = tablica->dane[i][j];
		}
		j = 0;
	}

}
void wyswietlanieObrazu(struct obrazek*struktury, int rozmiar)
{
	int i = 0;
	int j = 0;
	printf("%c", struktury[rozmiar - 1].format[0]);
	printf("%c n", struktury[rozmiar - 1].format[1]);
	printf("%d n", struktury[rozmiar - 1].wysokosc);
	printf("%d n", struktury[rozmiar - 1].szerokosc);
	printf("%d n", struktury[rozmiar - 1].glebokosc);
	for (i; i < struktury[rozmiar - 1].wysokosc; i++)
    {
		for (j; j < struktury[rozmiar - 1].szerokosc; j++)
		{
			printf("%d ", struktury[rozmiar - 1].dane[i][j]);
		}
		j = 0;
		printf("n");
	}
}
void alokacja2(struct obrazek*tablica, int szer, int wys)
{
	int i = 0;
	int j = 0;
	tablica->dane= realloc(0, wys* sizeof(tablica->dane));
    for (i; i < wys; i++)
    {
		tablica->dane[i]= realloc(0, szer * sizeof(tablica->dane[i]));
	}

}

struct obrazek  *usuwanie(struct obrazek*struktury, int rozmiar)
{
	struct obrazek * tym;
	int a=0;
	int i = 0;
	int j = 0;
	char c;
	int numer=0;

	printf("podaj numer obrazu, ktory chcesz usunac n");
	scanf("%d", &numer);
	while ((c = getchar()) != 'n' && c != EOF);
	a = numer;
	for (a; a < rozmiar; a++)
    {
		tym = &struktury[a - 1];//numer obrazu
		struktury[a - 1].format[0] = struktury[a].format[0];
		struktury[a - 1].format[1] = struktury[a].format[1];
		struktury[a - 1].szerokosc = struktury[a].szerokosc;
		struktury[a - 1].wysokosc = struktury[a].wysokosc;
		struktury[a - 1].glebokosc = struktury[a].glebokosc;
		alokacja2(tym, struktury[a - 1].szerokosc, struktury[a - 1].wysokosc);
		for (i; i < struktury[a - 1].wysokosc; i++)
        {
			for (j; j < struktury[a - 1].szerokosc; j++)
			{
				struktury[a - 1].dane[i][j] = struktury[a].dane[i][j];
			}
			j = 0;
		}
	}
	rozmiar--;
	return struktury;
}
void negatyw(struct obrazek *tablica)
{
	int i = 0;
	int n = 0;
	int j = 0;

	for (i; i < tablica->wysokosc; i++)
    {
		for (j; j < tablica->szerokosc; j++)
		{
			tablica->dane[i][j] = tablica->glebokosc - tablica->dane[i][j];
		}
		j = 0;
	}
	i = 0;
	j = 0;

}
void progowanie(struct obrazek *tablica)
{
	int prog =0;
	printf("glebia szarosci tego obrazu to %d n", tablica->glebokosc);
	printf(" wybierz poziom progowania od 0 do 255 n");
	scanf("%d", &prog);
		int i = 0;
		int j = 0;
		for (i; i < tablica->wysokosc; i++)
        {
			for (j; j < tablica->szerokosc; j++)
			{
				if (tablica->dane[i][j] < prog)
                    tablica->dane[i][j] = tablica->glebokosc;
				else
				     tablica->dane[i][j] = 0;
			}
			j = 0;

		}

}
void histogram(struct obrazek tablica)
{
	int * tym;
	int i = 0;
	int j = 0;
	tym = calloc(tablica.glebokosc, sizeof(tablica));//tworzenie tablicy glebokosc
	for (i; i < tablica.wysokosc; i++)
    {
		for (j; j < tablica.szerokosc; j++)
		{
			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
		}
		j = 0;
	}
	i = 0;
	FILE *plik;
	plik = fopen("histogram.csv", "w+");//tworzenie pliku z wartosciami tablicy glebokosc

	if ((plik = fopen("histogram.csv", "w+")) == NULL)
    {
		printf("blad przy tworzeniu pliku n");
	}
	for (i; i < tablica.glebokosc; i++)
	{
		fprintf(plik, "%d n", tym[i]);
	}
	fclose(plik);
}
void obrot(struct obrazek *tablica)
{
	int k = 0;
	int i = 0;
	int j = 0;
    char c;
	printf("podaj k-krotnosc kata 90 stopni obrotu od 1 do 4 n");
	scanf("%d", &k);
	while ((c = getchar()) != 'n' && c != EOF);

	switch (k) {
	case 4:break;

	case 1:
			alokacja2(tablica, tablica->wysokosc, tablica->szerokosc);
			tablica->szerokosc = tablica->wysokosc;
			tablica->wysokosc = tablica->szerokosc;
			for (i; i < tablica->wysokosc; i++)
			{
				for (j; j < tablica->szerokosc; j++)
                {
					tablica->dane[i][j] = tablica->dane[j][tablica->szerokosc - 1 - i];
				}
				j = 0;

			}
			i = 0;
			j = 0;
			break;
	case 2:
			for (i; i < tablica->wysokosc; i++)
			{
				for (j; j < tablica->szerokosc; j++)
                {
					tablica->dane[i][j] = tablica->dane[tablica->wysokosc - i - 1][tablica->szerokosc - j - 1];
				}
				j = 0;
			}

		i = 0;
		j = 0;
		break;

	case 3:
			alokacja2(tablica, tablica->wysokosc, tablica->szerokosc);
			tablica->szerokosc = tablica->wysokosc;
			tablica->wysokosc = tablica->szerokosc;
			for (i; i < tablica->wysokosc; i++)
            {
				for (j; j < tablica->szerokosc; j++)
				{
					tablica->dane[i][j] = tablica->dane[tablica->szerokosc - 1 - j][i];
				}
				j = 0;
			}
			i = 0;
			j = 0;
			break;
	default:
			printf("podales zla wielokrotnosc kata 90 stopni. n");
			return 0;
			break;
	}


}
void szum(struct obrazek *tablica)
{
    srand(time(NULL));
    int i, j, k, l;
    for (i = 0; i < tablica->wysokosc; i++)
    {
        for (j = 0; j < tablica->szerokosc; j++)
        {
            k = rand() % 20 + 1;
            if (k == 5)
            {
                l = rand() % 2 + 1;
                if (l == 1)
                    tablica->dane[i][j] = 0;
                else
                    tablica->dane[i][j] = tablica->glebokosc;
            }
        }
    }
}

void filtrMedianowy(struct obrazek *tablica)
{
    int macierz[9];
    int i, j, k, l, m, n, y, z;
    for (i = 1; i < (tablica->wysokosc)-1; i++)
    {
        for (j = 1; j < (tablica->szerokosc)-1; j++)
        {
            l = 1;
            m = 1;
            for (k = 0; k < 9; k++)
            {
                if ((k == 3) || (k == 6))
                {
                    m--;
                    l = 1;
                }
                macierz[k] = tablica->dane[i - l][j - m];
                l--;
            }
            for (y = 0; y < 8; y++)
            {
                for (z = 0; z < 8; z++)
                {
                    if (macierz[z] > macierz[z + 1])
                    {
                        n = macierz[z];
                        macierz[z] = macierz[z + 1];
                        macierz[z + 1] = n;
                    }
                }
            }
            tablica->dane[i][j] = macierz[4];
        }
    }
}
void zapisObrazu (struct obrazek*tablica)
{
    int i, j;
    char c;
    char nazwa[120];
    printf("podaj nazwe obrazu do zapisu n");
	scanf("%s", &nazwa);
	strcat(nazwa, ".pgm");
	printf("%s n", nazwa);
	while ((c = getchar()) != 'n' && c != EOF);
	FILE*obraz;
	obraz = fopen(nazwa, "w+");

	if ((obraz = fopen(nazwa, "w+")) == NULL)
    {
		printf("blad przy odzycie pliku, podaj nazwe jeszcze raz n");
	}

	fprintf(obraz, "%c", tablica->format[0]); //zapis pierwszego znaku
	fprintf(obraz, "%c n", tablica->format[1]); // zapis drugiego znaku
	fprintf(obraz, "%d n", tablica->szerokosc);
	fprintf(obraz, "%d n", tablica->wysokosc);
	fprintf(obraz, "%d n", tablica->glebokosc);
	//rozpoczecie zapisu samego obrazu
	for (i; i < tablica->wysokosc; i++)
    {
		for (j; j < tablica->szerokosc; j++)
		{
			 fprintf(obraz, "%d ", tablica->dane[i][j]);
		}
		j = 0;
		fprintf(obraz, " n");

	}
	fclose(obraz);
}

void main()
{
	int x = 0;
	int y = 0;
	int i =0;
	int j =0;
	int z = 0;
	int nr= 0;
	int nrobrazu = 0;
	int rozmiar=0;
	int zabieranie = 0;
	char c;
	struct obrazek *tablica;
	struct obrazek *struktury;
	struct obrazek a;
	tablica = &a;
	struktury = calloc(0, sizeof(*struktury));
	struktury=realloc(struktury, 10 * sizeof(*struktury));

	for (;;)
        {
		printf("1 - dodanie obrazun");
		printf("2 - usuniecie obrazu n");
		printf("3 - wyswietlanie obrazu n ");
		printf("4 - obrot obrazu o k * 90 stopni n");
		printf("5 - wykonanie negatywu n");
		printf("6 - wykonanie progowania n");
		printf("7 - wykonanie histogramu n");
		printf("8 - zapis przetwarzanego obrazu n");
		printf("9 - koniec programu n");
		printf("podaj liczbe n");
		scanf("%d", &z);
		while ((c = getchar()) != 'n' && c != EOF);//czysci bufor nie da rady wpisac 1 1 1 np
		switch (z) {
		case 1: // dodawanie
			wczytywanieobrazu(tablica, rozmiar);
			rozmiar = rozmiar + 1;
			dodawanieObrazu(tablica, struktury, rozmiar);
			break;

		case 2: // usuwanie
			struktury =usuwanie(struktury, rozmiar);
			rozmiar--;
			break;

		case 3: //wyswietlanie
			do {
				printf("podaj numer obrazu n");
				scanf("%d", &nrobrazu);
				while ((c = getchar()) != 'n' && c != EOF);
				if (nrobrazu > rozmiar) printf("nie ma jeszcze tyle obrazow n");
			} while (nrobrazu>rozmiar);

			wyswietlanieObrazu(struktury, nrobrazu);
			break;

		case 4:
			printf("podaj numer obrazu do wykonania obrotu n");
			scanf("%d", &nr);
			while ((c = getchar()) != 'n' && c != EOF);
			if (nr >= (rozmiar + 1) || nr <= 0) {
				printf("nie ma obrazu o takim numerze n");
				break;

			}
			obrot(&struktury[nr - 1]);
			nr = 0;
			break;

		case 5:
			printf("podaj numer obrazu do wykonania negatywu n");
			scanf("%d", &nr);
			while ((c = getchar()) != 'n' && c != EOF);
			if (nr >= (rozmiar+1) || nr <= 0) {
				printf("nie ma obrazu o takim numerze n");
				break;
			}
			negatyw(&struktury[nr-1]);
			nr = 0;
			break;

		case 6:
			printf("podaj numer obrazu do wykonania progowania n");
			scanf("%d", &nr);
			while ((c = getchar()) != 'n' && c != EOF);
			if (nr >= (rozmiar + 1) || nr <= 0) {
				printf("nie ma obrazu o takim numerze n");
				break;
			}
			progowanie(&struktury[nr-1]);
			nr = 0;
			break;

		case 7:
			printf("podaj numer obrazu do wykonania histogramu n");
			scanf("%d", &nr);
			while ((c = getchar()) != 'n' && c != EOF);
			if (nr >= (rozmiar + 1) || nr <= 0) {
				printf("nie ma obrazu o takim numerze n");
				break;
			}
			histogram(struktury[nr - 1]);
			nr = 0;
			break;

        case 8:
            printf("podaj numer obrazu do zapisu n");
			scanf("%d", &nr);
			while ((c = getchar()) != 'n' && c != EOF);
			if (nr >= (rozmiar + 1) || nr <= 0) {
				printf("nie ma obrazu o takim numerze n");
				break;
			}
			zapisObrazu(&struktury[nr - 1]);
			nr = 0;
			break;

        case 9:
			return 0;
			break;

		default:
			printf("w menu nie ma takiego numeru n");
			break;
		}
	}
	system("pause");
}