---

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

Go to the documentation of this file.

#include "artistic.h"

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

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

    value1 = 4;
    limitValue1.set(1, 20);
    value2 = 4;
    limitValue2.set(0, 100);
    
    imageRgbaCopy(img, temp);
   
    numModes = 2;
    this->changeMode(2);
}

void chrome::LBAction()
{
    if (LBpressed)
    {
        int newColor, location;
        imageRgbaCopy(temp, temp2);
        gaussian(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value2, mode);

        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                newColor = temp2->data[location].r + temp2->data[location].g + temp2->data[location].b;
                newColor = int(value1 / 2 * newColor);
                while (newColor < 0 || newColor > 255)
                {
                    if (newColor > 255)
                        newColor = 511 - newColor;
                    else if (newColor < 0)
                        newColor = abs(newColor);
                }
                img->data[location].r = newColor;
                img->data[location].g = newColor;
                img->data[location].b = newColor;
            }
        }
    }
}

void chrome::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Chrome | Mode 1: Simple");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Chrome | Mode 2: Gaussian");
        
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

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

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

    value1 = 10;
    limitValue1.set(0, 50);
    value2 = 10;
    limitValue2.set(1, 50);
    
    bColorMenu = true;
    myColor = (Rgba){0, 0, 0, 255};

    opacity = 1;
        
    imageRgbaCopy(img, temp);
    numModes = 2;
    mode = 1;
    this->changeMode(1);
}

void relief::LBAction()
{
    if (LBpressed)
    {
        imageRgbaCopy(temp, temp2);
        gaussian(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, mode);

        float newValue1 = 255 / value2;
        int location;
        
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                img->data[location].r = limitRGBA.intForceLimit(int((temp2->data[location].r + (newValue1 / 2)) / newValue1) * newValue1);
                img->data[location].g = limitRGBA.intForceLimit(int((temp2->data[location].g + (newValue1 / 2)) / newValue1) * newValue1);
                img->data[location].b = limitRGBA.intForceLimit(int((temp2->data[location].b + (newValue1 / 2)) / newValue1) * newValue1);
            }
        }
        Rgba color, nearColor, borderColor;
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                color = img->data[location];
                borderColor.r = limitRGBA.intForceLimit(((1 - opacity) * img->data[location].r) + (opacity * myColor.r));
                borderColor.g = limitRGBA.intForceLimit(((1 - opacity) * img->data[location].g) + (opacity * myColor.g));
                borderColor.b = limitRGBA.intForceLimit(((1 - opacity) * img->data[location].b) + (opacity * myColor.b));
                borderColor.a = 255;
                
                if (x >= 1)
                {
                    nearColor = img->data[(x-1) + img->width * y];
                    if (color.r != nearColor.r || color.g != nearColor.g || color.b != nearColor.b)
                        if (nearColor.r != borderColor.r || nearColor.g != borderColor.g || nearColor.b != borderColor.b)
                            img->data[location] = borderColor;
                }
                if (y >= 1)
                {
                    nearColor = img->data[x + img->width * (y - 1)];
                    if (color.r != nearColor.r || color.g != nearColor.g || color.b != nearColor.b)
                        if (nearColor.r != borderColor.r || nearColor.g != borderColor.g || nearColor.b != borderColor.b)
                            img->data[location] = borderColor;
                }
            }
        }
    }
}

void relief::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Relief | Mode 1: Simple");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Relief | Mode 2: Gaussian");
        
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

void relief::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        value1 += 1;
    else if (_key == GLUT_KEY_DOWN)
        value1 -= 1;
    else if (_key == GLUT_KEY_RIGHT)
        value2 += 1;
    else if (_key == GLUT_KEY_LEFT)
        value2 -= 1;
    else if (_key == GLUT_KEY_END)
    {
        if (opacity > 0)
            opacity = 0;
        else
            opacity = 1;
    }
    else if (_key == GLUT_KEY_PAGE_DOWN)
    {
        opacity += 0.1;
        if (opacity > 1)
            opacity = 1;
    }
            
    value1 = limitValue1.intForceLimit(value1);
    value2 = limitValue2.intForceLimit(value2);

    if (_key)
    {
        if (!LBpressed)
        {
            LBpressed = true;
            this->LBAction();
            LBpressed = false;
        }
        else
            this->LBAction();
    }
}

void relief::key(unsigned char _key)
{
    inAction = inActionState;

    if (_key == ' ')
        bMenu = !bMenu;

    if (_key == 127)
    {
        opacity -= 0.1;
        if (opacity < 0)
            opacity = 0;
            
        if (!LBpressed)
        {
            LBpressed = true;
            this->LBAction();
            LBpressed = false;
        }
        else
            this->LBAction();
    }
}

