---

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

Go to the documentation of this file.

#include "distort.h"

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

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

    value1 = 10;
    value2 = 1;
    if ((highArea.x - lowArea.x + 1) > (highArea.y - lowArea.y + 1))
        limitValue1.set(1, int((highArea.x - lowArea.x + 1)/5));
    else
        limitValue1.set(1, int((highArea.y - lowArea.y + 1)/5));
    limitValue2.set(0, int(value1 - 1));
    imageRgbaCopy(img, temp);
    
    bColorMenu = true;
    myColor = (Rgba){0, 0, 0, 255};
   
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

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

void mosaic::LBAction()
{
    if (LBpressed)
    {
        limitValue2.set(0, int(value1 - 1));
        value2 = limitValue2.intForceLimit(value2);

        int w = highArea.x - lowArea.x + 1;
        int h = highArea.y - lowArea.y + 1;
    
        for (int by = 0; by < int(1.0 * h / value1 + 1); by++)
        {
            for (int bx = 0; bx < int(1.0 * w / value1 + 1); bx++)
            {
                int R = 0, G = 0, B = 0, count = 0;
                int newX, newY;
                
                for (int y = 0; y < value1; y++)
                {
                    newY = int(lowArea.y + by*value1 + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = 0; x < value1; x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                count++;
                                R += temp->data[newX + img->width * newY].r;
                                G += temp->data[newX + img->width * newY].g;
                                B += temp->data[newX + img->width * newY].b;
                            }
                        }
                    }
                }
                
                if (count != 0)
                {
                    R = limitRGBA.intForceLimit(R / count);
                    G = limitRGBA.intForceLimit(G / count);
                    B = limitRGBA.intForceLimit(B / count);
                }
    
                for (int y = 0; y < value1; y++)
                {
                    newY = int(lowArea.y + by*value1 + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = 0; x < value1; x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                if (x < int(value2 / 2.0) || x >= int(value1 - (value2 / 2.0)) || y < int(value2 / 2.0) || y >= int(value1 - (value2 / 2.0)))
                                    img->data[newX + img->width * newY] = myColor;
                                else
                                    img->data[newX + img->width * newY] = (Rgba){R, G, B, 255};
                            }
                            else
                                break;
                        }
                    }
                    else
                        break;
                }
            }
        }
    }
}

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

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

    value1 = 10;
    if ((highArea.x - lowArea.x + 1) > (highArea.y - lowArea.y + 1))
        limitValue1.set(1, int((highArea.x - lowArea.x + 1)/5));
    else
        limitValue1.set(1, int((highArea.y - lowArea.y + 1)/5));
    value2 = 1;
    limitValue2.set(0, int(value1 / 2.0 - 1));
    imageRgbaCopy(img, temp);

    numModes = 8;
    mode = 6;

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

