// Dolaczamy plik naglowkowy naszej klasy MyWindow
#include "mywindow.h"

// Dolaczamy plik naglowkowy zawierajacy definicje GUI
// Plik ten jest generowany automatycznie
// z pliku XML "mywindow.ui"
#include "ui_mywindow.h"
#include "QPicture"
// Definicja konstruktora, wywolujemy najpierw
// konstruktor klasy nadrzednej, nastepnie tworzymy
// obiekt klasy Ui_MyWindow reprezentujacy GUI
MyWindow::MyWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MyWindow)
{
    // Wywolujemy funkcje tworzaca elementy GUI
    // Jej definicja znajduje sie w pliku "ui_mywindow.h"
    ui->setupUi(this);

    // Pobieramy wymiary i wspolrzedne lewego gornego naroznika ramki
    // i ustawiamy wartosci odpowiednich pol
    // Uwaga: ramke "rysujFrame" wykorzystujemy tylko do
    // wygodnego ustaiwenia tych wymiarow. Rysunek bedziemy wyswietlac
    // bezposrednio w glownym oknie aplikacji.
    szer = ui->rysujFrame->width();
    wys = ui->rysujFrame->height();
    poczX = ui->rysujFrame->x();
    poczY = ui->rysujFrame->y() + 16;

    // Tworzymy obiekt klasy QImage, o odpowiedniej szerokosci
    // i wysokosci. Ustawiamy format bitmapy na 32 bitowe RGB
    // (0xffRRGGBB).
    //img = new QImage(szer,wys,QImage::Format_RGB32);
    pic[0] = new QImage(":/img1.jpg");
    pic[1] = new QImage(":/img2.jpeg");
    pic[2] = new QImage(":/img3.jpg");
    pic[3] = new QImage(":/img2.jpg");
    pic[4] = new QImage(":/img5.jpg");
    //img = new QImage(":/img1.jpg");
    img = new QImage(szer,wys,QImage::Format_RGB32);
    *img = img->scaled(640,360,Qt::KeepAspectRatio);
    unsigned char *ptr;
    ptr = img->bits();
    int szer = img->width();
    int wys = img->height();
    update();
    int i,j;
    for(i = 0; i < 5 ;i ++){
        oppacity[i] = 0.0;
        mode[i] = 0;
        on[i] = false;
    }

    for(i=0;i<wys;i++)
    {
            for(j=0;j<szer ;j++)
            {
                    ptr[szer*4*i + 4*j]=255;
                    ptr[szer*4*i + 4*j + 1] = 255;
                    ptr[szer*4*i + 4*j + 2] = 255;
            }
    }



}

// Definicja destruktora
MyWindow::~MyWindow()
{
    delete ui;
}

// Funkcja (slot) wywolywana po nacisnieciu przycisku "Wyjscie" (exitButton)
// Uwaga: polaczenie tej funkcji z sygnalem "clicked"
// emitowanym przez przycisk jest realizowane
// za pomoca funkcji QMetaObject::connectSlotsByName(MyWindow)
// znajdujacej sie w automatycznie generowanym pliku "ui_mywindow.h"
// Nie musimy wiec sami wywolywac funkcji "connect"
void MyWindow::on_exitButton_clicked()
{
    // qApp to globalny wskaznik do obiektu reprezentujacego aplikacje
    // quit() to funkcja (slot) powodujaca zakonczenie aplikacji z kodem 0 (brak bledu)
    qApp->quit();
}

