---

/home/landauf/painter/miniproject/effects/effects.cpp

Go to the documentation of this file.

#include "effects.h"

// Endless Scrolling                                                         //
scroll::scroll(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    start.set(0, 0);
    glutSetWindowTitle("Paint Application | Scrolling");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);
    imageRgbaCopy(img, temp2);
    inActionState = false;
    this->idleAction();
    
}

void scroll::LBAction()
{
    if (LBpressed)
        start = mouse;
}

void scroll::RBAction()
{
    if (RBpressed)
        imageRgbaCopy(temp2, img);
}

void scroll::idleAction()
{
    if (LBpressed)
    {   
        ImageRGBA *swap;

        int dX, dY;
        dX = int(start.x - mouse.x);
        dY = int(start.y - mouse.y);
        while (dX < lowArea.x)
            dX += (highArea.x - lowArea.x + 1);
        while (dY < lowArea.y)
            dY += (highArea.y - lowArea.y + 1);

        while (dX > (highArea.x - lowArea.x))
            dX -= (highArea.x - lowArea.x + 1);
        while (dY > (highArea.y - lowArea.y))
            dY -= (highArea.y - lowArea.y + 1);


        if (!bArea)
        {            
            for (int row = 0; row < img->height; row++)
            {
                if (row < dY)
                {
                    memcpy(&temp->data[0 + (img->height - dY + row) * img->width], &img->data[dX + row * img->width], (img->width - dX) * sizeof(Rgba));
                    memcpy(&temp->data[(img->width - dX) + (img->height - dY + row) * img->width], &img->data[0 + row * img->width], dX * sizeof(Rgba));
                }
                else
                {
                    memcpy(&temp->data[0 + (row - dY) * img->width], &img->data[dX + row * img->width], (img->width - dX) * sizeof(Rgba));
                    memcpy(&temp->data[(img->width - dX) + (row - dY) * img->width], &img->data[0 + row * img->width], dX * sizeof(Rgba));
                }
            }
        }
        else
        {
//            imageRgbaCopy(img, temp);
            memcpy(&temp->data[0], &img->data[0], img->width * lowArea.y * sizeof(Rgba));
            for (int row = 0; row <= (highArea.y - lowArea.y); row++)
            {
                
                if (row < dY)
                {
                    
                    memcpy(&temp->data[lowArea.x + ((highArea.y + 1) - dY + row) * img->width], &img->data[(lowArea.x + dX) + (lowArea.y + row) * img->width], ((highArea.x + 1) - lowArea.x - dX) * sizeof(Rgba));
                    memcpy(&temp->data[((highArea.x + 1) - dX) + ((highArea.y + 1) - dY + row) * img->width], &img->data[lowArea.x + (lowArea.y + row) * img->width], (dX) * sizeof(Rgba));
                }
                else
                {
                    memcpy(&temp->data[lowArea.x + (lowArea.y + row - dY) * img->width], &img->data[(lowArea.x + dX) + (lowArea.y + row) * img->width], ((highArea.x + 1) - lowArea.x - dX) * sizeof(Rgba));
                    memcpy(&temp->data[((highArea.x + 1) - dX) + (lowArea.y + row - dY) * img->width], &img->data[lowArea.x + (lowArea.y + row) * img->width], (dX)* sizeof(Rgba));
                }
                memcpy(&temp->data[img->width * (lowArea.y + row)], &img->data[img->width * (lowArea.y + row)], lowArea.x * sizeof(Rgba));
                memcpy(&temp->data[(highArea.x + 1) + img->width * (lowArea.y + row)], &img->data[(highArea.x + 1) + img->width * (lowArea.y + row)], (img->width - (highArea.x + 1)) * sizeof(Rgba));
            }
            memcpy(&temp->data[img->width * (highArea.y + 1)], &img->data[img->width * (highArea.y + 1)], img->width * (img->height - (highArea.y + 1)) * sizeof(Rgba));
        }

        swap = img;    //
        img = temp;    // switch pointers instead of copying the whole picture back to img
        temp = swap;   //
        
        fwkSetDisplayImage(img); // now we changed the pointer, so we have to change the displayImage

        start = mouse;
    }
}

// Selection                                                                 //
selection::selection(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Selection");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);
}

void selection::LBAction()
{
    if (LBpressed)
    {
        startArea = mouse;
        endArea = mouse;
    }
} 

void selection::RBAction()
{
    if (RBpressed)
    {
        lowArea.set(0, 0);
        highArea.set(img->width - 1, img->height - 1);
        bArea = false;
    }
}

