/*
;===============================================================================;
;                                                                               ;
; Plik           : Z4.cpp                                                       ;
; Format         : EXE                                                          ;
; Cwiczenie      : Tryb graficzny i przetwarzanie obrazów                             ;
; Autorzy        : Mateusz Woskowicz 208345,                                         ;
;			     : Krzysztof Jablonski 208345,                                  ;
;				 : sroda, 8:30                                              ;
;                                                                               ;
;===============================================================================;
*/

#include <iostream.h>
#include <fstream.h>
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <iomanip.h>
#include <string.h>
#include <math.h>

//definicje  typów:
typedef unsigned char BYTE;
typedef unsigned int WORD;
typedef unsigned int UINT;
typedef unsigned long DWORD;
typedef unsigned long LONG;

struct BITMAPFILEHEADER
{
    UINT bfType; //Opis formatu pliku. Musi być ‘BM’.
    DWORD bfSize; //Rozmiar pliku BMP w bajtach.
    UINT bfReserved1; //Zarezerwowane. Musi być równe 0.
    UINT bfReserved2; //Zarezerwowane. Musi być równe 0.
    DWORD bfOffBits; //Przesunięcie w bajtach początku danych
};

struct BITMAPINFOHEADER
{
    DWORD biSize; //Rozmiar struktury BITMAPINFOHEADER.
    LONG biWidth; //Szerokość bitmapy w pikselach.
    LONG biHeight; //Wysokość bitmapy w pikselach.
    WORD biPlanes; //Ilość płaszczyzn. Musi być 1.
    WORD biBitCount; //Głębia kolorów w bitach na piksel.
    DWORD biCompression; //Rodzaj kompresji (0 – brak).
    DWORD biSizeImage; //Rozmiar obrazu w bajtach. Uwaga może być 0.
    LONG biXPelsPerMeter;//Rozdzielczość pozioma w pikselach na metr.
    LONG biYPelsPerMeter;//Rozdzielczość pionowa w pikselach na metr.
    DWORD biClrUsed; //Ilość używanych kolorów z palety.
    DWORD biClrImportant; //Ilość kolorów z palety niezbędnych do
}; //wyświetlenia obrazu.

struct RGBQUAD //pojedynczy kolor jest opisany za pomocą struktury zwanej paletą kolorów. (256 kolorow)
{
    BYTE rgbBlue;  //każdy wpis znajdujacy sie w palecie opisuje składowe RGB koloru
    BYTE rgbGreen; //każda składowa może przyjmować wartości z przedziału od 0 do 63
    BYTE rgbRed;
    BYTE rgbReserved;
 };


FILE *bitmap_file; //Plik bitmapy
unsigned char  far* video_memory = (BYTE *)0xA0000000L; //Aby dokonać wpisu do pamięci ekranu (ustawić wartość wybranego piksela)
														//można posłużyć się wskaźnikiem dalekim:

void TrybGraficzny()
{
    REGPACK regs;
    regs.r_ax = 0x13; //Tryb 13h jest trybem graficznym obecnym w kartach VGA i nowszych. grafika o rozdzielczości 320 x 200
    intr(0x10, &regs); //0A000h:0000h i zajmuje dokładnie 640000 bajtów.
}

void TrybTekstowy()
{
    REGPACK regs;
    regs.r_ax = 0x10; //Tryb 10h jest trybem tekstowym
    intr(0x10, &regs);
}