void relief::specialKey(int _key)
{
    inAction = inActionState;

    if (_key <= numModes)
        this->changeMode(_key);
        
    if (_key == GLUT_KEY_LEFT || _key == GLUT_KEY_RIGHT || _key == GLUT_KEY_UP || _key == GLUT_KEY_DOWN || _key == GLUT_KEY_END || _key == GLUT_KEY_PAGE_DOWN)
        this->changeValue(_key);
}

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

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

    value1 = 5;
    limitValue1.set(0, 100);
    value2 = 200;
    limitValue2.set(0, 255);
    
    imageRgbaCopy(img, temp);
    
    numModes = 2;
    this->changeMode(1);
}

void bw::LBAction()
{
    if (LBpressed)
    {
        imageRgbaCopy(temp, temp2);
        
        int location, MAX;
        Rgba up, down, left, right;
        int finalColor;
        
        if (mode == 2)
        {
            for (int y = lowArea.y; y <= highArea.y; y++)
            {
                for (int x = lowArea.x; x <= highArea.x; x++)
                {
                    location = x + img->width * y;
                    if (x >= (lowArea.x + value1))
                        left = temp->data[int(x-value1) + img->width * y];
                    else
                        left = temp->data[lowArea.x + img->width * y];

                    if (x < (highArea.x - value1))
                        right = temp->data[int(x+value1) + img->width * y];
                    else
                        right = temp->data[highArea.x + img->width * y];

                    if (y >= (lowArea.y + value1))
                        up = temp->data[x + img->width * int(y-value1)];
                    else
                        up = temp->data[x + img->width * lowArea.y];

                    if (y < (highArea.y - value1))
                        down = temp->data[x + img->width * int(y+value1)];
                    else
                        down = temp->data[x + img->width * highArea.y];
                        
                    finalColor = (abs(left.r - right.r) + abs(up.r - down.r)) + (abs(left.g - right.g) + abs(up.g - down.g)) + (abs(left.b - right.b) + abs(up.b - down.b));
                    temp2->data[location].r = limitRGBA.intForceLimit(finalColor);
                    temp2->data[location].g = limitRGBA.intForceLimit(finalColor);
                    temp2->data[location].b = limitRGBA.intForceLimit(finalColor);
                }
            }
        }
        
        gaussian(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, 1);

        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                
                MAX = temp2->data[location].r;
                if (temp2->data[location].g > MAX)
                    MAX = temp2->data[location].g;
                if (temp2->data[location].b > MAX)
                    MAX = temp2->data[location].b;
                    
                if (MAX <= value2)
                    img->data[location] = (Rgba){0, 0, 0, 255};
                else
                    img->data[location] = (Rgba){255, 255, 255, 255};
            }
        }
    }
}

void bw::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Black and White | Mode 1: Brightness");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Black and White | Mode 2: Edge");
        
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

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

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

    value1 = 15;
    limitValue1.set(0, 100);
    value2 = 40;
    limitValue2.set(0, 255);
    
    strength = 10;
    imageRgbaCopy(img, temp);
    
    bColorMenu = true;
    myColor = (Rgba){255, 0, 128, 255};
    
    numModes = 6;
    this->changeMode(1);
}

void starlight::LBAction()
{
    if (LBpressed)
    {
        imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){0, 0, 0, 0});
        float newStrength = ((float)strength / 10)*((float)strength / 10);
        int location, MAX;
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                
                MAX = temp->data[location].r;
                if (temp->data[location].g > MAX)
                    MAX = temp->data[location].g;
                if (temp->data[location].b > MAX)
                    MAX = temp->data[location].b;
                    
                if (MAX >= (255-value2))
                {
                    if (mode <= 3)
                        temp2->data[location] = temp->data[location];
                    else
                        temp2->data[location] = myColor;
                    temp2->data[location].a = 255;
                }
                else
                    temp2->data[location] = (Rgba){0,0,0,0};
