obrazy PGM funkcje

void gradient()
{
    int** gradient = malloc(obraz->wysokosc * sizeof(int*));
    for (int i = 0; i < obraz->wysokosc; i++)
    {
        gradient[i] = malloc(obraz->szerokosc * sizeof(int));
    }

    // Liczymy gradient dla pikseli wewnętrznych
    for (int i = 1; i < obraz->wysokosc - 1; i++)
    {
        for (int j = 1; j < obraz->szerokosc - 1; j++)
        {
            int Gx = obraz->piksele[i][j + 1] - obraz->piksele[i][j - 1];
            int Gy = obraz->piksele[i + 1][j] - obraz->piksele[i - 1][j];
            int G = abs(Gx) + abs(Gy); // Prosty gradient (sumujemy wartości bezwzględne)

            // Ograniczamy wartości do zakresu 0 - maxSzarosc
            if (G > obraz->maxSzarosc)
                G = obraz->maxSzarosc;

            gradient[i][j] = G;
        }
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        gradient[i][0] = gradient[i][obraz->szerokosc - 1] = 0;
    }
    for (int j = 0; j < obraz->szerokosc; j++)
    {
        gradient[0][j] = gradient[obraz->wysokosc - 1][j] = 0;
    }

    // Zwalniamy starą tablicę pikseli
    for (int i = 0; i < obraz->wysokosc; i++)
    {
        free(obraz->piksele[i]);
    }
    free(obraz->piksele);

    obraz->piksele = gradient;
}

void dodajLosowyObraz(struct obrazPGM** obrazy, int* liczbaO)
{

    struct obrazPGM nowyO;
    snprintf(nowyO.nazwa, sizeof(nowyO.nazwa), "losowy_%d.pgm", *liczbaO + 1);
    nowyO.szerokosc = 128;
    nowyO.wysokosc = 128;
    nowyO.maxSzarosc = 255;
    nowyO.szum = 0;

    nowyO.piksele = malloc(nowyO.wysokosc * sizeof(int*));
    for (int i = 0; i < nowyO.wysokosc; i++)
    {
        nowyO.piksele[i] = malloc(nowyO.szerokosc * sizeof(int));
        for (int j = 0; j < nowyO.szerokosc; j++)
        {
            // Losowa wartość szarości w zakresie 0 - maxSzarosc
            nowyO.piksele[i][j] = rand() % (nowyO.maxSzarosc + 1);
        }
    }

    struct obrazPGM* temp = realloc(*obrazy, (*liczbaO + 1) * sizeof(struct obrazPGM));
    if (temp == NULL)
    {
        fprintf(stderr, "Blad w alokacji pamieci przy dodawaniu losowego obrazu!\n");
        for (int i = 0; i < nowyO.wysokosc; i++)
            free(nowyO.piksele[i]);
        free(nowyO.piksele);
        return;
    }

    *obrazy = temp;
    (*obrazy)[*liczbaO] = nowyO;
    (*liczbaO)++;
    printf("Losowy obraz '%s' zostal dodany do bazy.\n", nowyO.nazwa);
}