QImage MyWindow::MultiplyMode(QImage *q1, QImage *q2){
    unsigned char *back;
    unsigned char *first;
    back = q1->bits();
    first = q2 -> bits();
    for(int i=0;i<wys;i++)
    {
            for(int j=0;j<szer ;j++)
            {

                back[szer*4*i + 4*j]=(back[szer*4*i + 4*j] * first[szer*4*i + 4*j]) >> 8;
                back[szer*4*i + 4*j + 1] = (back[szer*4*i + 4*j + 1] * first[szer*4*i + 4*j + 1]) >> 8;
                back[szer*4*i + 4*j + 2] = (back[szer*4*i + 4*j + 2] * first[szer*4*i + 4*j + 2]) >> 8;
            }
    }
    temp = q1;
    return *temp;
}
QImage MyWindow::ScreenMode(QImage *q1, QImage *q2){
    unsigned char *back;
    unsigned char *first;
    back = q1->bits();
    first = q2 -> bits();
    for(int i=0;i<wys;i++)
    {
            for(int j=0;j<szer ;j++)
            {
                back[szer*4*i + 4*j]=255 - ((255 - (back[szer*4*i + 4*j])) * ((255 - first[szer*4*i + 4*j])) >> 8);
                back[szer*4*i + 4*j + 1] = 255 - ((255 - (back[szer*4*i + 4*j + 1])) * ((255 - first[szer*4*i + 4*j + 1])) >> 8);
                back[szer*4*i + 4*j + 2] = 255 - ((255 - (back[szer*4*i + 4*j + 2])) * ((255 - first[szer*4*i + 4*j + 2])) >> 8);
            }
    }
    temp = q1;
    return *temp;
}
QImage MyWindow::OverlayMode(QImage *q1, QImage *q2){
    unsigned char *back;
    unsigned char *first;
    back = q1->bits();
    first = q2 -> bits();
    for(int i=0;i<wys;i++)
    {
            for(int j=0;j<szer ;j++)
            {
                if(back[szer*4*i + 4*j] < 128){
                   back[szer*4*i + 4*j]=(back[szer*4*i + 4*j] *  first[szer*4*i + 4*j] )>> 7;
                }
                else{
                   back[szer*4*i + 4*j]=255 - ((255 - back[szer*4*i + 4*j] * (255 - first[szer*4*i + 4*j]))>>7);
                }
                if(back[szer*4*i + 4*j + 1] < 128){
                   back[szer*4*i + 4*j + 1]=(back[szer*4*i + 4*j + 1] *  first[szer*4*i + 4*j + 1] )>> 7;
                }
                else{
                   back[szer*4*i + 4*j + 1]=255 - ((255 - back[szer*4*i + 4*j + 1] * (255 - first[szer*4*i + 4*j + 1]))>>7);
                }
                if(back[szer*4*i + 4*j + 2] < 128){
                   back[szer*4*i + 4*j + 2]=(back[szer*4*i + 4*j + 2] *  first[szer*4*i + 4*j + 2] )>> 7;
                }
                else{
                   back[szer*4*i + 4*j + 2]=255 - ((255 - back[szer*4*i + 4*j + 2] * (255 - first[szer*4*i + 4*j + 2]))>>7);
                }

            }
    }
    temp = q1;
    return *temp;
}
QImage MyWindow::DarkenMode(QImage *q1, QImage *q2){
    unsigned char *back;
    unsigned char *first;
    back = q1->bits();
    first = q2 -> bits();
    for(int i=0;i<wys;i++)
    {
            for(int j=0;j<szer ;j++)
            {
                if(back[szer*4*i + 4*j] < first[szer*4*i + 4*j]){
                   back[szer*4*i + 4*j] = back[szer*4*i + 4*j];
                }
                else{
                   back[szer*4*i + 4*j] = first[szer*4*i + 4*j];
                }
                if(back[szer*4*i + 4*j + 1] < first[szer*4*i + 4*j + 1]){
                   back[szer*4*i + 4*j + 1] = back[szer*4*i + 4*j + 1];
                }
                else{
                   back[szer*4*i + 4*j + 1 ] = first[szer*4*i + 4*j + 1];
                }
                if(back[szer*4*i + 4*j + 2] < first[szer*4*i + 4*j + 2]){
                   back[szer*4*i + 4*j + 2] = back[szer*4*i + 4*j + 2];
                }
                else{
                   back[szer*4*i + 4*j + 2] = first[szer*4*i + 4*j + 2];
                }
            }
    }
    temp = q1;
    return *temp;
}
QImage MyWindow::LightenMode(QImage *q1, QImage *q2){
    unsigned char *back;
    unsigned char *first;
    back = q1->bits();
    first = q2 -> bits();
    for(int i=0;i<wys;i++)
    {
            for(int j=0;j<szer ;j++)
            {
                if(back[szer*4*i + 4*j] > first[szer*4*i + 4*j]){
                   back[szer*4*i + 4*j] = back[szer*4*i + 4*j];
                }
                else{
                   back[szer*4*i + 4*j] = first[szer*4*i + 4*j];
                }
                if(back[szer*4*i + 4*j + 1] > first[szer*4*i + 4*j + 1]){
                   back[szer*4*i + 4*j + 1] = back[szer*4*i + 4*j + 1];
                }
                else{
                   back[szer*4*i + 4*j + 1 ] = first[szer*4*i + 4*j + 1];
                }
                if(back[szer*4*i + 4*j + 2] > first[szer*4*i + 4*j + 2]){
                   back[szer*4*i + 4*j + 2] = back[szer*4*i + 4*j + 2];
                }
                else{
                   back[szer*4*i + 4*j + 2] = first[szer*4*i + 4*j + 2];
                }
            }
    }
    temp = q1;
    return *temp;
}
QImage MyWindow::DifferenceMode(QImage *q1, QImage *q2){
    unsigned char *back;
    unsigned char *first;
    back = q1->bits();
    first = q2 -> bits();
    for(int i=0;i<wys;i++)
    {
            for(int j=0;j<szer ;j++)
            {
                back[szer*4*i + 4*j]=abs(back[szer*4*i + 4*j] - first[szer*4*i + 4*j]);
                back[szer*4*i + 4*j + 1] = abs(back[szer*4*i + 4*j + 1] - first[szer*4*i + 4*j + 1]);
                back[szer*4*i + 4*j + 2] = abs(back[szer*4*i + 4*j + 2] - first[szer*4*i + 4*j + 2]);
            }
    }
    temp = q1;
    return *temp;
}
// Funkcja "odmalowujaca" komponent
void MyWindow::paintEvent(QPaintEvent*)
{
    // Obiekt klasy QPainter pozwala nam rysowac na komponentach
    QPainter p(this);
    // Rysuje obrazek "img" w punkcie (poczX,poczY)
    // (tu bedzie lewy gorny naroznik)
    p.drawImage(poczX,poczY, *img);

}


