hdfjdhgj

#include <cmath>
#include <iostream>
#include <cstdlib>
#include <stack>
#include <QColorDialog>
#include <QColor>
#include "floodfill.h"
#include "ui_floodfill.h"

double const Pi = 3.14159265;

FloodFill::FloodFill(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::FloodFill)
{
    ui->setupUi(this);
    szer=ui->frame->width();
    wys=ui->frame->height();
    startX=ui->frame->x();
    startY=ui->frame->y();
    ilosc_katow=ui->ilosc_k->value();
    Kolor = Qt::black;

    obraz=new QImage(szer,wys,QImage::Format_RGB32);
    uchar *wskaznik;

    //CZYSTE POLE
    for (int i=0; i<wys; i++)
    {
        wskaznik = obraz->scanLine(i);
        for(int j=0; j<szer;j++)
        {
            wskaznik[4*j] = 255; //NIEBIESKI
            wskaznik[4*j+1] = 255; //ZIELONY
            wskaznik[4*j+2] = 255; //CZERWONY
        }
    }
}



FloodFill::~FloodFill()
{
    delete ui;
}

struct Piksel
{
    int x;
    int y;
    QColor kolorpixela;
};


void FloodFill::paintEvent(QPaintEvent *event)
{
    QPainter p(this);

    p.drawImage(startX,startY,*obraz);
}

void FloodFill::mousePressEvent(QMouseEvent *event)
{
    x0 = event->x() - startX;
    y0 = event->y() - startY;
}

void FloodFill::mouseReleaseEvent(QMouseEvent *event)
{
    x1 = event->x() - startX;
    y1 = event->y() - startY;

    if (Ksztalt==1 && Tryb==1) //ODCINEK
    {
        x1 = event->x() - startX;
        y1 = event->y() - startY;
        rysujodc(x0,y0,x1,y1,Kolor);
        update();
    }
    if (Ksztalt==2 && Tryb==1) //PROSTOKAT
    {
        rysujprostokat(x0,y0,x1,y1);
        update();
    }
    if (Ksztalt==3 && Tryb==1) //KOLO
    {
        double R=sqrt(pow(x1-x0,2)-pow(y1-y0,2));
        rysujkolo(x0,y0,R);
        update();
    }
    if (Ksztalt==4 && Tryb==1) //ELIPSA
    {
        rysujelipse(x0,y0,x1,y1);
        update();
    }
    if (Ksztalt==5 && Tryb==1) //WIELOKAT
    {
        rysujwielokat(x0,y0,x1,y1);
        update();
    }
    if(Tryb==2) {
        Kolor2 = Qt::blue;
        koloruj(x0,y0,Kolor,Kolor2);
    }
}

//NARZĘDZIA:
void FloodFill::on_quitbutton_clicked()
{
    qApp -> quit();
}

void FloodFill::on_wyczysc_clicked()
{
    wyczysc();
    update();
}

void FloodFill::on_odc_toggled(bool checked)
{
        Ksztalt=1;
}

void FloodFill::on_pros_toggled(bool checked)
{
        Ksztalt=2;
}

void FloodFill::on_kolo_toggled(bool checked)
{
        Ksztalt=3;
}

void FloodFill::on_elip_toggled(bool checked)
{
        Ksztalt=4;
}

void FloodFill::on_wiel_toggled(bool checked)
{
        Ksztalt=5;
}

void FloodFill::on_NONE_toggled(bool checked)
{
        Ksztalt=6;
}

void FloodFill::on_ilosc_k_valueChanged(int arg1)
{
    ilosc_katow = arg1;
}

void FloodFill::on_rysuj_toggled(bool checked)
{
    Tryb = 1;
}

void FloodFill::on_wypelnij_toggled(bool checked)
{
    Tryb = 2;
}

void FloodFill::on_paleta_clicked()
{
    Kolor = QColorDialog::getColor();
}