void box::LBAction()
{
    if (LBpressed)
    {
        limitValue2.set(0, int(value1 / 2.0 - 1));
        value2 = limitValue2.intForceLimit(value2);

        int w = highArea.x - lowArea.x + 1;
        int h = highArea.y - lowArea.y + 1;
    
        for (int by = 0; by < int(1.0 * h / value1 + 1); by++)
        {
            for (int bx = 0; bx < int(1.0 * w / value1 + 1); bx++)
            {
                int R = 0, G = 0, B = 0, count = 0;
                int newX, newY;
                
                for (int y = 0; y < value1; y++)
                {
                    newY = int(lowArea.y + by*value1 + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = 0; x < value1; x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                int location = newX + img->width * newY;

                                count++;
                                R += temp->data[location].r;
                                G += temp->data[location].g;
                                B += temp->data[location].b;
                            }
                        }
                    }
                }
                
                if (count != 0)
                {
                    R = limitRGBA.intForceLimit(R / count);
                    G = limitRGBA.intForceLimit(G / count);
                    B = limitRGBA.intForceLimit(B / count);
                }
    
                for (int y = 0; y < value1; y++)
                {
                    newY = int(lowArea.y + by*value1 + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = 0; x < value1; x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                int location = newX + img->width * newY;

                                img->data[location] = (Rgba){R, G, B};
                            }
                        }
                    }
                }
            }
        }
        for (int by = 0; by < int(1.0 * h / value1 + 1); by++)
        {
            for (int bx = 0; bx < int(1.0 * w / value1 + 1); bx++)
            {
                int dU = 0, dD = 0, dL = 0, dR = 0;
                int vSelf, vOther; // value (brightness)
                int newX, newY;
                Rgba colorSelf, colorOther;
                
                if (bx > 0 && by > 0 && bx < int(1.0 * w / value1) && by < int(1.0 * h / value1))
                {
                    // dU
                    colorSelf = img->data[int(lowArea.x + (bx - 0)*value1 + (value1 / 2.0)) + img->width * int(lowArea.y + (by - 0)*value1 + (value1 / 2.0))];
                    colorOther = img->data[int(lowArea.x + (bx - 0)*value1 + (value1 / 2.0)) + img->width * int(lowArea.y + (by - 1)*value1 + (value1 / 2.0))];
                    vSelf = colorSelf.r;
                    if (colorSelf.g > vSelf)
                        vSelf = colorSelf.g;
                    if (colorSelf.b > vSelf)
                        vSelf = colorSelf.b;

                    vOther = colorOther.r;
                    if (colorOther.g > vOther)
                        vOther = colorOther.g;
                    if (colorOther.b > vOther)
                        vOther = colorOther.b;
                        
                    dU = vSelf - vOther;
                    
/*                    // dD
                    colorSelf = img->data[int(lowArea.x + (bx - 0)*value1) + img->width * int(lowArea.y + (by - 0)*value1)];
                    colorOther = img->data[int(lowArea.x + (bx - 0)*value1) + img->width * int(lowArea.y + (by + 1)*value1)];
                    vSelf = colorSelf.r;
                    if (colorSelf.g > vSelf)
                        vSelf = colorSelf.g;
                    if (colorSelf.b > vSelf)
                        vSelf = colorSelf.b;

                    vOther = colorOther.r;
                    if (colorOther.g > vOther)
                        vOther = colorOther.g;
                    if (colorOther.b > vOther)
                        vOther = colorOther.b;
                        
                    dD = vSelf - vOther;*/
                        
                    // dL
                    colorSelf = img->data[int(lowArea.x + (bx - 0)*value1 + (value1 / 2.0)) + img->width * int(lowArea.y + (by - 0)*value1 + (value1 / 2.0))];
                    colorOther = img->data[int(lowArea.x + (bx - 1)*value1 + (value1 / 2.0)) + img->width * int(lowArea.y + (by - 0)*value1 + (value1 / 2.0))];
                    vSelf = colorSelf.r;
                    if (colorSelf.g > vSelf)
                        vSelf = colorSelf.g;
                    if (colorSelf.b > vSelf)
                        vSelf = colorSelf.b;

                    vOther = colorOther.r;
                    if (colorOther.g > vOther)
                        vOther = colorOther.g;
                    if (colorOther.b > vOther)
                        vOther = colorOther.b;
                        
                    dL = vSelf - vOther;
                        
/*                    // dR
                    colorSelf = img->data[int(lowArea.x + (bx - 0)*value1) + img->width * int(lowArea.y + (by - 0)*value1)];
                    colorOther = img->data[int(lowArea.x + (bx + 1)*value1) + img->width * int(lowArea.y + (by - 0)*value1)];
                    vSelf = colorSelf.r;
                    if (colorSelf.g > vSelf)
                        vSelf = colorSelf.g;
                    if (colorSelf.b > vSelf)
                        vSelf = colorSelf.b;

                    vOther = colorOther.r;
                    if (colorOther.g > vOther)
                        vOther = colorOther.g;
                    if (colorOther.b > vOther)
                        vOther = colorOther.b;
                        
                    dR = vSelf - vOther;*/
                }

                for (int y = 0; y < value1; y++)
                {
                    newY = int(lowArea.y + by*value1 + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = 0; x < value1; x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                int newMode;
                                if (mode > 4)
                                    newMode = (mode - 4) * 2 - 1;
                                else
                                    newMode = (mode - 5) * 2 + 1;
                                    
                                int location = newX + img->width * newY;
                                if (y < value2 && y <= x && y < (value1 - x))
                                {
                                    img->data[location].r = limitRGBA.intForceLimit(img->data[location].r + 50 + dU * newMode);
                                    img->data[location].g = limitRGBA.intForceLimit(img->data[location].g + 50 + dU * newMode);
                                    img->data[location].b = limitRGBA.intForceLimit(img->data[location].b + 50 + dU * newMode);
                                }
                                else if (y >= (value1 - value2) && y > x && y >= (value1 - x))
                                {
                                    img->data[location].r = limitRGBA.intForceLimit(img->data[location].r - 50 + dD * 0);
                                    img->data[location].g = limitRGBA.intForceLimit(img->data[location].g - 50 + dD * 0);
                                    img->data[location].b = limitRGBA.intForceLimit(img->data[location].b - 50 + dD * 0);
                                }
                                else if (x < value2)
                                {
                                    img->data[location].r = limitRGBA.intForceLimit(img->data[location].r + 20 + dL * newMode);
                                    img->data[location].g = limitRGBA.intForceLimit(img->data[location].g + 20 + dL * newMode);
                                    img->data[location].b = limitRGBA.intForceLimit(img->data[location].b + 20 + dL * newMode);
                                }
                                else if (x >= (value1 - value2))
                                {
                                    img->data[location].r = limitRGBA.intForceLimit(img->data[location].r - 20 + dR * 0);
                                    img->data[location].g = limitRGBA.intForceLimit(img->data[location].g - 20 + dR * 0);
                                    img->data[location].b = limitRGBA.intForceLimit(img->data[location].b - 20 + dR * 0);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void box::changeMode(char _mode)
{
    mode = _mode;
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

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

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

    value1 = 10;
    if ((highArea.x - lowArea.x + 1) > (highArea.y - lowArea.y + 1))
        limitValue1.set(2, int((highArea.x - lowArea.x + 1)/5));
    else
        limitValue1.set(2, int((highArea.y - lowArea.y + 1)/5));
    imageRgbaCopy(img, temp);
   
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

void comb::LBAction()
{
    if (LBpressed)
    {
        int w = highArea.x - lowArea.x + 1;
        int h = highArea.y - lowArea.y + 1;
        int value1y = int(sqrt(3) / 2.0 * value1);
    
        for (int by = 0; by < int(1.0 * h / value1y + 2); by++)
        {
            for (int bx = 0; bx < int(1.0 * w / value1 + 2); bx++)
            {
                int R1 = 0, G1 = 0, B1 = 0, count1 = 0;
                int R2 = 0, G2 = 0, B2 = 0, count2 = 0;
                int newX, newY;
                
                for (int y = 0; y < value1y; y++)
                {
                    newY = int(lowArea.y + by*value1y + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = int(0 - ((by % 2) * (value1 / 2.0)) + (1.0 * abs(y) / value1y * value1) / 2.0); x < (value1 - ((by % 2) * (value1 / 2.0)) - (1.0 * abs(y) / value1y * value1) / 2.0); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                count1++;
                                R1 += temp->data[newX + img->width * newY].r;
                                G1 += temp->data[newX + img->width * newY].g;
                                B1 += temp->data[newX + img->width * newY].b;
                            }
                        }
                    }
                }
                for (int y = 0; y > (-value1y); y--)
                {
                    newY = int(lowArea.y + by*value1y + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = int(0 - ((by % 2) * (value1 / 2.0)) + (1.0 * abs(y) / value1y * value1) / 2.0); x < (value1 - ((by % 2) * (value1 / 2.0)) - (1.0 * abs(y) / value1y * value1) / 2.0); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                count2++;
                                R2 += temp->data[newX + img->width * newY].r;
                                G2 += temp->data[newX + img->width * newY].g;
                                B2 += temp->data[newX + img->width * newY].b;
                            }
                        }
                    }
                }
                
                if (count1 != 0)
                {
                    R1 = limitRGBA.intForceLimit(R1 / count1);
                    G1 = limitRGBA.intForceLimit(G1 / count1);
                    B1 = limitRGBA.intForceLimit(B1 / count1);
                }
                if (count2 != 0)
                {
                    R2 = limitRGBA.intForceLimit(R2 / count2);
                    G2 = limitRGBA.intForceLimit(G2 / count2);
                    B2 = limitRGBA.intForceLimit(B2 / count2);
                }
    
                for (int y = 0; y < value1y; y++)
                {
                    newY = int(lowArea.y + by*value1y + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = int(0 - ((by % 2) * (1.0 * value1 / 2.0)) + (1.0 * abs(y) / value1y * value1) / 2.0); x < (value1 - ((by % 2) * (1.0 * value1 / 2.0)) - (1.0 * abs(y) / value1y * value1) / 2.0); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[newX + img->width * newY] = (Rgba) {R1, G1, B1, 255};
                        }
                    }
                }
                for (int y = 0; y > (-value1y); y--)
                {
                    newY = int(lowArea.y + by*value1y + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = int(0 - ((by % 2) * (1.0 * value1 / 2.0)) + (1.0 * abs(y) / value1y * value1) / 2.0); x < (value1 - ((by % 2) * (1.0 * value1 / 2.0)) - (1.0 * abs(y) / value1y * value1) / 2.0); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[newX + img->width * newY] = (Rgba) {R2, G2, B2, 255};
                        }
                    }
                }
            }
        }
    }
}

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

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

    value1 = 30;
    if ((highArea.x - lowArea.x + 1) > (highArea.y - lowArea.y + 1))
        limitValue1.set(2, (highArea.x - lowArea.x + 1));
    else
        limitValue1.set(2, (highArea.y - lowArea.y + 1));
        
    value2 = 10;
    limitValue2.set(0, int(value1 / 2.0));
    
    bColorMenu = true;
    myColor = (Rgba){0, 0, 0, 255};
    
    imageRgbaCopy(img, temp);

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

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