// Funkcja (slot) wywolywana po nacisnieciu przycisku "Czysc" (cleanButton)
void MyWindow::on_cleanButton_clicked()
{
    // Funkcja czysci (zamalowuje na bialo) obszar rysowania
    // definicja znajduje sie ponizej
    czysc();

    // Funkcja "update()" powoduje ponowne "namalowanie" calego komponentu
    // Wywoluje funkcje "paintEvent"
    update();
}


// Funkcja (slot) wywolywana po nacisnieciu przycisku "Rysuj 1" (draw1Button)


void MyWindow::czysc()
{
    // Wskaznik za pomoca, ktorego bedziemy modyfikowac obraz
    unsigned char *ptr;

    // Funkcja "bits()" zwraca wskaznik do pierwszego piksela danych
    ptr = img->bits();

    int i,j;

    // Przechodzimy po wszystkich wierszach obrazu
    for(i=0; i<wys; i++)
    {
        // Przechodzimy po pikselach danego wiersza
        // W kazdym wierszu jest "szer" pikseli (tzn. 4 * "szer" bajtow)
        for(j=0; j<szer; j++)
        {
            ptr[szer*4*i + 4*j]=255; // Skladowa BLUE
            ptr[szer*4*i + 4*j + 1] = 255; // Skladowa GREEN
            ptr[szer*4*i + 4*j + 2] = 255; // Skladowa RED
        }
    }
}


// Funkcja powoduje zamalowanie obszaru rysowania pewnym wzorem