//FUNKCJE:
void FloodFill::wyczysc()
{
    uchar *wskaznik;

    //CZYSTE POLE
    for (int i=0; i<wys; i++)
    {
        wskaznik = obraz->scanLine(i);
        for(int j=0; j<szer;j++)
        {
            wskaznik[4*j] = 255; //NIEBIESKI
            wskaznik[4*j+1] = 255; //ZIELONY
            wskaznik[4*j+2] = 255; //CZERWONY
        }
    }
}

void FloodFill::wstawPiksel(int x, int y, int red = 0, int green = 0, int blue = 0)
{
    uchar *wskaznik;
    if(x>=0 && y>=0 && x<szer && y<wys)
    {
        wskaznik = obraz->scanLine(y);
        wskaznik[4*x] = blue; //NIEBIESKI
        wskaznik[4*x+1] = green; //ZIELONY
        wskaznik[4*x+2] = red; //CZERWONY
    }
}

void FloodFill::wstawPiksel(int x, int y, QColor Kolor)
{
    uchar *wskaznik;
    if(x>=0 && y>=0 && x<szer && y<wys)
    {
        wskaznik = obraz->scanLine(y);
        wskaznik[4*x] = Kolor.blue(); //NIEBIESKI
        wskaznik[4*x+1] = Kolor.green(); //ZIELONY
        wskaznik[4*x+2] = Kolor.red(); //CZERWONY
    }
}

QColor FloodFill::pobierzKolor(int x, int y)
{
    uchar *wskaznik;
    QColor wynik;
    wskaznik = obraz->scanLine(y);
    wynik.setBlue(wskaznik[4*x]);
    wynik.setGreen(wskaznik[4*x+1]);
    wynik.setRed(wskaznik[4*x+2]);
    return wynik;
}

void FloodFill::punkty(int x, int y, int x0, int y0)
{
    wstawPiksel(x+x0, y+y0, Kolor);
    wstawPiksel(y+x0, x+y0, Kolor);
    wstawPiksel(y+x0, -x+y0, Kolor);
    wstawPiksel(x+x0, -y+y0, Kolor);
    wstawPiksel(-y+x0, -x+y0, Kolor);
    wstawPiksel(-x+x0, -y+y0, Kolor);
    wstawPiksel(-y+x0, x+y0, Kolor);
    wstawPiksel(-x+x0, y+y0, Kolor);
}

void FloodFill::punktyE(int x, int y, int x0, int y0)
{
    wstawPiksel(x + x0, y + y0);
    wstawPiksel(x + x0, -y + y0);
    wstawPiksel(-x + x0, -y + y0);
    wstawPiksel(-x + x0, y + y0);
}

void FloodFill::rysujodc(int x0, int y0, int x1, int y1, QColor Kolor)
{
    if (Tryb==1)
    {
        int roznica, X, Y, a, b, bufX, bufY;
        int x = x0;
        int y = y0;

        if(x0 < x1)    {
            X = x1 - x0;
            bufX = 1;
        }
        else    {
            X = x0 - x1;
            bufX = -1;
        }

        if (y0 < y1)    {
            Y = y1 - y0;
            bufY = 1;
        }
        else    {
            Y = y0 - y1;
            bufY = -1;
        }
        wstawPiksel(x,y,Kolor);
        if(X > Y)    {
            b = Y * 2;
            a = (Y - X) * 2;
            roznica = a - X;
            while(x != x1)        {
                if(roznica >= 0)            {
                    roznica += a;
                    y += bufY;
                    x += bufX;
                }
                else            {
                    x += bufX;
                    roznica += b;
                }
                wstawPiksel(x,y,Kolor);
            }
        }
        else    {
            b = X * 2;
            a = (X - Y) * 2;
            roznica = b - Y;
            while (y != y1)        {
                if(roznica >= 0)            {
                    y += bufY;
                    roznica += a;
                    x += bufX;
                }
                else            {
                    y += bufY;
                    roznica += b;
                }
                wstawPiksel(x,y,Kolor);
            }
        }
    }
}

void FloodFill::rysujprostokat(int x0, int y0, int x1, int y1)
{
    if (Tryb==1)
    {

    }

}