void dots::LBAction()
{
    if (LBpressed)
    {
        int w = highArea.x - lowArea.x + 1;
        int h = highArea.y - lowArea.y + 1;

        limitValue2.set(0, int(value1 / 2));
        value2 = limitValue2.intForceLimit(value2);
    
        int newX, newY;
        if (mode == 1)
        {
            for (int by = 0; by < int(1.0 * h / value1 + 1); by++)
            {
                for (int bx = 0; bx < int(1.0 * w / value1 + 1); bx++)
                {
                    int lowX, lowY, highX, highY;
                    
                    lowX = int(lowArea.x + bx*value1);
                    lowY = int(lowArea.y + by*value1);
                    highX = int(lowX + value1);
                    highY = int(lowY + value1);
    
                    if (highX > highArea.x)
                        highX = highArea.x;
                    if (highY > highArea.y)
                        highY = highArea.y;
                    
                    for (int y = 0; y < value1; y++)
                    {
                        for (int x = 0; x < value1; x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            newY = int(lowArea.y + by*value1 + y);
                            if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                            {
                                img->data[newX + img->width * newY] = imageRgbaInterpolateColors((1.0 * x / value1), (1.0 * y / value1),
                                                                temp->data[lowX + img->width * lowY],
                                                                temp->data[highX + img->width * lowY],
                                                                temp->data[lowX + img->width * highY],
                                                                temp->data[highX + img->width * highY]);
                            }
                        }
                    }                
                }
            }
        }
        if (mode == 2)
        {
            imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x + 1, highArea.y + 1, myColor);
        }
        for (int by = 0; by < int(1.0 * h / value1 + 2); by++)
        {
            for (int bx = 0; bx < int(1.0 * w / value1 + 2); bx++)
            {
//                offset.set(int(lowArea.x + bx*value1), int(lowArea.y + by*value1));
                for (int y = int(-value2); y < int(value2); y++)
                {
                    float xValue = sqrt((value2*value2) - (y*y));
                    for (int x = int(-xValue); x < int(xValue); x++)
                    {
                        newX = int(lowArea.x + bx*value1 + x);
                        newY = int(lowArea.y + by*value1 + y);
                        int location = newX + img->width * newY;
                        if ((newX >= lowArea.x) && (newX <= highArea.x) && (newY >= lowArea.y) && (newY <= highArea.y))
                            img->data[location] = temp->data[location];
                    }
                }
            }
        }
    }
}