// Funkcja (slot) wywolywana po nacisnieciu przycisku myszy (w glownym oknie)
void MyWindow::mousePressEvent(QMouseEvent *event)
{
    // Pobieramy wspolrzedne punktu klikniecia
    int x= event->x();
    int y = event->y();

    // Sa to wspolrzedne wzgledem glownego okna,
    // Musimy odjac od nich wpolrzedne lewego gornego naroznika rysunku

    x -= poczX;
    y -= poczY;

    int kolor = 0;
    unsigned char *ptr;
    ptr = img->bits();

    // Sprawdzamy ktory przycisk myszy zostal klkniety
    if(event->button() == Qt::LeftButton)
    {
        // jezeli lewy to ustawiamy kolor na czarny
        kolor = 255;

    }
    else
    {
        // jezeli prawy to ustawiamy kolor na bialy
        kolor = 255;
    }

    // Sprawdzamy czy klikniecie nastapilo w granicach rysunku
/*
    if ((x>=0)&&(y>=0)&&(x<szer)&&(y<wys))
    {

        // Ustawiamy kolor kliknietego piksela na bialy lub czarny
        ptr[szer*4*y + 4*x] = 255;
        ptr[szer*4*y + 4*x + 1] = 255;
        ptr[szer*4*y + 4*x + 2] = 255;
    }

  */      // Ustawiamy kolor kliknietego piksela na bialy lub czarny


    // Odswiezamy komponent
    update();

}


void MyWindow::on_checkBox_stateChanged(int arg1)
{
    if(arg1 == 2){
        on[0] = true;
        run();
    }
    else{
        on[0] = false;
        run();
    }

}
bool MyWindow::sprawdz(bool tab[]){
    for(int i = 0 ; i < 5 ; i++){
        if(tab[i] == true)
            return false;
    }
    return true;
}
void MyWindow::on_checkBox_2_stateChanged(int arg1)
{
    if(arg1 == 2){
        on[1] = true;
        run();
    }
    else{
        on[1] = false;
        run();
    }
}

void MyWindow::on_checkBox_3_stateChanged(int arg1)
{
    if(arg1 == 2){
        on[2] = true;
        run();
    }
    else{
        on[2] = false;
        run();
    }
}

void MyWindow::on_checkBox_4_stateChanged(int arg1)
{
    if(arg1 == 2){
        on[3] = true;
        run();
    }
    else{
        on[3] = false;
        run();
    }
}