void FloodFill::rysujkolo(int x0, int y0, double R)
{
    if (Tryb==1)
    {
        double const Pi = 3.14;
        double X, Y;
        double x=x0;
        double y=y0;

        double dX=0;
        double dY=0;

        if(x0 < x1)
        {
            X = x1 - x0;
        }
        else
        {
            X = x0 - x1;
        }

        if (y0 < y1)
        {
            Y = y1 - y0;
        }
        else
        {
            Y = y0 - y1;
        }

        R=sqrt(pow(x1-x0,2)-pow(y1-y0,2));

        for(;dX <= R; dX++)
        {
            dY = sqrt(R * R - dX * dX);
            punkty(dX, dY, x0, y0);
        }
    }
}

void FloodFill::rysujelipse(int x0, int y0, int x1, int y1)
{
    if (Tryb==1)
    {
        double x,y,a,b;

        a=sqrt(pow((x1-x0),2)+pow((y0-y0),2));
        b=sqrt(pow((x0-x0),2)+pow((y1-y0),2));

        for (double t=0; t < 2*Pi; t+=0.01)
        {
            x=a*cos(t);
            y=b*sin(t);

            wstawPiksel(x+x0,y+y0,Kolor);
            wstawPiksel(x+x0,-y+y0,Kolor);
            wstawPiksel(-x+x0,y+y0,Kolor);
            wstawPiksel(-x+x0,-y+y0,Kolor);
        }
    }
}

void FloodFill::rysujwielokat(int x0, int y0, int x1, int y1)
{
    if (Tryb==1)
    {
        double a,b;
        double x,y;
        double X,Y;

        a = sqrt(pow((x1-x0),2)+pow((y0-y0),2));
        b = sqrt(pow((x0-x0),2)+pow((y1-y0),2));

        X = a * cos(Pi/2);
        Y = b * sin(Pi/2);

        for (double t=0; t<=2*Pi; t+=((2*Pi)/(ilosc_katow)))
        {
            x=a*cos((Pi/2)+t);
            y=b*sin((Pi/2)+t);

            //wstawPiksel(x0+X,y0+Y,x0+x,y0+y);
            rysujodc(x0+X,y0+Y,x0+x,y0+y,Kolor);

            X=x;
            Y=y;
        }
    }
}

void FloodFill::koloruj(int x, int y, QColor Kolor, QColor Kolor2)
{
    std::cout << "before";
    if (Tryb==2)
    {
        std::cout << "after";
        Piksel bufor;
        std::stack<Piksel> Q;
        Piksel pixel;
        pixel.x=x;
        pixel.y=y;
        if (pobierzKolor(pixel.x,pixel.y)!=Kolor)
        {
            return;
        }
        Q.push(pixel);
        while (!Q.empty())
        {
            Piksel pixel = Q.top();
            Q.pop();
            if (pobierzKolor(pixel.x,pixel.y)==Kolor)
            {
                int w,e;
                w=pixel.x;
                e=pixel.x;
                while (pobierzKolor(w,pixel.y) == Kolor)
                {
                    w--;
                }
                while (pobierzKolor(e,pixel.y) == Kolor)
                {
                    e++;
                }
                for (int i=w+1; i<e; i++)
                {
                   // wstawPiksel(i,pixel.y,Kolor);
                    uchar *wskaznik;
                    wskaznik = obraz->scanLine(pixel.y);
                    wskaznik[4*i] = 122; //b
                    wskaznik[4*i+1] = 34; //g
                    wskaznik[4*i+2] = 251; //r
                }
                for (int i=w+1; i<e; i++)
                {
                    if (pobierzKolor(i,pixel.y+1)==Kolor)
                    {
                        bufor.x = i;
                        bufor.y = pixel.y+1;
                        Q.push(bufor);
                    }
                    if (pobierzKolor(i,pixel.y-1)==Kolor)
                    {
                        bufor.x = i;
                        bufor.y = pixel.y-1;
                        Q.push(bufor);
                    }
                }
            }
        }
    }
}