//                    temp2->data[location].a = 0;
            }
        }
        if ((mode % 3) == 1 || (mode % 3) == 2)
        {
            horizontal_blur(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, mode, 1);
            vertical_blur(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, mode, 2);
        }
        if ((mode % 3) == 1 || (mode % 3) == 0)
        {
            motion_blur(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, 45, mode, 2);
            motion_blur(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, 135, mode, 2);
        }

        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                img->data[location].r = limitRGBA.intForceLimit(temp->data[location].r + ((float)(img->data[location].a)/255) * newStrength * img->data[location].r);
                img->data[location].g = limitRGBA.intForceLimit(temp->data[location].g + ((float)(img->data[location].a)/255) * newStrength * img->data[location].g);
                img->data[location].b = limitRGBA.intForceLimit(temp->data[location].b + ((float)(img->data[location].a)/255) * newStrength * img->data[location].b);
                img->data[location].a = 255;
//                img->data[location] = temp2->data[location];
            }
        }
        display = img;
        this->refreshImage();
    }
}

void starlight::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Starlight | Mode 1: Star");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Starlight | Mode 2: Cross");
    else if (mode == 3)
        glutSetWindowTitle("Paint Application | Starlight | Mode 3: X");
    else if (mode == 4)
        glutSetWindowTitle("Paint Application | Starlight | Mode 4: Colorized Star");
    else if (mode == 5)
        glutSetWindowTitle("Paint Application | Starlight | Mode 5: Colorized Cross");
    else if (mode == 6)
        glutSetWindowTitle("Paint Application | Starlight | Mode 6: Colorized X");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

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

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

    value1 = 15;
    limitValue1.set(0, 200);
    value2 = 40;
    limitValue2.set(0, 255);

    strength = 10;
    imageRgbaCopy(img, temp);

    bColorMenu = true;
    myColor = (Rgba){230, 155, 0, 255};

    numModes = 2;

    this->changeMode(1);
}