void MyWindow::on_checkBox_5_stateChanged(int arg1)
{
    if(arg1 == 2){
        on[4] = true;
        run();
    }
    else{
        on[4] = false;
        run();
    }
}
void MyWindow::run(){
    int n = 0;
    for(int i = 4 ; i >= 0 ; i--){
        if(on[i] == true){
            n++;
            if(mode[i] == 0){
                unsigned char* a = img->bits();
                QImage *picture = pic[i];

                *picture = picture->scaled(640,360,Qt::KeepAspectRatio);
                unsigned char* b = picture->bits();
                for(int x=0;x<wys;x++)
                {
                        for(int y=0;y<szer ;y++)
                        {
                            a[szer*4*x + 4*y] = oppacity[i] * b[szer*4*x + 4*y] + (1 - oppacity[i]) * a[szer*4*x + 4*y];
                            a[szer*4*x + 4*y + 1] = oppacity[i] * b[szer*4*x + 4*y + 1] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 1];
                            a[szer*4*x + 4*y + 2] = oppacity[i] * b[szer*4*x + 4*y + 2] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 2];


                    }
                }

            }
            if(mode[i] == 1){
                unsigned char* a = img->bits();
                QImage tmp = MultiplyMode(img,pic[i]);
                unsigned char* b = tmp.bits();
                for(int x=0;x<wys;x++)
                {
                        for(int y=0;y<szer ;y++)
                        {
                            a[szer*4*x + 4*y] = oppacity[i] * b[szer*4*x + 4*y] + (1 - oppacity[i]) * a[szer*4*x + 4*y];
                            a[szer*4*x + 4*y + 1] = oppacity[i] * b[szer*4*x + 4*y + 1] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 1];
                            a[szer*4*x + 4*y + 2] = oppacity[i] * b[szer*4*x + 4*y + 2] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 2];
                        }
                }
            }
            if(mode[i] == 2){
                unsigned char* a = img->bits();
                QImage tmp = ScreenMode(img,pic[i]);
                unsigned char* b = tmp.bits();
                for(int x=0;x<wys;x++)
                {
                        for(int y=0;y<szer ;y++)
                        {
                            a[szer*4*x + 4*y] = oppacity[i] * b[szer*4*x + 4*y] + (1 - oppacity[i]) * a[szer*4*x + 4*y];
                            a[szer*4*x + 4*y + 1] = oppacity[i] * b[szer*4*x + 4*y + 1] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 1];
                            a[szer*4*x + 4*y + 2] = oppacity[i] * b[szer*4*x + 4*y + 2] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 2];
                        }
                }
            }
            if(mode[i] == 3){
                unsigned char* a = img->bits();
                QImage tmp = DarkenMode(img,pic[i]);
                unsigned char* b = tmp.bits();
                for(int x=0;x<wys;x++)
                {
                        for(int y=0;y<szer ;y++)
                        {
                            a[szer*4*x + 4*y] = oppacity[i] * b[szer*4*x + 4*y] + (1 - oppacity[i]) * a[szer*4*x + 4*y];
                            a[szer*4*x + 4*y + 1] = oppacity[i] * b[szer*4*x + 4*y + 1] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 1];
                            a[szer*4*x + 4*y + 2] = oppacity[i] * b[szer*4*x + 4*y + 2] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 2];
                        }
                }
            }
            if(mode[i] == 4){
                unsigned char* a = img->bits();
                QImage tmp = LightenMode(img,pic[i]);
                unsigned char* b = tmp.bits();
                for(int x=0;x<wys;x++)
                {
                        for(int y=0;y<szer ;y++)
                        {
                            a[szer*4*x + 4*y] = oppacity[i] * b[szer*4*x + 4*y] + (1 - oppacity[i]) * a[szer*4*x + 4*y];
                            a[szer*4*x + 4*y + 1] = oppacity[i] * b[szer*4*x + 4*y + 1] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 1];
                            a[szer*4*x + 4*y + 2] = oppacity[i] * b[szer*4*x + 4*y + 2] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 2];
                        }
                }
            }
            if(mode[i] == 5){
                unsigned char* a = img->bits();
                QImage tmp = DifferenceMode(img,pic[i]);
                unsigned char* b = tmp.bits();
                for(int x=0;x<wys;x++)
                {
                        for(int y=0;y<szer ;y++)
                        {
                            a[szer*4*x + 4*y] = oppacity[i] * b[szer*4*x + 4*y] + (1 - oppacity[i]) * a[szer*4*x + 4*y];
                            a[szer*4*x + 4*y + 1] = oppacity[i] * b[szer*4*x + 4*y + 1] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 1];
                            a[szer*4*x + 4*y + 2] = oppacity[i] * b[szer*4*x + 4*y + 2] + (1 - oppacity[i]) * a[szer*4*x + 4*y + 2];
                        }
                }
            }
        }
        update();
    }
    if(n == 0){
           unsigned char* a = img->bits();
        for(int x=0;x<wys;x++)
        {
                for(int y=0;y<szer ;y++)
                {
                    a[szer*4*x + 4*y] = 255;
                    a[szer*4*x + 4*y + 1] = 255;
                    a[szer*4*x + 4*y + 2] = 255;
                }
        }
        update();
    }
}
void MyWindow::on_horizontalSlider_sliderMoved(int position)
{
    oppacity[0] = (double) position / 100;
    run();
}
void MyWindow::on_horizontalSlider_2_sliderMoved(int position)
{
     oppacity[1] = (double) position / 100;
     run();
}

void MyWindow::on_horizontalSlider_3_sliderMoved(int position)
{
    oppacity[2] = (double) position / 100;
    run();
}

void MyWindow::on_horizontalSlider_4_sliderMoved(int position)
{
    oppacity[3] = (double) position / 100;
    run();
}


void MyWindow::on_horizontalSlider_5_sliderMoved(int position)
{
    oppacity[4] = (double) position / 100;
    run();
}

void MyWindow::on_comboBox_activated(int index)
{
    mode[0] = index;
    run();
}

void MyWindow::on_comboBox_2_activated(int index)
{
    mode[1] = index;
    run();
}

void MyWindow::on_comboBox_3_activated(int index)
{
    mode[2] = index;
    run();
}

void MyWindow::on_comboBox_4_activated(int index)
{
    mode[3] = index;
    run();
}

void MyWindow::on_comboBox_5_activated(int index)
{
    mode[4] = index;
    run();
}