void gradient(struct Obraz* obraz) {
    int** gradient = (int**)malloc(obraz->wysokosc * sizeof(int*)); // Alokacja tablicy 2D
    if (gradient == NULL) {
        fprintf(stderr, "Blad alokacji pamieci dla gradientu\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc; i++) {
        gradient[i] = (int*)malloc(obraz->szerokosc * sizeof(int));
        if (gradient[i] == NULL) {
            fprintf(stderr, "Blad alokacji pamieci dla wiersza gradientu\n");
            for (int j = 0; j < i; j++) {
                free(gradient[j]);
            }
            free(gradient);
            return;
        }
    }

    // Obliczanie gradientu dla pikseli wewnętrznych
    for (int i = 1; i < obraz->wysokosc - 1; i++) {
        for (int j = 1; j < obraz->szerokosc - 1; j++) {
            int Gx = obraz->piksele[i][j + 1] - obraz->piksele[i][j - 1];
            int Gy = obraz->piksele[i + 1][j] - obraz->piksele[i - 1][j];
            int G = abs(Gx) + abs(Gy); // Gradient w wersji uproszczonej

            // Ograniczamy wartości do zakresu 0 - glebi
            if (G > obraz->glebi) {
                G = obraz->glebi;
            }

            gradient[i][j] = G;
        }
    }

    // Ustawianie krawędzi obrazu na 0
    for (int i = 0; i < obraz->wysokosc; i++) {
        gradient[i][0] = 0;
        gradient[i][obraz->szerokosc - 1] = 0;
    }
    for (int j = 0; j < obraz->szerokosc; j++) {
        gradient[0][j] = 0;
        gradient[obraz->wysokosc - 1][j] = 0;
    }

    // Zwalnianie starej tablicy pikseli
    zwolnijTablice2D(obraz->piksele, obraz->wysokosc);

    // Przypisanie nowego obrazu do tablicy pikseli
    obraz->piksele = gradient;

    printf("Gradient obrazu obliczony.\n");
}

case 11:
    printf("Podaj indeks obrazu do obliczenia gradientu: ");
    int indeksGradientu;
    scanf("%d", &indeksGradientu);
    if (indeksGradientu >= 0 && indeksGradientu < liczbaObrazow) {
        gradient(&obrazy[indeksGradientu]);
    } else {
        printf("Niepoprawny indeks obrazu.\n");
    }
    break;

void dodajLosowyObraz(struct Obraz* obrazy, int* liczbaObrazow) {
    if (*liczbaObrazow >= 100) {
        printf("Osiagnieto maksymalna liczbe obrazow w bazie.\n");
        return;
    }

    struct Obraz nowyObraz;
    snprintf(nowyObraz.nazwa, sizeof(nowyObraz.nazwa), "losowy_%d.pgm", *liczbaObrazow + 1);
    nowyObraz.szerokosc = 128;
    nowyObraz.wysokosc = 128;
    nowyObraz.glebi = 255;

    // Alokacja pamięci dla tablicy pikseli
    nowyObraz.piksele = alokujTablice2D(nowyObraz.szerokosc, nowyObraz.wysokosc);
    if (nowyObraz.piksele == NULL) {
        printf("Blad alokacji pamieci dla losowego obrazu.\n");
        return;
    }

    // Wypełnianie losowymi wartościami z zakresu 0 - glebi
    srand(time(NULL)); // Zainicjowanie generatora losowego
    for (int i = 0; i < nowyObraz.wysokosc; i++) {
        for (int j = 0; j < nowyObraz.szerokosc; j++) {
            nowyObraz.piksele[i][j] = rand() % (nowyObraz.glebi + 1);
        }
    }

    // Dodanie nowego obrazu do bazy
    obrazy[*liczbaObrazow] = nowyObraz;
    (*liczbaObrazow)++;
    printf("Losowy obraz '%s' zostal dodany do bazy.\n", nowyObraz.nazwa);
}

case 12:
    dodajLosowyObraz(obrazy, &liczbaObrazow);
    break;

void generujKratownice(int szerokosc, int wysokosc, int rozmiarKwadratu, int indeks) {
    if (liczbaObrazow >= 100) {
        printf("Osiagnieto limit obrazow.\n");
        return;
    }

    obrazy[indeks].szerokosc = szerokosc;
    obrazy[indeks].wysokosc = wysokosc;
    obrazy[indeks].glebi = 255; // Zakladamy skale szarosci od 0 do 255
    strcpy(obrazy[indeks].nazwa, "Kratownica");

    obrazy[indeks].piksele = alokujTablice2D(szerokosc, wysokosc);
    if (obrazy[indeks].piksele == NULL) {
        printf("Blad alokacji pamieci dla kratownicy.\n");
        return;
    }

    for (int i = 0; i < wysokosc; i++) {
        for (int j = 0; j < szerokosc; j++) {
            // Wyliczanie koloru na podstawie pozycji
            if (((i / rozmiarKwadratu) + (j / rozmiarKwadratu)) % 2 == 0) {
                obrazy[indeks].piksele[i][j] = 255; // Bialy
            } else {
                obrazy[indeks].piksele[i][j] = 0;   // Czarny
            }
        }
    }

    liczbaObrazow++;
    printf("Kratownica zostala wygenerowana jako obraz %d.\n", indeks);
}

case 10:
    printf("Podaj szerokosc obrazu: ");
    int szerokosc;
    scanf("%d", &szerokosc);
    printf("Podaj wysokosc obrazu: ");
    int wysokosc;
    scanf("%d", &wysokosc);
    printf("Podaj rozmiar kwadratu: ");
    int rozmiarKwadratu;
    scanf("%d", &rozmiarKwadratu);

    generujKratownice(szerokosc, wysokosc, rozmiarKwadratu, liczbaObrazow);
    break;

void generuj_gradient(Obraz_PGM* obraz)
{
    printf("Podaj szerokosc obrazu: ");
    scanf("%d", &obraz->szerokosc_obrazu);

    printf("Podaj wysokosc obrazu: ");
    scanf("%d", &obraz->wysokosc_obrazu);

    obraz->max_skala_szarosci = 255; // Standard grayscale max value.

    if (!alokacja_pamieci(obraz))
    {
        printf("BLAD! Nie udalo sie zaalokowac pamieci dla obrazu gradientu.\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc_obrazu; i++)
    {
        int value = (i * obraz->max_skala_szarosci) / (obraz->wysokosc_obrazu - 1); // Linear gradient.
        for (int j = 0; j < obraz->szerokosc_obrazu; j++)
        {
            obraz->liczba_pikseli[i][j] = value;
        }
    }

    printf("Gradient pionowy od czarnego do bialego zostal wygenerowany!\n");
}

void generujGradient(struct obrazPGM* obraz)
{
    printf("Podaj szerokosc obrazu: ");
    scanf("%d", &obraz->szerokosc);

    printf("Podaj wysokosc obrazu: ");
    scanf("%d", &obraz->wysokosc);

    obraz->maxSzarosc = 255; // Standard grayscale max value.

    // Alokacja pamięci dla pikseli
    obraz->piksele = malloc(obraz->wysokosc * sizeof(int*));
    if (obraz->piksele == NULL)
    {
        printf("BLAD! Nie udalo sie zaalokowac pamieci dla obrazu gradientu.\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        obraz->piksele[i] = malloc(obraz->szerokosc * sizeof(int));
        if (obraz->piksele[i] == NULL)
        {
            printf("BLAD! Nie udalo sie zaalokowac pamieci dla wiersza pikseli.\n");

            // Zwolnij wcześniej zaalokowaną pamięć w przypadku błędu
            for (int k = 0; k < i; k++)
            {
                free(obraz->piksele[k]);
            }
            free(obraz->piksele);
            return;
        }
    }

    // Generowanie gradientu pionowego
    for (int i = 0; i < obraz->wysokosc; i++)
    {
        int value = (i * obraz->maxSzarosc) / (obraz->wysokosc - 1); // Linear gradient.
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            obraz->piksele[i][j] = value;
        }
    }

    printf("Gradient pionowy od czarnego do bialego zostal wygenerowany!\n");
}
void generujGradient(struct obrazPGM* obraz)
{
    printf("Podaj szerokosc obrazu: ");
    scanf("%d", &obraz->szerokosc);

    printf("Podaj wysokosc obrazu: ");
    scanf("%d", &obraz->wysokosc);

    obraz->maxSzarosc = 255; // Standard grayscale max value.

    // Alokacja pamięci dla pikseli
    obraz->piksele = malloc(obraz->wysokosc * sizeof(int*));
    if (obraz->piksele == NULL)
    {
        printf("BLAD! Nie udalo sie zaalokowac pamieci dla obrazu gradientu.\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        obraz->piksele[i] = malloc(obraz->szerokosc * sizeof(int));
        if (obraz->piksele[i] == NULL)
        {
            printf("BLAD! Nie udalo sie zaalokowac pamieci dla wiersza pikseli.\n");

            // Zwolnij wcześniej zaalokowaną pamięć w przypadku błędu
            for (int k = 0; k < i; k++)
            {
                free(obraz->piksele[k]);
            }
            free(obraz->piksele);
            return;
        }
    }

    // Generowanie gradientu pionowego
    for (int i = 0; i < obraz->wysokosc; i++)
    {
        int value = (i * obraz->maxSzarosc) / (obraz->wysokosc - 1); // Linear gradient.
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            obraz->piksele[i][j] = value;
        }
    }

    printf("Gradient pionowy od czarnego do bialego zostal wygenerowany!\n");
}

case  ... :
    {
        struct obrazPGM nowyObraz;
        generujGradient(&nowyObraz);
        dodajObraz(&obrazy, &liczbaO, nowyObraz.nazwa);
    }
    break;

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

struct Obraz {
    char nazwa[100];
    int szerokosc;
    int wysokosc;
    int glebi;
    int** piksele;
};

struct Obraz obrazy[100];
int liczbaObrazow = 0;

int** alokujTablice2D(int szerokosc, int wysokosc) {
    int** tablica = (int**)malloc(wysokosc * sizeof(int*));
    if (!tablica) {
        printf("Blad alokacji pamieci dla tablicy 2D\n");
        return NULL;
    }
    for (int i = 0; i < wysokosc; i++) {
        tablica[i] = (int*)malloc(szerokosc * sizeof(int));
        if (!tablica[i]) {
            printf("Blad alokacji pamieci dla wiersza tablicy 2D\n");
            for (int j = 0; j < i; j++) {
                free(tablica[j]);
            }
            free(tablica);
            return NULL;
        }
    }
    return tablica;
}

void zwolnijTablice2D(int** tablica, int wysokosc) {
    if (tablica) {
        for (int i = 0; i < wysokosc; i++) {
            free(tablica[i]);
        }
        free(tablica);
    }
}

int czyPoprawneRozszerzenie(const char* nazwaPliku) {
    size_t dlugosc = strlen(nazwaPliku);
    if (dlugosc < 4) {
        printf("Nazwa pliku jest za krotka, aby zawierac rozszerzenie .pgm\n");
        return 0;
    }
    if (strcmp(&nazwaPliku[dlugosc - 4], ".pgm") == 0) {
        return 1;
    }
    printf("Plik nie ma poprawnego rozszerzenia .pgm\n");
    return 0;
}

int odczytajPGM(struct Obraz* obraz, char* nazwaPliku) {
    if (!czyPoprawneRozszerzenie(nazwaPliku)) {
        return 0;
    }

    FILE* plik = fopen(nazwaPliku, "r");
    if (!plik) {
        printf("Nie udalo sie otworzyc pliku %s\n", nazwaPliku);
        return 0;
    }

    fscanf(plik, "P2");
    fscanf(plik, "%d %d", &obraz->szerokosc, &obraz->wysokosc);
    fscanf(plik, "%d", &obraz->glebi);

    obraz->piksele = alokujTablice2D(obraz->szerokosc, obraz->wysokosc);
    if (!obraz->piksele) {
        fclose(plik);
        return 0;
    }

    for (int i = 0; i < obraz->wysokosc; i++) {
        for (int j = 0; j < obraz->szerokosc; j++) {
            fscanf(plik, "%d", &obraz->piksele[i][j]);
        }
    }

    fclose(plik);
    return 1;
}

int zapiszPGM(struct Obraz* obraz, char* nazwaPliku) {
    FILE* plik = fopen(nazwaPliku, "w");
    if (!plik) {
        printf("Nie udalo sie otworzyc pliku do zapisu\n");
        return 0;
    }

    fprintf(plik, "P2\n%d %d\n%d\n", obraz->szerokosc, obraz->wysokosc, obraz->glebi);
    for (int i = 0; i < obraz->wysokosc; i++) {
        for (int j = 0; j < obraz->szerokosc; j++) {
            fprintf(plik, "%d ", obraz->piksele[i][j]);
        }
        fprintf(plik, "\n");
    }

    fclose(plik);
    return 1;
}

void histogramDoCSV(struct Obraz* obraz, const char* nazwaCSV) {
    int* histogram = (int*)calloc(obraz->glebi + 1, sizeof(int));
    if (!histogram) {
        printf("Blad alokacji pamieci dla histogramu\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc; i++) {
        for (int j = 0; j < obraz->szerokosc; j++) {
            histogram[obraz->piksele[i][j]]++;
        }
    }

    FILE* plik = fopen(nazwaCSV, "w");
    if (!plik) {
        printf("Nie udalo sie otworzyc pliku do zapisu histogramu\n");
        free(histogram);
        return;
    }

    fprintf(plik, "Jasnosc,Ilosc\n");
    for (int i = 0; i <= obraz->glebi; i++) {
        fprintf(plik, "%d,%d\n", i, histogram[i]);
    }

    fclose(plik);
    free(histogram);
    printf("Histogram zapisany do pliku %s\n", nazwaCSV);
}

void negatyw(struct Obraz* obraz) {
    for (int i = 0; i < obraz->wysokosc; i++) {
        for (int j = 0; j < obraz->szerokosc; j++) {
            obraz->piksele[i][j] = obraz->glebi - obraz->piksele[i][j];
        }
    }
    printf("Negatyw wykonany.\n");
}


void obroc90(struct Obraz* obraz) {
    int** obrocony = alokujTablice2D(obraz->wysokosc, obraz->szerokosc);
    if (!obrocony) {
        printf("Blad alokacji pamieci.\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc; i++) {
        for (int j = 0; j < obraz->szerokosc; j++) {
            obrocony[j][obraz->wysokosc - i - 1] = obraz->piksele[i][j];
        }
    }

    zwolnijTablice2D(obraz->piksele, obraz->wysokosc);
    obraz->piksele = obrocony;

    int temp = obraz->szerokosc;
    obraz->szerokosc = obraz->wysokosc;
    obraz->wysokosc = temp;

    printf("Obrot o 90 stopni wykonano.\n");
}

void zaszumObraz(struct Obraz* obraz, float poziom) {
    int liczbaZakloconych = (int)(poziom * obraz->szerokosc * obraz->wysokosc);
    srand(time(NULL));

    for (int k = 0; k < liczbaZakloconych; k++) {
        int i = rand() % obraz->wysokosc;
        int j = rand() % obraz->szerokosc;
        obraz->piksele[i][j] = (rand() % 2 == 0) ? 0 : obraz->glebi;
    }

    printf("Obraz zaszumiono.\n");
}


void filtrMedianowy(struct Obraz* obraz) {
    int** nowaTablica = alokujTablice2D(obraz->szerokosc, obraz->wysokosc);
    if (!nowaTablica) {
        printf("Blad alokacji pamieci.\n");
        return;
    }

    int okno[9];
    for (int y = 1; y < obraz->wysokosc - 1; y++) {
        for (int x = 1; x < obraz->szerokosc - 1; x++) {
            int k = 0;
            for (int dy = -1; dy <= 1; dy++) {
                for (int dx = -1; dx <= 1; dx++) {
                    okno[k++] = obraz->piksele[y + dy][x + dx];
                }
            }

            for (int i = 0; i < 8; i++) {
                for (int j = 0; j < 8 - i; j++) {
                    if (okno[j] > okno[j + 1]) {
                        int temp = okno[j];
                        okno[j] = okno[j + 1];
                        okno[j + 1] = temp;
                    }
                }
            }

            nowaTablica[y][x] = okno[4];
        }
    }

    zwolnijTablice2D(obraz->piksele, obraz->wysokosc);
    obraz->piksele = nowaTablica;

    printf("Filtr medianowy wykonano.\n");
}

void wyswietlListeObrazow() {
    if (liczbaObrazow == 0) {
        printf("Brak obrazow.\n");
    }
    else {
        for (int i = 0; i < liczbaObrazow; i++) {
            printf("%d. %s (%dx%d, glebi: %d)\n", i, obrazy[i].nazwa, obrazy[i].szerokosc, obrazy[i].wysokosc, obrazy[i].glebi);
        }
    }
}


void usunObraz(int indeks) {
    if (indeks < 0 || indeks >= liczbaObrazow) {
        printf("Niepoprawny indeks obrazu\n");
        return;
    }

    zwolnijTablice2D(obrazy[indeks].piksele, obrazy[indeks].wysokosc);
    for (int i = indeks; i < liczbaObrazow - 1; i++) {
        obrazy[i] = obrazy[i + 1];
    }

    liczbaObrazow--;
    printf("Obraz usuniety\n");
}


int main() {
    int opcja;
    char nazwaPliku[100];

    while (1) {
        printf("\nMENU:\n");
        printf("1. Wczytaj obraz\n");
        printf("2. Zapisz obraz\n");
        printf("3. Negatyw obrazu\n");
        printf("4. Obrot o 90 stopni\n");
        printf("5. Szum pieprz i sol\n");
        printf("6. Filtr medianowy\n");
        printf("7. Histogram do CSV\n");
        printf("8. Wyswietl liste obrazow\n");
        printf("9. Usun obraz\n");
        printf("0. Wyjdz\n");
        printf("Wybierz opcje: ");
        scanf("%d", &opcja);

        if (opcja == 0) break;

        int indeks;
        switch (opcja) {
        case 1:
            if (liczbaObrazow < 100) {
                printf("Podaj nazwe pliku: ");
                scanf("%s", nazwaPliku);
                if (odczytajPGM(&obrazy[liczbaObrazow], nazwaPliku)) {
                    strcpy(obrazy[liczbaObrazow].nazwa, nazwaPliku);
                    liczbaObrazow++;
                }
            }
            else {
                printf("Osiagnieto limit obrazow.\n");
            }
            break;

        case 2:
            printf("Podaj indeks obrazu: ");
            scanf("%d", &indeks);
            if (indeks >= 0 && indeks < liczbaObrazow) {
                printf("Podaj nazwe pliku: ");
                scanf("%s", nazwaPliku);
                zapiszPGM(&obrazy[indeks], nazwaPliku);
            }
            break;

        case 3:
            printf("Podaj indeks obrazu: ");
            scanf("%d", &indeks);
            if (indeks >= 0 && indeks < liczbaObrazow) {
                negatyw(&obrazy[indeks]);
            }
            break;

        case 4:
            printf("Podaj indeks obrazu: ");
            scanf("%d", &indeks);
            if (indeks >= 0 && indeks < liczbaObrazow) {
                obroc90(&obrazy[indeks]);
            }
            break;

        case 5:
            printf("Podaj indeks obrazu: ");
            scanf("%d", &indeks);
            if (indeks >= 0 && indeks < liczbaObrazow) {
                float poziom;
                printf("Podaj poziom szumu (0-1): ");
                scanf("%f", &poziom);
                zaszumObraz(&obrazy[indeks], poziom);
            }
            break;

        case 6:
            printf("Podaj indeks obrazu: ");
            scanf("%d", &indeks);
            if (indeks >= 0 && indeks < liczbaObrazow) {
                filtrMedianowy(&obrazy[indeks]);
            }
            break;

        case 7:
            printf("Podaj indeks obrazu: ");
            scanf("%d", &indeks);
            if (indeks >= 0 && indeks < liczbaObrazow) {
                printf("Podaj nazwe pliku CSV: ");
                scanf("%s", nazwaPliku);
                histogramDoCSV(&obrazy[indeks], nazwaPliku);
            }
            break;

        case 8:
            wyswietlListeObrazow();
            break;

        case 9:
            printf("Podaj indeks obrazu: ");
            scanf("%d", &indeks);
            if (indeks >= 0 && indeks < liczbaObrazow) {
                usunObraz(indeks);
            }
            break;

        default:
            printf("Niepoprawna opcja.\n");
        }
    }

    for (int i = 0; i < liczbaObrazow; i++) {
        zwolnijTablice2D(obrazy[i].piksele, obrazy[i].wysokosc);
    }

    return 0;
}

void generujGradientZakres(struct obrazPGM* obraz)
{
    // Podanie wymiarów obrazu przez użytkownika
    printf("Podaj szerokosc obrazu: ");
    scanf("%d", &obraz->szerokosc);

    printf("Podaj wysokosc obrazu: ");
    scanf("%d", &obraz->wysokosc);

    // Podanie zakresu wartości szarości
    int minSzarosc, maxSzarosc;
    printf("Podaj minimalna wartosc szarosci (np. 0): ");
    scanf("%d", &minSzarosc);

    printf("Podaj maksymalna wartosc szarosci (np. 255): ");
    scanf("%d", &maxSzarosc);

    // Sprawdzenie poprawności danych
    if (minSzarosc < 0 || maxSzarosc > 255 || minSzarosc >= maxSzarosc)
    {
        printf("BLAD! Nieprawidlowe wartosci szarosci. Musza spelnic warunek: 0 <= minSzarosc < maxSzarosc <= 255.\n");
        return;
    }

    obraz->maxSzarosc = maxSzarosc; // Maksymalna wartość szarości w obrazie

    // Alokacja pamięci dla pikseli
    obraz->piksele = malloc(obraz->wysokosc * sizeof(int*));
    if (obraz->piksele == NULL)
    {
        printf("BLAD! Nie udalo sie zaalokowac pamieci dla obrazu gradientu.\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        obraz->piksele[i] = malloc(obraz->szerokosc * sizeof(int));
        if (obraz->piksele[i] == NULL)
        {
            printf("BLAD! Nie udalo sie zaalokowac pamieci dla wiersza pikseli.\n");

            // Zwolnij wcześniej zaalokowaną pamięć w przypadku błędu
            for (int k = 0; k < i; k++)
            {
                free(obraz->piksele[k]);
            }
            free(obraz->piksele);
            return;
        }
    }

    // Generowanie gradientu pionowego
    for (int i = 0; i < obraz->wysokosc; i++)
    {
        // Wyliczanie wartości w oparciu o liniowy gradient
        int value = minSzarosc + (i * (maxSzarosc - minSzarosc)) / (obraz->wysokosc - 1);
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            obraz->piksele[i][j] = value;
        }
    }

    printf("Gradient pionowy od %d do %d zostal wygenerowany!\n", minSzarosc, maxSzarosc);
}

printf("11. Wygeneruj gradient pionowy z zakresem\n");

case 11:
    {
        struct obrazPGM nowyObraz;
        generujGradientZakres(&nowyObraz);
        if (nowyObraz.piksele != NULL) // Sprawdzenie, czy gradient został wygenerowany
        {
            dodajObraz(&obrazy, &liczbaO, nowyObraz.nazwa);
        }
    }
    break;

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

struct obrazPGM
{
    char nazwa[100];
    int wysokosc;
    int szerokosc;
    int maxSzarosc;
    int** piksele;
    int szum;
};

void pominKom(FILE* plik)
{
    int kom;
    while ((kom = fgetc(plik)) != EOF)
    {
        if (kom == '#')
        {
            while ((kom = fgetc(plik)) != '\n' && kom != EOF);
        }
        else if (!isspace(kom))
        {
            ungetc(kom, plik);
            break;
        }
    }
}

int odczytPGM(const char* nazwa, struct obrazPGM* obraz)
{
    strncpy(obraz->nazwa, nazwa, sizeof(obraz->nazwa) - 1);
    obraz->nazwa[sizeof(obraz->nazwa) - 1] = '\0';

    FILE* plik = fopen(nazwa, "r");
    if (plik == NULL)
    {
        perror("Blad fopen");
        printf("Blad w otwaciu pliku do odczytu: %s\n", nazwa);
        return 0;
    }

    char standard[3];
    pominKom(plik);
    fscanf(plik, "%2s", standard);
    if (strcmp(standard, "P2") != 0)
    {
        printf("Niepoprawny format pliku: %s\n", standard);
        fclose(plik);
        return 0;
    }

    pominKom(plik);
    fscanf(plik, "%d", &obraz->szerokosc);
    pominKom(plik);
    fscanf(plik, "%d", &obraz->wysokosc);
    pominKom(plik);
    fscanf(plik, "%d", &obraz->maxSzarosc);
    obraz->szum = 0;

    obraz->piksele = malloc(obraz->wysokosc * sizeof(int*));
    if (obraz->piksele == NULL)
    {
        printf("Blad alokacji pamieci!\n");
        fclose(plik);
        return 0;
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        obraz->piksele[i] = malloc(obraz->szerokosc * sizeof(int));
        if (obraz->piksele[i] == NULL)
        {
            for (int j = 0; j < i; j++)
            {
                free(obraz->piksele[j]);
            }
            free(obraz->piksele);
            fclose(plik);
            return 0;
        }
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            fscanf(plik, "%d", &obraz->piksele[i][j]);
        }
    }

    fclose(plik);
    printf("Obraz %s zostal poprawnie odczytany\n", nazwa);
    return 1;
}

void zapisPGM(const char* nazwa, struct obrazPGM* obraz)
{
    FILE* plik = fopen(nazwa, "w");
    if (plik == NULL)
    {
        printf("Blad w otwaciu pliku do zapisu: %s\n", nazwa);
        return;
    }

    fprintf(plik, "P2\n");
    fprintf(plik, "%d %d\n", obraz->szerokosc, obraz->wysokosc);
    fprintf(plik, "%d\n", obraz->maxSzarosc);

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            fprintf(plik, "%d ", obraz->piksele[i][j]);
        }
        fprintf(plik, "\n");
    }

    fclose(plik);
    printf("Obraz %s zostal zapisany poprawnie\n", nazwa);
}

void zwolnijPGM(struct obrazPGM* obraz)
{
    if (obraz->piksele != NULL)
    {
        for (int i = 0; i < obraz->wysokosc; i++)
        {
            free(obraz->piksele[i]);
        }
        free(obraz->piksele);
        obraz->piksele = NULL;
    }
}

void obrot90(struct obrazPGM* obraz)
{
    int** obraz90 = malloc(obraz->szerokosc * sizeof(int*));
    if (obraz90 == NULL)
    {
        fprintf(stderr, "Blad w alokacji pamieci dla obroconego obrazu\n");
        return;
    }

    for (int i = 0; i < obraz->szerokosc; i++)
    {
        obraz90[i] = malloc(obraz->wysokosc * sizeof(int));
        if (obraz90[i] == NULL)
        {
            for (int j = 0; j < i; j++)
            {
                free(obraz90[j]);
            }
            free(obraz90);
            fprintf(stderr, "Blad w alokacji pamieci dla wierszy obroconego obrazu\n");
            return;
        }
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            obraz90[j][obraz->wysokosc - 1 - i] = obraz->piksele[i][j];
        }
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        free(obraz->piksele[i]);
    }
    free(obraz->piksele);
    obraz->piksele = obraz90;

    int temp = obraz->szerokosc;
    obraz->szerokosc = obraz->wysokosc;
    obraz->wysokosc = temp;
}

void negatyw(struct obrazPGM* obraz)
{
    for (int i = 0; i < obraz->wysokosc; i++)
    {
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            obraz->piksele[i][j] = obraz->maxSzarosc - obraz->piksele[i][j];
        }
    }
    printf("Negatyw obrazu zostal wygenerowany.\n");
}