void shine::LBAction()
{
    if (LBpressed)
    {
        imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){0, 0, 0, 0});
        float newStrength = ((float)strength / 10)*((float)strength / 10);
        int location, MAX;
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;

                MAX = temp->data[location].r;
                if (temp->data[location].g > MAX)
                    MAX = temp->data[location].g;
                if (temp->data[location].b > MAX)
                    MAX = temp->data[location].b;

                if (MAX >= (255-value2))
                {
                    if (mode == 1)
                        temp2->data[location] = temp->data[location];
                    else if (mode == 2)
                        temp2->data[location] = myColor;
                    temp2->data[location].a = 255;
                }
                else
                    temp2->data[location] = (Rgba){0,0,0,0};
            }
        }

        // radial blur
        int newX, newY;
        imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){0, 0, 0, 0});
        float radius, angle;
        int maxY;
        int newValue1;
        int oldValue1, olderValue1;

        int R, G, B, A, count;
        point middle = mouse;

        // upper left quadrant
        for (int x = lowArea.x; x <= middle.x; x++)
        {
            if (x != lowArea.x)
                maxY = lowArea.y;
            else
                maxY = middle.y;

            for (int y = lowArea.y; y <= maxY; y++)
            {
                newX = (middle.x - x);
                newY = (middle.y - y);
                radius = sqrt(newX*newX + newY*newY);
                angle = atan((float)abs(newX) / abs(newY));
                newValue1 = 0;
                for (int r = 0; r <= (radius + value1); r++)
                {
                    olderValue1 = oldValue1;
                    oldValue1 = newValue1;
                    newValue1 = int((float)r / (radius + value1) * value1);
                    if (r == 0)
                    {
                        R = 0;
                        G = 0;
                        B = 0;
                        A = 0;
                        count = 0;
                    }
                    else if (r >= newValue1 && olderValue1 == newValue1)
                    {
                        // SUBTRACT
                        int r2 = r - 1;
                        newX = int(middle.x - sin(angle)*(r2-2*newValue1));
                        newY = int(middle.y - cos(angle)*(r2-2*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count--;
                            R -= temp2->data[location].r;
                            G -= temp2->data[location].g;
                            B -= temp2->data[location].b;
                            A -= temp2->data[location].a;
                        }
                    }

                    if (r <= sqrt(int((highArea.x - lowArea.x + 1)/2)*int((highArea.x - lowArea.x + 1)/2) + int((highArea.y - lowArea.y + 1)/2)*int((highArea.y - lowArea.y + 1)/2)));
                    {
                        // ADD
                        newX = int(middle.x - sin(angle)*r);
                        newY = int(middle.y - cos(angle)*r);
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count++;
                            R += temp2->data[location].r;
                            G += temp2->data[location].g;
                            B += temp2->data[location].b;
                            A += temp2->data[location].a;
                        }
                        // DRAW
                        newX = int(middle.x - sin(angle)*(r-0*newValue1));
                        newY = int(middle.y - cos(angle)*(r-0*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            if (count != 0)
                                img->data[location] = (Rgba){limitRGBA.intForceLimit(R / count), limitRGBA.intForceLimit(G / count), limitRGBA.intForceLimit(B / count), limitRGBA.intForceLimit(A / count)};
                        }
                    }
                }
            }
        }

        // lower left quadrant
        for (int x = lowArea.x; x <= middle.x; x++)
        {
            if (x != lowArea.x)
                maxY = highArea.y;
            else
                maxY = middle.y;

            for (int y = highArea.y; y >= maxY; y--)
            {
                newX = (middle.x - x);
                newY = (middle.y - y);
                radius = sqrt(newX*newX + newY*newY);
                angle = atan((float)abs(newX) / abs(newY));
                newValue1 = 0;
                for (int r = 0; r <= (radius + value1); r++)
                {
                    olderValue1 = oldValue1;
                    oldValue1 = newValue1;
                    newValue1 = int((float)r / (radius + value1) * value1);
                    if (r == 0)
                    {
                        R = 0;
                        G = 0;
                        B = 0;
                        A = 0;
                        count = 0;
                    }
                    else if (r >= newValue1 && olderValue1 == newValue1)
                    {
                        // SUBTRACT
                        int r2 = r - 1;
                        newX = int(middle.x - sin(angle)*(r2-2*newValue1));
                        newY = int(middle.y + cos(angle)*(r2-2*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count--;
                            R -= temp2->data[location].r;
                            G -= temp2->data[location].g;
                            B -= temp2->data[location].b;
                            A -= temp2->data[location].a;
                        }
                    }

                    if (r <= sqrt(int((highArea.x - lowArea.x + 1)/2)*int((highArea.x - lowArea.x + 1)/2) + int((highArea.y - lowArea.y + 1)/2)*int((highArea.y - lowArea.y + 1)/2)));
                    {
                        // ADD
                        newX = int(middle.x - sin(angle)*r);
                        newY = int(middle.y + cos(angle)*r);
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count++;
                            R += temp2->data[location].r;
                            G += temp2->data[location].g;
                            B += temp2->data[location].b;
                            A += temp2->data[location].a;
                        }
                        // DRAW
                        newX = int(middle.x - sin(angle)*(r-0*newValue1));
                        newY = int(middle.y + cos(angle)*(r-0*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            if (count != 0)
                                img->data[location] = (Rgba){limitRGBA.intForceLimit(R / count), limitRGBA.intForceLimit(G / count), limitRGBA.intForceLimit(B / count), limitRGBA.intForceLimit(A / count)};
                        }
                    }
                }
            }
        }

        // upper right quadrant
        for (int x = highArea.x; x >= middle.x; x--)
        {
            if (x != highArea.x)
                maxY = lowArea.y;
            else
                maxY = middle.y;

            for (int y = lowArea.y; y <= maxY; y++)
            {
                newX = (middle.x - x);
                newY = (middle.y - y);
                radius = sqrt(newX*newX + newY*newY);
                angle = atan((float)abs(newX) / abs(newY));
                newValue1 = 0;
                for (int r = 0; r <= (radius + value1); r++)
                {
                    olderValue1 = oldValue1;
                    oldValue1 = newValue1;
                    newValue1 = int((float)r / (radius + value1) * value1);
                    if (r == 0)
                    {
                        R = 0;
                        G = 0;
                        B = 0;
                        A = 0;
                        count = 0;
                    }
                    else if (r >= newValue1 && olderValue1 == newValue1)
                    {
                        // SUBTRACT
                        int r2 = r - 1;
                        newX = int(middle.x + sin(angle)*(r2-2*newValue1));
                        newY = int(middle.y - cos(angle)*(r2-2*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count--;
                            R -= temp2->data[location].r;
                            G -= temp2->data[location].g;
                            B -= temp2->data[location].b;
                            A -= temp2->data[location].a;
                        }
                    }

                    if (r <= sqrt(int((highArea.x - lowArea.x + 1)/2)*int((highArea.x - lowArea.x + 1)/2) + int((highArea.y - lowArea.y + 1)/2)*int((highArea.y - lowArea.y + 1)/2)));
                    {
                        // ADD
                        newX = int(middle.x + sin(angle)*r);
                        newY = int(middle.y - cos(angle)*r);
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count++;
                            R += temp2->data[location].r;
                            G += temp2->data[location].g;
                            B += temp2->data[location].b;
                            A += temp2->data[location].a;
                        }
                        // DRAW
                        newX = int(middle.x + sin(angle)*(r-0*newValue1));
                        newY = int(middle.y - cos(angle)*(r-0*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            if (count != 0)
                                img->data[location] = (Rgba){limitRGBA.intForceLimit(R / count), limitRGBA.intForceLimit(G / count), limitRGBA.intForceLimit(B / count), limitRGBA.intForceLimit(A / count)};
                        }
                    }
                }
            }
        }

        // lower right quadrant
        for (int x = highArea.x; x >= middle.x; x--)
        {
            if (x != highArea.x)
                maxY = highArea.y;
            else
                maxY = middle.y;

            for (int y = highArea.y; y >= maxY; y--)
            {
                newX = (middle.x - x);
                newY = (middle.y - y);
                radius = sqrt(newX*newX + newY*newY);
                angle = atan((float)abs(newX) / abs(newY));
                newValue1 = 0;
                for (int r = 0; r <= (radius + value1); r++)
                {
                    olderValue1 = oldValue1;
                    oldValue1 = newValue1;
                    newValue1 = int((float)r / (radius + value1) * value1);
                    if (r == 0)
                    {
                        R = 0;
                        G = 0;
                        B = 0;
                        A = 0;
                        count = 0;
                    }
                    else if (r >= newValue1 && olderValue1 == newValue1)
                    {
                        // SUBTRACT
                        int r2 = r - 1;
                        newX = int(middle.x + sin(angle)*(r2-2*newValue1));
                        newY = int(middle.y + cos(angle)*(r2-2*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count--;
                            R -= temp2->data[location].r;
                            G -= temp2->data[location].g;
                            B -= temp2->data[location].b;
                            A -= temp2->data[location].a;
                        }
                    }

                    if (r <= sqrt(int((highArea.x - lowArea.x + 1)/2)*int((highArea.x - lowArea.x + 1)/2) + int((highArea.y - lowArea.y + 1)/2)*int((highArea.y - lowArea.y + 1)/2)));
                    {
                        // ADD
                        newX = int(middle.x + sin(angle)*r);
                        newY = int(middle.y + cos(angle)*r);
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            count++;
                            R += temp2->data[location].r;
                            G += temp2->data[location].g;
                            B += temp2->data[location].b;
                            A += temp2->data[location].a;
                        }
                        // DRAW
                        newX = int(middle.x + sin(angle)*(r-0*newValue1));
                        newY = int(middle.y + cos(angle)*(r-0*newValue1));
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            if (count != 0)
                                img->data[location] = (Rgba){limitRGBA.intForceLimit(R / count), limitRGBA.intForceLimit(G / count), limitRGBA.intForceLimit(B / count), limitRGBA.intForceLimit(A / count)};
                        }
                    }
                }
            }
        }

        // fehlerkorrektur
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                if (img->data[location].a == 0)
                {
                    R = 0; G = 0; B = 0; A = 0; count = 0;
                    for (int iy = -1; iy <= 1; iy++)
                    {
                        for (int ix = -1; ix <= 1; ix++)
                        {
                            newX = x + ix;
                            newY = y + iy;
                            location = newX + img->width * newY;
                            if ((!((ix == 0) && (iy == 0))) && newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                            {
                                location = newX + img->width * newY;
                                R += img->data[location].r;
                                G += img->data[location].g;
                                B += img->data[location].b;
                                A += img->data[location].a;
                                count++;
                            }
                        }
                    }
                    location = x + img->width * y;
                    if (count > 0)
                    {
                        location = x + img->width * y;
                        img->data[location].r = limitRGBA.intForceLimit((float)R / count);
                        img->data[location].g = limitRGBA.intForceLimit((float)G / count);
                        img->data[location].b = limitRGBA.intForceLimit((float)B / count);
                        img->data[location].a = limitRGBA.intForceLimit((float)A / count);
                    }
                }
            }
        }

        gaussian(temp2, img, lowArea.x, lowArea.y, highArea.x, highArea.y, 2, 2);

        // finalize
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                img->data[location].r = limitRGBA.intForceLimit(temp->data[location].r + ((float)(temp2->data[location].a)/255) * newStrength * img->data[location].r);
                img->data[location].g = limitRGBA.intForceLimit(temp->data[location].g + ((float)(temp2->data[location].a)/255) * newStrength * img->data[location].g);
                img->data[location].b = limitRGBA.intForceLimit(temp->data[location].b + ((float)(temp2->data[location].a)/255) * newStrength * img->data[location].b);
                img->data[location].a = 255;
            }
        }
        display = img;
        this->refreshImage();
    }
}