void dots::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Dots | Mode 1: Interpolated");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Dots | Mode 2: Colorized");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

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

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

    value1 = 10;
    if ((highArea.x - lowArea.x + 1) > (highArea.y - lowArea.y + 1))
        limitValue1.set(2, int((highArea.x - lowArea.x + 1) / 5));
    else
        limitValue1.set(2, int((highArea.y - lowArea.y + 1) / 5));

    numModes = 2;
    mode = 1;

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

void rgbdots::LBAction()
{
    if (LBpressed)
    {
        int w = highArea.x - lowArea.x + 1;
        int h = highArea.y - lowArea.y + 1;

        if (mode == 1)
            imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){0, 0, 0, 255});
        else if (mode == 2)
            imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){255, 255, 255, 255});
        
        for (int by = 0; by < int(1.0 * h / value1 + 1); by++)
        {
            for (int bx = 0; bx < int(1.0 * w / value1 + 1); bx++)
            {
                int R = 0, G = 0, B = 0, count = 0;
                int newX, newY;
                
                for (int y = 0; y < value1; y++)
                {
                    newY = int(lowArea.y + by*value1 + y);
                    if ((newY >= lowArea.y) && (newY <= highArea.y))
                    {
                        for (int x = 0; x < value1; x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            
                            if ((newX >= lowArea.x) && (newX <= highArea.x))
                            {
                                count++;
                                int location = newX + img->width * newY;
                                R += temp->data[location].r;
                                G += temp->data[location].g;
                                B += temp->data[location].b;
                            }
                        }
                    }
                }
                
                if (count != 0)
                {
                    R = limitRGBA.intForceLimit(R / count);
                    G = limitRGBA.intForceLimit(G / count);
                    B = limitRGBA.intForceLimit(B / count);
                }
                point offset;
                float radius, xValue;
                
                if (mode == 1)
                {
                    // red
                    offset.set(int(value1 / 4.0), int(value1 / 4.0));
                    radius = sqrt(value1*value1 * (1.0 * R / 255)) / sqrt(M_PI);
                    for (int y = int(offset.y - radius); y < int(offset.y + radius); y++)
                    {
                        xValue = sqrt((radius*radius) - ((y - offset.y)*(y - offset.y)));
                        for (int x = int(offset.x - xValue); x < int(offset.x + xValue); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            newY = int(lowArea.y + by*value1 + y);
                            int location = newX + img->width * newY;
                            if ((newY >= lowArea.y) && (newY <= highArea.y) && (newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[location].r = 255;
                        }
                    }
    
                    // green
                    offset.set(int(value1 / 4.0 * 3.0), 0);
                    radius = sqrt(value1*value1 * (1.0 * G / 255)) / sqrt(M_PI);
                    for (int y = int(offset.y - radius); y < int(offset.y + radius); y++)
                    {
                        xValue = sqrt((radius*radius) - ((y - offset.y)*(y - offset.y)));
                        for (int x = int(offset.x - xValue); x < int(offset.x + xValue); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            newY = int(lowArea.y + by*value1 + y);
                            int location = newX + img->width * newY;
                            if ((newY >= lowArea.y) && (newY <= highArea.y) && (newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[location].g = 255;
                        }
                    }
    
                    // blue
                    offset.set(int(value1 / 2.0), int(value1 / 4.0 * 3.0));
                    radius = sqrt(value1*value1 * (1.0 * B / 255)) / sqrt(M_PI);
                    for (int y = int(offset.y - radius); y < int(offset.y + radius); y++)
                    {
                        xValue = sqrt((radius*radius) - ((y - offset.y)*(y - offset.y)));
                        for (int x = int(offset.x - xValue); x < int(offset.x + xValue); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            newY = int(lowArea.y + by*value1 + y);
                            int location = newX + img->width * newY;
                            if ((newY >= lowArea.y) && (newY <= highArea.y) && (newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[location].b = 255;
                        }
                    }
                }
                else if (mode == 2)
                {
                    // red
                    offset.set(int(value1 / 4.0), int(value1 / 4.0));
                    radius = sqrt(value1*value1 * (1.0 * (255-R) / 255)) / sqrt(M_PI);
                    for (int y = int(offset.y - radius); y < int(offset.y + radius); y++)
                    {
                        xValue = sqrt((radius*radius) - ((y - offset.y)*(y - offset.y)));
                        for (int x = int(offset.x - xValue); x < int(offset.x + xValue); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            newY = int(lowArea.y + by*value1 + y);
                            int location = newX + img->width * newY;
                            if ((newY >= lowArea.y) && (newY <= highArea.y) && (newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[location].r = 0;
                        }
                    }
    
                    // green
                    offset.set(int(value1 / 4.0 * 3.0), 0);
                    radius = sqrt(value1*value1 * (1.0 * (255-G) / 255)) / sqrt(M_PI);
                    for (int y = int(offset.y - radius); y < int(offset.y + radius); y++)
                    {
                        xValue = sqrt((radius*radius) - ((y - offset.y)*(y - offset.y)));
                        for (int x = int(offset.x - xValue); x < int(offset.x + xValue); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            newY = int(lowArea.y + by*value1 + y);
                            int location = newX + img->width * newY;
                            if ((newY >= lowArea.y) && (newY <= highArea.y) && (newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[location].g = 0;
                        }
                    }
    
                    // blue
                    offset.set(int(value1 / 2.0), int(value1 / 4.0 * 3.0));
                    radius = sqrt(value1*value1 * (1.0 * (255-B) / 255)) / sqrt(M_PI);
                    for (int y = int(offset.y - radius); y < int(offset.y + radius); y++)
                    {
                        xValue = sqrt((radius*radius) - ((y - offset.y)*(y - offset.y)));
                        for (int x = int(offset.x - xValue); x < int(offset.x + xValue); x++)
                        {
                            newX = int(lowArea.x + bx*value1 + x);
                            newY = int(lowArea.y + by*value1 + y);
                            int location = newX + img->width * newY;
                            if ((newY >= lowArea.y) && (newY <= highArea.y) && (newX >= lowArea.x) && (newX <= highArea.x))
                                img->data[location].b = 0;
                        }
                    }
                }
            }
        }
    }
}


void rgbdots::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | RGB-Dots | Mode 1: Additive");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | RGB-Dots | Mode 2: Subtractive");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

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

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

    value1 = 50;
    limitValue1.set(1, 200);

    imageRgbaCopy(img, temp);

    numModes = 2;
    mode = 1;
    
    this->changeMode(1);
}

void lines::LBAction()
{
    if (LBpressed)
    {
        if (mode == 1)
        {
            for (int iy = lowArea.y; iy <= highArea.y; iy++)
            {
                int x = lowArea.x, length = 0;
                while (x < highArea.x)
                {
                    x += length;
                    length = int(fmod(rand(), value1)) + 1;
                    int R = 0, G = 0, B = 0, count = 0;
                    for (int ix = x; (ix < (x + length)) && (ix <= highArea.x); ix++)
                    {
                        count++;
                        int location = ix + img->width * iy;
                        R += temp->data[location].r;
                        G += temp->data[location].g;
                        B += temp->data[location].b;
                    }
                    if (count != 0)
                    {
                        R = limitRGBA.intForceLimit(R / count);
                        G = limitRGBA.intForceLimit(G / count);
                        B = limitRGBA.intForceLimit(B / count);
                    }
                    for (int ix = x; (ix < (x + length)) && (ix <= highArea.x); ix++)
                    {
                        int location = ix + img->width * iy;
                        img->data[location] = (Rgba){R, G, B, 255};
                    }
                }
            }
        }
        if (mode == 2)
        {
            for (int ix = lowArea.x; ix <= highArea.x; ix++)
            {
                int y = lowArea.y, length = 0;
                while (y < highArea.y)
                {
                    y += length;
                    length = int(fmod(rand(), value1)) + 1;
                    int R = 0, G = 0, B = 0, count = 0;
                    for (int iy = y; (iy < (y + length)) && (iy <= highArea.y); iy++)
                    {
                        count++;
                        int location = ix + img->width * iy;
                        R += temp->data[location].r;
                        G += temp->data[location].g;
                        B += temp->data[location].b;
                    }
                    if (count != 0)
                    {
                        R = limitRGBA.intForceLimit(R / count);
                        G = limitRGBA.intForceLimit(G / count);
                        B = limitRGBA.intForceLimit(B / count);
                    }
                    for (int iy = y; (iy < (y + length)) && (iy <= highArea.y); iy++)
                    {
                        int location = ix + img->width * iy;
                        img->data[location] = (Rgba){R, G, B, 255};
                    }
                }
            }
        }
    }
}


void lines::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Lines | Mode 1: Horizontal");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Lines | Mode 2: Vertical");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

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

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

    value1 = 100;
    limitValue1.set(0, 100);
    value2 = 50;
    limitValue2.set(0, 100);
    
    bColorMenu = true;
    myColor = (Rgba){64, 64, 192, 255};
    
    imageRgbaCopy(img, temp);

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

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

void noise::LBAction()
{
    if (LBpressed)
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                int random = rand() % 100;
                int location = x + img->width * y;
                if (random < value1)
                {
                    float opacity = value2 / 100;
                    if (mode == 1)
                    {
                        img->data[location].r = limitRGBA.intForceLimit((1 - opacity) * temp->data[location].r + opacity * (rand() % 256));
                        img->data[location].g = limitRGBA.intForceLimit((1 - opacity) * temp->data[location].g + opacity * (rand() % 256));
                        img->data[location].b = limitRGBA.intForceLimit((1 - opacity) * temp->data[location].b + opacity * (rand() % 256));
                    }
                    if (mode == 2)
                    {
                        img->data[location].r = limitRGBA.intForceLimit((1 - opacity) * temp->data[location].r + opacity * (limitRGBA.intForceLimit(myColor.r + (rand() % 256))));
                        img->data[location].g = limitRGBA.intForceLimit((1 - opacity) * temp->data[location].g + opacity * (limitRGBA.intForceLimit(myColor.g + (rand() % 256))));
                        img->data[location].b = limitRGBA.intForceLimit((1 - opacity) * temp->data[location].b + opacity * (limitRGBA.intForceLimit(myColor.b + (rand() % 256))));
                    }
                }
                else
                    img->data[location] = temp->data[location];
            }
        }                
    }
}

void noise::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Noise | Mode 1: Random");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Noise | Mode 2: Colorized");
        
    if (!LBpressed)
    {
        LBpressed = true;
        this->LBAction();
        LBpressed = false;
    }
    else
        this->LBAction();
}

---