void generujGradientZakres(struct obrazPGM* obraz)
{
    printf("Podaj szerokosc obrazu: ");
    scanf("%d", &obraz->szerokosc);

    printf("Podaj wysokosc obrazu: ");
    scanf("%d", &obraz->wysokosc);

    int minSzarosc, maxSzarosc;
    printf("Podaj minimalna wartosc szarosci (np. 0): ");
    scanf("%d", &minSzarosc);

    printf("Podaj maksymalna wartosc szarosci (np. 255): ");
    scanf("%d", &maxSzarosc);

    if (minSzarosc < 0 || maxSzarosc > 255 || minSzarosc >= maxSzarosc)
    {
        printf("BLAD! Nieprawidlowe wartosci szarosci.\n");
        return;
    }

    obraz->maxSzarosc = maxSzarosc;

    obraz->piksele = malloc(obraz->wysokosc * sizeof(int*));
    if (obraz->piksele == NULL)
    {
        printf("BLAD! Nie udalo sie zaalokowac pamieci dla obrazu gradientu.\n");
        return;
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        obraz->piksele[i] = malloc(obraz->szerokosc * sizeof(int));
        if (obraz->piksele[i] == NULL)
        {
            for (int k = 0; k < i; k++)
            {
                free(obraz->piksele[k]);
            }
            free(obraz->piksele);
            return;
        }
    }

    for (int i = 0; i < obraz->wysokosc; i++)
    {
        int value = minSzarosc + (i * (maxSzarosc - minSzarosc)) / (obraz->wysokosc - 1);
        for (int j = 0; j < obraz->szerokosc; j++)
        {
            obraz->piksele[i][j] = value;
        }
    }

    printf("Gradient pionowy od %d do %d zostal wygenerowany!\n", minSzarosc, maxSzarosc);
}