void shine::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Shine | Mode 1: Normal");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Shine | Mode 2: Colorized");

    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

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

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

    value1 = 10;
    limitValue1.set(5, 30);
    value2 = 2;
    limitValue2.set(1, 5);
    
    imageRgbaCopy(img, temp);
   
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

void brush::LBAction()
{
    if (LBpressed)
    {
        int highest = 0;
        int R = 0, G = 0, B = 0, count = 0;
        int newX, newY;
        int width = int(value2 * 2 + 1);
        int numElements = width * width;
        Rgba *color = new Rgba[width*width];
        
        for (int x = lowArea.x; x <= highArea.x; x++)
        {
            for (int y = int(lowArea.y - width); y <= highArea.y; y++)
            {
/*
                newX = int(x - value2);
                newY = int(y + value2);
                if (newX < lowArea.x) newX = lowArea.x;
                if (newY < lowArea.y) newY = lowArea.y;
                if (newX > (highArea.x - width)) newX = (highArea.x - width);
                if (newY > highArea.y) newY = highArea.y;

                //positionY = int(y - lowArea.y + width) % width;
                positionY = (y + width) % width;
                memcpy(&color[width * positionY], &temp->data[newX + img->width * newY], width * sizeof(Rgba));
*/
/*
                for (int iy = int(-value2); iy <= value2; iy++)
                {
                    newX = int(x - value2);
                    newY = int(y + iy);
                    if (newX < lowArea.x) newX = lowArea.x;
                    if (newY < lowArea.y) newY = lowArea.y;
                    if (newX > (highArea.x - width)) newX = (highArea.x - width);
                    if (newY > highArea.y) newY = highArea.y;

                    positionY = int(iy + value2);
                    memcpy(&color[width * positionY], &temp->data[newX + img->width * newY], width * sizeof(Rgba));
                }
*/
                for (int iy = int(-value2); iy <= value2; iy++)
                {
                    for (int ix = int(-value2); ix <= value2; ix++)
                    {
                        newX = x + ix;
                        newY = y + iy;
                        if (newX < lowArea.x) newX = lowArea.x;
                        if (newY < lowArea.y) newY = lowArea.y;
                        if (newX > highArea.x) newX = highArea.x;
                        if (newY > highArea.y) newY = highArea.y;

                        color[int(ix + value2) + width * int(iy + value2)] = temp->data[newX + img->width * newY];
//                        memcpy(&color[width * positionY], &temp->data[newX + img->width * newY], width * sizeof(Rgba));
                    }
                }

                if (y >= 0)
                {
                    for (int i = 0; i < numElements; i++)
                    {
                        if (color[i].a != 0)
                        {
                            color[i].a = 0;
                            for (int ii = i+1; ii < numElements; ii++)
                            {
                                if (color[ii].a != 0)
                                {
                                    if (abs(color[i].r - color[ii].r) <= value1 && abs(color[i].g - color[ii].g) <= value1 && abs(color[i].b - color[ii].b) <= value1)
                                    {
                                        color[ii].a = 0;
                                        color[i].a++;
                                    }
                                }
                            }
                        }
                    }
                    highest = 0;
                    for (int i = 0; i < numElements; i++)
                    {
                        if (color[i].a > highest)
                            highest = color[i].a;
                    }
                    R = 0;
                    G = 0;
                    B = 0;
                    count = 0;
                    for (int i = 0; i < numElements; i++)
                    {
                        if (color[i].a == highest)
                        {
                            R += color[i].r;
                            G += color[i].g;
                            B += color[i].b;
                            count++;
                        }
                    }
                    img->data[x + img->width * y] = (Rgba){ limitRGBA.intForceLimit((float)R / count),
                                                            limitRGBA.intForceLimit((float)G / count),
                                                            limitRGBA.intForceLimit((float)B / count),
                                                            255 };
                }
            }
        }
        delete color;

    }
}

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

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

    value1 = 10;
    limitValue1.set(5, 30);
    value2 = 2;
    limitValue2.set(1, 5);

    imageRgbaCopy(img, temp);

    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