void selection::moveAction()
{
    if (LBpressed)
    {
        bArea = true;
        endArea = mouse;

        if (startArea.x <= endArea.x)
        {
            lowArea.x = startArea.x;
            highArea.x = endArea.x;
        }
        else
        {
            lowArea.x = endArea.x;
            highArea.x = startArea.x;
        }
    
        if (startArea.y <= endArea.y)
        {
            lowArea.y = startArea.y;
            highArea.y = endArea.y;
        }
        else
        {
            lowArea.y = endArea.y;
            highArea.y = startArea.y;
        }

        lowArea.x = int(limitX.forceLimit(lowArea.x));
        lowArea.y = int(limitY.forceLimit(lowArea.y));
        highArea.x = int(limitX.forceLimit(highArea.x));
        highArea.y = int(limitY.forceLimit(highArea.y));
    }
}


// Draw                                                                      //
draw::draw(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Draw");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);

    imageRgbaCopy(img, temp2);

    inActionState = false;
    numModes = 6;
    start.set(0, 0);
    end.set(0, 0);
    finalDraw = false;
    breakDraw = true;
    bColorMenu = true;
    myColor = (Rgba){255, 255, 255, 255};

    imageRgbaCopy(img, temp);
    this->changeMode(5);
}

void draw::colorChangeAction()
{
    this->RBAction();
}