int main()
{
    struct obrazPGM* obrazy = NULL;
    int liczbaO = 0;
    int menu = -1;
    int menuOperacji = -1;

    while (menu != 0)
    {
        printf("\n---MENU GLOWNE---\n");
        printf("1. Dodaj obraz z pliku\n");
        printf("2. Zapisz obraz do pliku\n");
        printf("3. Wyswietl liste obrazow\n");
        printf("4. Wygeneruj gradient pionowy z zakresem szarosci\n");
        printf("5. Wykonaj operacje na obrazie\n");
        printf("0. Zakoncz\n");
        scanf("%d", &menu);

        switch (menu)
        {
            case 1:
                {
                    char nazwa[100];
                    printf("Podaj nazwe pliku do odczytu: ");
                    scanf("%s", nazwa);
                    struct obrazPGM nowyObraz;
                    if (odczytPGM(nazwa, &nowyObraz))
                    {
                        obrazy = realloc(obrazy, (liczbaO + 1) * sizeof(struct obrazPGM));
                        obrazy[liczbaO++] = nowyObraz;
                    }
                }
                break;

            case 2:
                {
                    if (liczbaO == 0)
                    {
                        printf("Brak obrazow w bazie!\n");
                        break;
                    }
                    int numer;
                    printf("Podaj numer obrazu do zapisu: ");
                    scanf("%d", &numer);
                    if (numer < 0 || numer >= liczbaO)
                    {
                        printf("Niepoprawny numer obrazu!\n");
                        break;
                    }
                    char nazwa[100];
                    printf("Podaj nazwe pliku do zapisu: ");
                    scanf("%s", nazwa);
                    zapisPGM(nazwa, &obrazy[numer]);
                }
                break;

            case 3:
                {
                    if (liczbaO == 0)
                    {
                        printf("Brak obrazow w bazie!\n");
                        break;
                    }
                    for (int i = 0; i < liczbaO; i++)
                    {
                        printf("%d. %s (%dx%d)\n", i, obrazy[i].nazwa, obrazy[i].szerokosc, obrazy[i].wysokosc);
                    }
                }
                break;

            case 4:
                {
                    struct obrazPGM nowyObraz;
                    generujGradientZakres(&nowyObraz);
                    if (nowyObraz.piksele != NULL)
                    {
                        obrazy = realloc(obrazy, (liczbaO + 1) * sizeof(struct obrazPGM));
                        obrazy[liczbaO++] = nowyObraz;
                    }
                }
                break;

            case 5:
                {
                    if (liczbaO == 0)
                    {
                        printf("Brak obrazow w bazie!\n");
                        break;
                    }
                    printf("Podaj numer obrazu do operacji: ");
                    int numer;
                    scanf("%d", &numer);
                    if (numer < 0 || numer >= liczbaO)
                    {
                        printf("Niepoprawny numer obrazu!\n");
                        break;
                    }

                    while (menuOperacji != 0)
                    {
                        printf("\n---MENU OPERACJI---\n");
                        printf("1. Obrot obrazu o 90 stopni\n");
                        printf("2. Negatyw obrazu\n");
                        printf("0. Powrot do menu glownego\n");
                        scanf("%d", &menuOperacji);

                        switch (menuOperacji)
                        {
                            case 1:
                                obrot90(&obrazy[numer]);
                                printf("Obraz zostal obrocony o 90 stopni.\n");
                                break;

                            case 2:
                                negatyw(&obrazy[numer]);
                                printf("Negatyw obrazu zostal wygenerowany.\n");
                                break;

                            case 0:
                                printf("Powrot do menu glownego.\n");
                                break;

                            default:
                                printf("Niepoprawna opcja.\n");
                        }
                    }
                }
                break;

            case 0:
                printf("Zakoncz program.\n");
                break;

            default:
                printf("Niepoprawna opcja!\n");
        }
    }

    for (int i = 0; i < liczbaO; i++)
    {
        zwolnijPGM(&obrazy[i]);
    }
    free(obrazy);

    return 0;
}