void spatter::LBAction()
{
    if (LBpressed)
    {
        int newX, newY;

        for (int x = lowArea.x; x <= highArea.x; x++)
        {
            for (int y = lowArea.y; y <= highArea.y; y++)
            {
                newX = x + rand() % int(value1 * 2) - int(value1);
                newY = y + rand() % int(value1 * 2) - int(value1);

                if (newX < lowArea.x) newX = lowArea.x;
                if (newY < lowArea.y) newY = lowArea.y;
                if (newX > highArea.x) newX = highArea.x;
                if (newY > highArea.y) newY = highArea.y;

                img->data[x + img->width * y] = temp->data[newX + img->width * newY];
            }
        }
    }
}

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

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

    strength = 2;

    value1 = 3;
    limitValue1.set(2, 100);
    value2 = 20;
    limitValue2.set(5, 30);

    imageRgbaCopy(img, temp);

    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

void cutout::LBAction()
{
    if (LBpressed)
    {
        /*
        imageRgbaCopy(temp, img);
        Rgba color[int(value1)];
        int highest[int(value1)];
        int numElements = img->width * img->height;
        int count[numElements];
        int currentDif, maxDif, min;

        if (strength > 0)
            gaussian(temp2, img, lowArea.x, lowArea.y, highArea.x, highArea.y, strength, 2);
        else
            imageRgbaCopy(temp, temp2);

        for (int i = 0; i < numElements; i++)
            count[i] = 1;
            

        for (int i = 0; i < numElements; i++)
        {
            if (count[i] != 0)
            {
                count[i] = 0;
                for (int ii = i+1; ii < numElements; ii++)
                {
                    if (count[ii] != 0)
                    {
                        if (abs(temp2->data[i].r - temp2->data[ii].r) <= value2 && abs(temp2->data[i].g - temp2->data[ii].g) <= value2 && abs(temp2->data[i].b - temp2->data[ii].b) <= value2)
                        {
                            count[ii] = 0;
                            count[i]++;
                        }
                    }
                }
            }
        }

        for (int k = 0; k < int(value1); k++)
            highest[k] = 0;
            
        for (int i = 0; i < numElements; i++)
            holdHighest(highest, int(value1), count[i]);
            
        for (int i = 0; i < numElements; i++)
            if (count[i] > 0)
                for (int k = 0; k < int(value1); k++)
                    if (count[i] == highest[k])
                        color[k] = temp2->data[i];

        for (int k = 0; k < int(value1); k++)
            log(highest[k]);
            

        for (int newX, newY, i = 0; i < numElements; i++)
        {
            newX = i % img->width;
            newY = int(i / img->width);

            if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
            {
                min = 0;
                for (int k = 0; k < int(value1); k++)
                {
                    maxDif = abs(temp2->data[i].r - color[k].r);
                    currentDif = abs(temp2->data[i].g - color[k].g);
                    if (currentDif > maxDif) maxDif = currentDif;
                    currentDif = abs(temp2->data[i].b - color[k].b);
                    if (currentDif > maxDif) maxDif = currentDif;

                    highest[k] = maxDif;
                    if (highest[k] < highest[min]) min = k;
                }
                img->data[i] = color[min];
            }
        }
        */
        imageRgbaCopy(temp, img);
        Rgba color[int(value1)];
        int highest[int(value1)];
        int numElements = (highArea.x - lowArea.x + 1) * (highArea.y - lowArea.y + 1);
        int count[numElements];
        int currentDif, maxDif, min;

        if (strength > 0)
            gaussian(temp2, img, lowArea.x, lowArea.y, highArea.x, highArea.y, strength, 2);
        else
            imageRgbaCopy(temp, temp2);

        for (int i = 0; i < numElements; i++)
            count[i] = 1;


        for (int n, i = 0; i < numElements; i++)
        {
            n = (lowArea.x + (i % (highArea.x - lowArea.x + 1))) + img->width * (lowArea.y  + int(i / (highArea.x - lowArea.x + 1)));
            if (count[i] != 0)
            {
                count[i] = 0;
                for (int nn, ii = i+1; ii < numElements; ii++)
                {
                    nn = (lowArea.x + (ii % (highArea.x - lowArea.x + 1))) + img->width * (lowArea.y  + int(ii / (highArea.x - lowArea.x + 1)));
                    if (count[ii] != 0)
                    {
                        if (abs(temp2->data[n].r - temp2->data[nn].r) <= value2 && abs(temp2->data[n].g - temp2->data[nn].g) <= value2 && abs(temp2->data[n].b - temp2->data[nn].b) <= value2)
                        {
                            count[ii] = 0;
                            count[i]++;
                        }
                    }
                }
            }
        }

        for (int k = 0; k < int(value1); k++)
            highest[k] = 0;

        for (int i = 0; i < numElements; i++)
            holdHighest(highest, int(value1), count[i]);

        for (int i = 0; i < numElements; i++)
            if (count[i] > 0)
                for (int k = 0; k < int(value1); k++)
                    if (count[i] == highest[k])
                        color[k] = temp2->data[(lowArea.x + (i % (highArea.x - lowArea.x + 1))) + img->width * (lowArea.y  + int(i / (highArea.x - lowArea.x + 1)))];

        for (int k = 0; k < int(value1); k++)
            log(highest[k]);


        for (int n, i = 0; i < numElements; i++)
        {
            n = (lowArea.x + (i % (highArea.x - lowArea.x + 1))) + img->width * (lowArea.y  + int(i / (highArea.x - lowArea.x + 1)));

            min = 0;
            for (int k = 0; k < int(value1); k++)
            {
                maxDif = abs(temp2->data[n].r - color[k].r);
                currentDif = abs(temp2->data[n].g - color[k].g);
                if (currentDif > maxDif) maxDif = currentDif;
                currentDif = abs(temp2->data[n].b - color[k].b);
                if (currentDif > maxDif) maxDif = currentDif;

                highest[k] = maxDif;
                if (highest[k] < highest[min]) min = k;
            }
            img->data[n] = color[min];
        }
    }
}

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

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

    strength = 2;

    value1 = 7;
    limitValue1.set(2, 30);
    value2 = 3;
    limitValue2.set(2, 15);

    imageRgbaCopy(img, temp);

    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