void draw::idleAction()
{
    if (LBpressed || finalDraw || breakDraw)
    {
        // Pipette
        if (mode == 1 && mouse.x >= 0 && mouse.y >= 0 && mouse.x < img->width && mouse.y < img->height)
        {
            if (!finalDraw)
                myColor = img->data[mouse.x + img->width * mouse.y];   
        }
        
        // Point
        if (mode == 2)
        {
            if (!breakDraw)// && mouse.x >= lowArea.x && mouse.x <= highArea.x && mouse.y >= lowArea.y && mouse.y <= highArea.y)
                imageRgbaDrawLine(img, end.x, end.y, int(mouse.x), int(mouse.y), myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
        }
        
        // Line
        else if (mode == 3)
        {
            if (!breakDraw)
            {
                imageRgbaInvertLine(img, start.x, start.y, end.x, end.y);
                imageRgbaInvertLine(img, start.x, start.y, int(mouse.x), int(mouse.y));
            }
            else
            {
                imageRgbaCopy(temp, img);
                if (finalDraw)
                    imageRgbaDrawLine(img, start.x, start.y, end.x, end.y, myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
            }
        }
        
        // Rectangle
        else if (mode == 4)
        {
            if (!breakDraw)
            {
                imageRgbaInvertLine(img, start.x, start.y, start.x, end.y);
                imageRgbaInvertLine(img, start.x, start.y, end.x, start.y);
                imageRgbaInvertLine(img, end.x, start.y, end.x, end.y);
                imageRgbaInvertLine(img, start.x, end.y, end.x, end.y);

                imageRgbaDrawInvertedPoint(img, start.x, start.y);
                imageRgbaDrawInvertedPoint(img, start.x, end.y);
                imageRgbaDrawInvertedPoint(img, end.x, start.y);
                imageRgbaDrawInvertedPoint(img, end.x, end.y);

                imageRgbaInvertLine(img, start.x, start.y, start.x, int(mouse.y));
                imageRgbaInvertLine(img, start.x, start.y, int(mouse.x), start.y);
                imageRgbaInvertLine(img, int(mouse.x), start.y, int(mouse.x), int(mouse.y));
                imageRgbaInvertLine(img, start.x, int(mouse.y), int(mouse.x), int(mouse.y));

                imageRgbaDrawInvertedPoint(img, start.x, start.y);
                imageRgbaDrawInvertedPoint(img, start.x, int(mouse.y));
                imageRgbaDrawInvertedPoint(img, int(mouse.x), start.y);
                imageRgbaDrawInvertedPoint(img, int(mouse.x), int(mouse.y));
            }
            else
            {
                imageRgbaCopy(temp, img);
                if (finalDraw)
                {                
                    imageRgbaDrawLine(img, start.x, start.y, start.x, end.y, myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
                    imageRgbaDrawLine(img, start.x, start.y, end.x, start.y, myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
                    imageRgbaDrawLine(img, end.x, start.y, end.x, end.y, myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
                    imageRgbaDrawLine(img, start.x, end.y, end.x, end.y, myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
                }
            }
        }
        
        // Ellipse
        else if (mode == 5)
        {
            int a1 = int((end.x - start.x) / 2.0);
            int b1 = int((end.y - start.y) / 2.0);
            
            int a2 = int((int(mouse.x) - start.x) / 2.0);
            int b2 = int((int(mouse.y) - start.y) / 2.0);
            
            if (!breakDraw)
            {
                imageRgbaInvertEllipse(img, start.x + a1, start.y + b1, a1, b1);
                imageRgbaInvertEllipse(img, start.x + a2, start.y + b2, a2, b2);
            }
            else
            {
                imageRgbaCopy(temp, img);
                if (finalDraw)
                    imageRgbaDrawEllipse(img, start.x + a1, start.y + b1, a1, b1, myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
            }
        }
        
        // Circle
        else if (mode == 6)
        {
            int a1 = int(sqrt((end.x - start.x)*(end.x - start.x) + (end.y - start.y)*(end.y - start.y)));
            int a2 = int(sqrt((int(mouse.x) - start.x)*(int(mouse.x) - start.x) + (int(mouse.y) - start.y)*(int(mouse.y) - start.y)));
            
            if (!breakDraw)
            {
                imageRgbaInvertEllipse(img, start.x, start.y, a1, a1);
                imageRgbaInvertEllipse(img, start.x, start.y, a2, a2);
            }
            else
            {
                imageRgbaCopy(temp, img);
                if (finalDraw)
                    imageRgbaDrawEllipse(img, start.x, start.y, a1, a1, myColor, lowArea.x, lowArea.y, highArea.x, highArea.y);
            }
        }
        
        breakDraw = false;
        if (finalDraw)
        {
            imageRgbaCopy(img, temp);
            finalDraw = false;
        }
        end = mouse;
    }
    
}

void draw::LB(bool _state)
{
    bool buttonPressed = false;
    if (bMenu && _state)
        buttonPressed = this->useMenu(true);

    if (!buttonPressed)
    {    
        if (_state)
        {
            imageRgbaCopy(img, temp);
            start = mouse;
            end = mouse;
            LBpressed = true;
        }
        else
        {
            if (LBpressed)
            {
                breakDraw = true;
                finalDraw = true;
                LBpressed = false;
            }
        }
    }
}

void draw::RBAction()
{
    if (RBpressed)
    {
        if (LBpressed)
        {
            breakDraw = true;
            finalDraw = false;
            LBpressed = false;
        }
        else
            imageRgbaCopy(temp2, img);
    }
}

void draw::changeMode(char _mode)
{
    if (LBpressed)
    {
        breakDraw = true;
        finalDraw = false;
        this->idleAction();
        start = mouse;
        end = mouse;
        imageRgbaCopy(img, temp);
    }
    
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Draw | Mode 1: Pipette");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Draw | Mode 2: Point");
    else if (mode == 3)
        glutSetWindowTitle("Paint Application | Draw | Mode 3: Line");
    else if (mode == 4)
        glutSetWindowTitle("Paint Application | Draw | Mode 4: Rectangle");
    else if (mode == 5)
        glutSetWindowTitle("Paint Application | Draw | Mode 5: Ellipse");
    else if (mode == 6)
        glutSetWindowTitle("Paint Application | Draw | Mode 6: Circle");
}
// Telescope                                                                 //
telescope::telescope(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    start.set(0, 0);
    glutSetWindowTitle("Paint Application | Telescope");

    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);
    imageRgbaCopy(img, temp);
    inActionState = false;
    
    value1 = 100;
    limitValue1.set(10, 250);
    value2 = 2;
    limitValue2.set(2, 10);

    M[0] = new matrix ((float[9]) { 1, 2, 1,
                                    2, 4, 2,
                                    1, 2, 1 }, 1, 16);

    M[1] = new matrix ((float[9]) { 0, 1, 0,
                                    1, -4, 1,
                                    0, 1, 0 }, 1, 1);

    M[2] = new matrix ((float[9]) { 1, 0, -1,
                                    2, 0, -2,
                                    1, 0, -1 }, 1, 1);

    M[3] = new matrix ((float[9]) { 1, 2, 1,
                                    0, 0, 0,
                                    -1, -2, -1 }, 1, 1);


    numModes = 7;
    this->changeMode(1);
}

void telescope::LBAction()
{
    if (LBpressed)
    {
        start = mouse;
        imageRgbaCopy(img, temp);
        imageRgbaInvertEllipse(img, start.x, start.y, int(value1), int(value1));
    }
    else
    {
        imageRgbaInvertEllipse(img, start.x, start.y, int(value1), int(value1));
        imageRgbaCopy(temp, img);
    }
}

void telescope::idleAction()
{
    if (LBpressed)
    {
        imageRgbaInvertEllipse(img, start.x, start.y, int(value1), int(value1));
        for (int y = int(start.y - int(value1) - 1); y < int(start.y + int(value1) + 1); y++)
        {
            int xValue = int(sqrt((int(value1)*int(value1)) - ((y - start.y)*(y - start.y))));
            for (int x = int(start.x - xValue - 1); x < int(start.x + xValue + 1); x++)
            {
                if ((x >= 0) && (x < img->width) && (y >= 0) && (y < img->height))
                    img->data[x + img->width * y] = temp->data[x + img->width * y];
            }
        }
        for (int y = int(mouse.y - int(value1)); y < int(mouse.y + int(value1)); y++)
        {
            int xValue = int(sqrt((int(value1)*int(value1)) - ((y - mouse.y)*(y - mouse.y))));
            for (int x = (mouse.x - xValue); x < (mouse.x + xValue); x++)
            {
                if ((x >= 0) && (x < img->width) && (y >= 0) && (y < img->height))
                {
                    if (mode == 1)
                    {
                        float newX, newY;

                        newX = x - int(mouse.x);
                        newY = y - int(mouse.y);

                        if (value2 != 0)
                        {
                            newX = int(mouse.x) + ((float)newX / value2);
                            newY = int(mouse.y) + ((float)newY / value2);
                        }
                        else
                        {
                            newX = int(mouse.x) + newX;
                            newY = int(mouse.y) + newY;
                        }
                        if ((newX >= 0) && (newX < img->width) && (newY >= 0) && (newY < img->height))
                            img->data[x + img->width * y] = imageRgbaInterpolate(temp, newX, newY);
                        else
                            img->data[x + img->width * y] = (Rgba){0, 0, 0, 255};
                    }
                    if (mode == 2)
                    {
                        img->data[x + img->width * y] = applyMatrix(temp, M[0], x, y, point(0, 0), point(img->width, img->height));
                    }
                    if (mode == 3)
                    {
                        Rgba color1 = temp->data[x + img->width * y];
                        Rgba color2 = applyMatrix(temp, M[0], x, y, point(0, 0), point(img->width, img->height));
                        img->data[x + img->width * y] = (Rgba) { limitRGBA.intForceLimit(2 * color1.r - color2.r),
                                                                 limitRGBA.intForceLimit(2 * color1.g - color2.g),
                                                                 limitRGBA.intForceLimit(2 * color1.b - color2.b),
                                                                 255 };
                    }
                    if (mode == 4)
                    {
                        img->data[x + img->width * y] = applyMatrix(temp, M[1], x, y, point(0, 0), point(img->width, img->height));
                    }
                    if (mode == 5)
                    {
                        Rgba color1 = applyMatrix(temp, M[2], x, y, point(0, 0), point(img->width, img->height));
                        Rgba color2 = applyMatrix(temp, M[3], x, y, point(0, 0), point(img->width, img->height));
                        img->data[x + img->width * y] = (Rgba) { limitRGBA.intForceLimit(color1.r + color2.r),
                                                                 limitRGBA.intForceLimit(color1.g + color2.g),
                                                                 limitRGBA.intForceLimit(color1.b + color2.b),
                                                                 255 };
                    }
                    if (mode == 6)
                        img->data[x + img->width * y] = applyMatrix(temp, M[2], x, y, point(0, 0), point(img->width, img->height));
                    if (mode == 7)
                        img->data[x + img->width * y] = applyMatrix(temp, M[3], x, y, point(0, 0), point(img->width, img->height));
                }
            }
        }
        start = mouse;
        imageRgbaInvertEllipse(img, start.x, start.y, int(value1), int(value1));
    }
}

void telescope::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Telescope | Mode 1: Zoom");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Telescope | Mode 2: Gaussian Blur");
    else if (mode == 3)
        glutSetWindowTitle("Paint Application | Telescope | Mode 3: Gaussian Sharpen");
    else if (mode == 4)
        glutSetWindowTitle("Paint Application | Telescope | Mode 4: Laplace");
    else if (mode == 5)
        glutSetWindowTitle("Paint Application | Telescope | Mode 5: Sobel Combined");
    else if (mode == 6)
        glutSetWindowTitle("Paint Application | Telescope | Mode 6: Sobel Horizontal");
    else if (mode == 7)
        glutSetWindowTitle("Paint Application | Telescope | Mode 7: Sobel Vertical");
}

void telescope::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        value2 += 1;
    else if (_key == GLUT_KEY_DOWN)
        value2 -= 1;
    else if (_key == GLUT_KEY_RIGHT)
        value1 += 2;
    else if (_key == GLUT_KEY_LEFT)
        value1 -= 2;

    value1 = limitValue1.intForceLimit(value1);
    value2 = limitValue2.intForceLimit(value2);

    if (_key)
    {
        LB(false);
        LB(true);
    }
}

---