int main()
{
    BITMAPFILEHEADER bmfh; //nagłowek nr 1 bitmapy
    BITMAPINFOHEADER bmih; //nagłowek nr 2 bitmapy
    RGBQUAD palette[256];

    int wybor_opcji,m,n,i,prog,numer,tmp,jasnosc;
    char* pathname[40];

    cout<<"Ktory obrazek wczytac?\n1.lena.bmp\n2.aero.bmp\n3.boat.bmp\n4.bridge.bmp\n ";
    cin>>numer;
    switch(numer)
    {
        case 1:
                *pathname = "C:\\borlandc\\bin\\lena.bmp";
                break;
        case 2:
                *pathname = "C:\\borlandc\\bin\\aero.bmp";
                break;
        case 3:
                *pathname = "C:\\borlandc\\bin\\boat.bmp";
                break;
        case 4:
                *pathname = "C:\\borlandc\\bin\\bridge.bmp";
                break;
        default:
                cout<<"Podano zla opcje, wybrano domyslnie plik lena.bmp.";
                *pathname = "C:\\borlandc\\bin\\lena.bmp";
                break;
    }

	//size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
	//ptr - wskaźnik na tablicę
	//size - rozmiar elementu tablicy
	//nitems - liczba elementów do odczytania
	//stream - plik, na którym wykonywana jest operacja

    bitmap_file = fopen(*pathname, "rb"); //otworz plik
    fread (&bmfh, sizeof(BITMAPFILEHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 1 i zapamiętaj w zmiennej bmfh
    fread (&bmih, sizeof(BITMAPINFOHEADER), 1, bitmap_file); ////odczytaj z pliku nagłówek nr 2 i zapamiętaj w zmiennej bmih
    fread(palette, sizeof(RGBQUAD), 256, bitmap_file);  //- wszystkich przekształceń dokonujemy na palecie
														//(ten sam efekt, jak byśmy dokonywali ich na pikselach obrazu). Pliku załadowanego do pamięci karty graficznej NIE ruszamy.

    cout<<"Program wykonujacy operacje na bitmapie\n1.Negacja\n2.Progowanie\n3.Zmiana jasnosci\nWybierz jedna z operacji: ";
    cin>>wybor_opcji;
    switch(wybor_opcji)
    {
		////////////////////////////Negacja/////////////////////////////////
        case 1:
        {
            cout<<"Przed zmiana:\n";
            getch(); //oczekiwanie na przycisk
            TrybGraficzny(); //wlaczenie trybu graficznego
            outportb(0x03C8, 0); //rozpocznij ustawianie palety od koloru nr 0
            for (i = 0; i < 255; i++) //ilość kolorów w palecie 8-bitowej
            {
                outp(0x03C9, palette[i].rgbRed * 63 / 255); //skalowana składowa R
                outp(0x03C9, palette[i].rgbGreen * 63 / 255); //skalowana składowa G
                outp(0x03C9, palette[i].rgbBlue * 63 / 255); //skalowana składowa B
            }

            for( m = 199; m >= 0;--m)
            {
                for( n = 0;n < 320; ++n)
                {
                    BYTE l; //definiujemy piksel
                    fread(&l,sizeof(BYTE),1, bitmap_file); //odczytaj piksel
                    video_memory[m * 320 + n] = l; //ustaw m*320 + n piksel obrazu na kolor l aktualnej palety karty VGA
                }
            }

            fclose(bitmap_file); //zamknij plik
            getch(); //oczekiwanie na przycisk

            TrybTekstowy(); //wlaczenie trybu tekstowego
            cout<<"Po zmianie:\n";
            getch();

            TrybGraficzny(); //wlaczenie trybu graficznego
            bitmap_file = fopen(*pathname, "rb"); //otwórz plik do odczytu w trybie binarnym "rb"
            fread (&bmfh, sizeof(BITMAPFILEHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 1 i zapamiętaj w zmiennej bmfh
            fread (&bmih, sizeof(BITMAPINFOHEADER), 1, bitmap_file);  //odczytaj z pliku nagłówek nr 2 i zapamiętaj w zmiennej bmih
            fread(palette, sizeof(RGBQUAD), 256, bitmap_file); //- wszystkich przekształceń dokonujemy na palecie
			//(ten sam efekt, jak byśmy dokonywali ich na pikselach obrazu). Pliku załadowanego do pamięci karty graficznej NIE ruszamy.
            outportb(0x03C8, 0); //rozpocznij ustawianie palety od koloru nr 0
            for (i = 0; i < 255; i++) //ilość kolorów w palecie 8-bitowej
            {
                outp(0x03C9, ~palette[i].rgbRed * 63 / 255); //skalowana składowa R
                outp(0x03C9, ~palette[i].rgbGreen * 63 / 255); //skalowana składowa G
                outp(0x03C9, ~palette[i].rgbBlue * 63 / 255); //skalowana składowa B
            }

            for( m = 199; m >= 0; --m)
            {
                for( n = 0; n < 320; ++n)
                {
                    BYTE l; //definiujemy piksel o 256 kolorach
                    fread(&l,sizeof(BYTE),1, bitmap_file); //czytamy piksel
                    video_memory[m * 320 + n] = l; ////ustaw m*320 + n piksel obrazu na kolor l aktualnej palety karty VGA
                }
            }
            fclose(bitmap_file); //zamykamy plik
            getch(); //czekamy na przycisk
            break;
        }
		////////////////////////////Progowanie/////////////////////////////////
        case 2:
            {
                cout<<"Podaj wartosc progu : (0 - 255)" <<endl;
                cin>>prog;
                if(prog < 0 || prog > 255)
                {
                     cout<<"Podano zla wartosc progu";
                     break;
                }
                else
                {
                    cout<<"Obraz przed progowaniem:";
                    getch();
                    TrybGraficzny();
                    bitmap_file = fopen(*pathname, "rb"); //otwórz plik do odczytu w trybie binarnym "rb"
                    fread (&bmfh, sizeof(BITMAPFILEHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 1 i zapamiętaj w zmiennej bmfh
                    fread (&bmih, sizeof(BITMAPINFOHEADER), 1, bitmap_file);  //odczytaj z pliku nagłówek nr 2 i zapamiętaj w zmiennej bmih
                    fread(palette, sizeof(RGBQUAD), 256, bitmap_file); //- wszystkich przekształceń dokonujemy na palecie
					//(ten sam efekt, jak byśmy dokonywali ich na pikselach obrazu). Pliku załadowanego do pamięci karty graficznej NIE ruszamy.

                    outportb(0x03C8, 0); //rozpocznij ustawianie palety od koloru nr 0
                    for (i = 0; i < 255; i++) //ilość kolorów w palecie 8-bitowej
                    {
                        outp(0x03C9, palette[i].rgbRed * 63 / 255); //skalowana składowa R
                        outp(0x03C9, palette[i].rgbGreen * 63 / 255); //skalowana składowa
                        outp(0x03C9, palette[i].rgbBlue * 63 / 255); //skalowana składowa B
                    }
                    for( m = 199; m >= 0;--m)
                    {
                        for( n = 0;n < 320; ++n)
                        {
                            BYTE l; //definiujemy piksel o 8-bitowej wartosci koloru
                            fread(&l,sizeof(BYTE),1, bitmap_file); //odczytujemy piksel
                            video_memory[m * 320 + n] = l; //ustaw m*320 + n piksel obrazu na kolor l aktualnej palety karty VGA
                        }
                    }
                fclose(bitmap_file); //zamknij plik
                getch(); //zatrzymuje dopoki uzytkownik nie wpisze znaku
                TrybTekstowy(); //przelacza do trybu tekstowego
                cout<<"Obraz po progowaniu:";
                getch(); //zatrzymuje dopoki uzytkownik nie wpisze znaku

                TrybGraficzny();  //przelacza do trybu graficznego
                bitmap_file = fopen(*pathname, "rb"); //otwórz plik do odczytu w trybie binarnym "rb"
                fread (&bmfh, sizeof(BITMAPFILEHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 1 i zapamiętaj w zmiennej bmfh
                fread (&bmih, sizeof(BITMAPINFOHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 2 i zapamiętaj w zmiennej bmih
                fread(palette, sizeof(RGBQUAD), 256, bitmap_file); // wszystkich przekształceń dokonujemy na palecie
					//(ten sam efekt, jak byśmy dokonywali ich na pikselach obrazu). Pliku załadowanego do pamięci karty graficznej NIE ruszamy.

                outportb(0x03C8, 0); //rozpocznij ustawianie palety od koloru nr 0
                for (i = 0; i < 255; i++) //ilość kolorów w palecie 8-bitowej
                {
                    outp(0x03C9, palette[i].rgbRed * 63 / 255); //skalowana składowa R
                    outp(0x03C9, palette[i].rgbGreen * 63 / 255); //skalowana składowa
                    outp(0x03C9, palette[i].rgbBlue * 63 / 255); //skalowana składowa B
                }

                for( m = 199; m >= 0; --m)
                {
                    for( n = 0; n < 320; ++n)
                        {
                            BYTE l; //definiujemy piksel
                            fread(&l,sizeof(BYTE),1, bitmap_file); //czytamy piksel
                            video_memory[m * 320 + n] = l; //ustaw m*320 + n piksel obrazu na kolor l aktualnej palety karty VGA
                            if(video_memory[m * 320 + n] < prog) //jesli wartośc koloru w pikselu video_memory jest mniejsza od progu
                            {
                                video_memory[m * 320 + n] = 0; //ustaw ja na zero
                            }
                        }
                }
                fclose(bitmap_file); //zamykamy plik
                getch(); //czekamy na przycisk
                }
                break;
        }
		////////////////////////////Rozjasnianie/////////////////////////////////
        case 3:
            {
                char t;
                int red,gre,blu;
                cout<<"Chcesz rozjasnic [t/T] czy przyciemnic [n/N/*]: ";
                cin>>t;
                if(t == 't' || t == 'T')
                {
                    cout<<"Obraz zostanie rozjasniony.\n";
                    cout<<"Podaj wartosc rozjasnienia(liczba calkowita 0-10): ";
                    cin>>jasnosc;
                if(jasnosc > 10)
                {
                    cout<<"Przyjeto wartosc: "<<jasnosc%10<<", gdyz ta podana byla bledna.\n";
                    jasnosc=jasnosc%10;
                    getch();
                }
                else
                  if(jasnosc < 0)
                  {
                    cout<<"Przyjeto wartosc: "<<jasnosc%10*(-1)<<", gdyz ta podana byla bledna.\n";
                    jasnosc=jasnosc%10*(-1);
                    getch();
                  }
              }
              else
              {
                cout<<"Obraz zostanie przyciemniony. \n";
                cout<<"Podaj wartosc przyciemnienia(liczba calkowita 0-10): ";
                cin>>jasnosc;
                if(jasnosc > 10)
                {
                  cout<<"Przyjeto wartosc: "<<jasnosc%10<<", gdyz ta podana byla bledna.\n";
                  jasnosc=jasnosc%10*(-1);
                }
                else
                  if(jasnosc < 0)
                  {
                    cout<<"Przyjeto wartosc: "<<jasnosc%10*(-1)<<", gdyz ta podana byla bledna.\n";
                    jasnosc=jasnosc%10;
                  }
                  else
                    jasnosc *= (-1);
            getch();
          }
            bitmap_file = fopen(*pathname, "rb"); //otworz plik
            fread (&bmfh, sizeof(BITMAPFILEHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 1 i zapamiętaj w zmiennej bmfh
            fread (&bmih, sizeof(BITMAPINFOHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 2 i zapamiętaj w zmiennej bmih
            fread(palette, sizeof(RGBQUAD), 256, bitmap_file); // wszystkich przekształceń dokonujemy na palecie
					//(ten sam efekt, jak byśmy dokonywali ich na pikselach obrazu). Pliku załadowanego do pamięci karty graficznej NIE ruszamy.
            TrybGraficzny(); //Wlaczamy tryb graficzny
            outportb(0x03C8, 0); //rozpocznij ustawianie palety od koloru nr 0

            for (i = 0; i < 255; i++) //ilość kolorów w palecie 8-bitowej
            {
                outp(0x03C9, palette[i].rgbRed * 63 / 255); //skalowana składowa R
                outp(0x03C9, palette[i].rgbGreen * 63 / 255); //skalowana składowa G
                outp(0x03C9, palette[i].rgbBlue * 63 / 255); //skalowana składowa B
            }

            for( m = 199; m >= 0;--m)
            {
                for( n = 0;n < 320; ++n)
                {
                    BYTE l; //definiujemy piksel 8-bitowy
                    fread(&l,sizeof(BYTE),1, bitmap_file); //czytamy go
                    video_memory[m * 320 + n] = l; //ustaw m*320 + n piksel obrazu na kolor l aktualnej palety karty VGA
                }
            }
            fclose(bitmap_file); //zamykamy plik (piksel)
            getch(); //czekamy na przycisk

            TrybTekstowy(); //wlaczamy tryb tekstowy
            cout<<"Po zmianie:\n";
            getch();  //czekamy na przycisk
            TrybGraficzny();  //wlaczamy tryb graficzny
            bitmap_file = fopen(*pathname, "rb");  //przelacza do trybu graficznego
            fread (&bmfh, sizeof(BITMAPFILEHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 1 i zapamiętaj w zmiennej bmfh
            fread (&bmih, sizeof(BITMAPINFOHEADER), 1, bitmap_file); //odczytaj z pliku nagłówek nr 2 i zapamiętaj w zmiennej bmih
            fread(palette, sizeof(RGBQUAD), 256, bitmap_file); // wszystkich przekształceń dokonujemy na palecie
					//(ten sam efekt, jak byśmy dokonywali ich na pikselach obrazu). Pliku załadowanego do pamięci karty graficznej NIE ruszamy.

            outportb(0x03C8, 0); //rozpocznij ustawianie palety od koloru nr 0
            for (i = 0; i < 255; i++) //ilość kolorów w palecie 8-bitowej
            {
                outp(0x03C9, palette[i].rgbRed * 63 / 255); //skalowana składowa R
                outp(0x03C9, palette[i].rgbGreen * 63 / 255); //skalowana składowa
                outp(0x03C9, palette[i].rgbBlue * 63 / 255); //skalowana składowa B
            }

            for (i = 200; i >= 0; --i)
            {
                for (int j = 0; j < 320; ++j)
                {
                    BYTE l; //definiujemy piksel 8-bitowy
                    fread(&l, sizeof(BYTE), 1, bitmap_file); //czytamy go
                    if(jasnosc > 0)
                    {
                        tmp = (256 - l) / 11; //odejmujemy wartosc piksela od 255 (max wartosci RGB - bialy), zeby obrazek stal sie jasniejszy i zapisujemy w zmiennej pomocniczej
                        tmp *= jasnosc; //mnozymy wartosc tymczasowa przez jasnosc
                    }
                    else if(jasnosc < 0)
                    {
                        tmp = l/11;
                        tmp *= jasnosc; //mnozymy wartosc tymczasowa przez jasnosc
                    }
                    l = l + tmp; //dodajemy wartosc tymczasowa jasmosci do piksela
                    video_memory[i * 320 + j] = l; //ustaw i*320 + j piksel obrazu na kolor l aktualnej palety karty VGA
                }
            }
            fclose(bitmap_file); //zamykamy plik
            getch(); //czekamy na przycisk
          break;
        }
        default:
        {
                cout<<"Podano zla opcje";
        }
    }
    //zamknij plik to na końcu
   // fclose(bitmap_file);
    TrybTekstowy();
    return 0;
}