void strokes::LBAction()
{
    if (LBpressed)
    {
        int newX, newY;
        int angle;
        float newAngle;
        
        if (strength > 0)
        {
            imageRgbaCopy(temp, img);
            gaussian(temp2, img, lowArea.x, lowArea.y, highArea.x, highArea.y, strength, 2);
        }
        else
            imageRgbaCopy(temp, temp2);

        imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){0, 0, 0, 0});

        for (int r = 0; r < 2; r++)
        {
            for (int y = lowArea.y; y <= highArea.y; y++)
            {
                for (int x = lowArea.x; x <= highArea.x; x++)
                {
                    if (img->data[x + img->width * y].a == 0)
                    {
                        newX = x;
                        newY = y;
                        angle = rand() % 360;

                        for (int j = 0; j < 3; j++)
                        {
                            for (int k = -int(value2 - (rand() % int(value2/2))); k < (value2 - (rand() % int(value2/2))); k++)
                            {
                                newAngle = (float)(angle + (rand() % 30) - 15) / 180 * M_PI;
                                imageRgbaDrawLine(img, int(newX + j + sin(newAngle) * (value1 - (rand() % int(value1/2))) + sin(newAngle + M_PI / 2) * k),
                                                       int(newY + cos(newAngle) * (value1 - (rand() % int(value1/2))) + cos(newAngle + M_PI / 2) * k),
                                                       int(newX + j - sin(newAngle) * (value1 - (rand() % int(value1/2))) + sin(newAngle + M_PI / 2) * k),
                                                       int(newY - cos(newAngle) * (value1 - (rand() % int(value1/2))) + cos(newAngle + M_PI / 2) * k),
                                                       temp2->data[newX + img->width * newY],
                                                       lowArea.x, lowArea.y, highArea.x, highArea.y);
                            }
                        }
                    }
                }
            }
        }
        int randomCount = int((float)(img->width * img->height) / (2*value1 * 2*value2));
        for (int i = 0; i < randomCount; i++)
        {
            newX = lowArea.x + rand() % (highArea.x - lowArea.x);
            newY = lowArea.y + rand() % (highArea.y - lowArea.y);
            angle = rand() % 360;

            for (int j = 0; j < 3; j++)
            {
                for (int k = -int(value2 - (rand() % int(value2/2))); k < (value2 - (rand() % int(value2/2))); k++)
                {
                    newAngle = (float)(angle + (rand() % 30) - 15) / 180 * M_PI;
                    imageRgbaDrawLine(img, int(newX + j + sin(newAngle) * (value1 - (rand() % int(value1/2))) + sin(newAngle + M_PI / 2) * k),
                                           int(newY + cos(newAngle) * (value1 - (rand() % int(value1/2))) + cos(newAngle + M_PI / 2) * k),
                                           int(newX + j - sin(newAngle) * (value1 - (rand() % int(value1/2))) + sin(newAngle + M_PI / 2) * k),
                                           int(newY - cos(newAngle) * (value1 - (rand() % int(value1/2))) + cos(newAngle + M_PI / 2) * k),
                                           temp2->data[newX + img->width * newY],
                                           lowArea.x, lowArea.y, highArea.x, highArea.y);
                }
            }
        }
    }
}

---