---

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

Go to the documentation of this file.

#include "matrices.h"

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

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

    imageRgbaCopy(img, temp);
    imageRgbaCopy(img, temp2);

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

void blur::LBAction()
{
    if (LBpressed)
    {
        if (mode == 1 || mode == 2 || mode == 3 || mode == 4)
        {
            int loops = 1;
            float oldValue1 = value1;
            ImageRGBA *swap;
            
            imageRgbaCopy(temp, temp2);

            if (mode == 2)
                loops = int(oldValue1);

            for (int l = 0; l < loops; l++)
            {
                if (mode == 2 && l > 0)
                {
                    value1 = int(exp((l*-l)/oldValue1) * oldValue1);
                    swap = img;
                    img = temp2;
                    temp2 = swap;
                }
                
                if (value1 > 0)
                {
                    // horizontal motion blur
                    if (mode == 1 ||  mode == 2 || mode == 3)
                    {
                        horizontal_blur(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, mode);
                    }
    
                    if (mode == 1 ||  mode == 2 || mode == 4)
                    {
                        if (mode != 4)
                        {
                            swap = img;
                            img = temp2;
                            temp2 = swap;
                        }
            
                        vertical_blur(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, mode);
                    }
                }
            }
            value1 = oldValue1;
            display = img;
            this->refreshImage();
        }
        if (mode == 5) // motion
        {
            motion_blur(img, temp, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, value2, mode);
        }
        if (mode == 6) // radial
        {
/*
            int newX, newY;
            imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){0, 0, 0, 0});
            point middle = point(int((highArea.x - lowArea.x)/2+1), int((highArea.y - lowArea.y)/2+1));
            float radius, angle;
            int R[4] = {0, 0, 0, 0};
            int G[4] = {0, 0, 0, 0};
            int B[4] = {0, 0, 0, 0};
            int count[4] = {0, 0, 0, 0};
            int maxY, location, location2;
            int newValue1;
            int oldValue1, olderValue1;
            
            int startX = 2 * (mouse.x - middle.x);
            int startY = 2 * (mouse.y - middle.y);
            if (startX > 0)
                startX = 0;
            if (startY > 0)
                startY = 0;
            middle = mouse;

            for (int x = startX; x <= middle.x; x++)
            {
                if (x != startX)
                    maxY = startY;
                else
                    maxY = middle.y;

                for (int y = startY; 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)
                        {
                            for (int i = 0; i < 4; i++)
                            {
                                location = (lowArea.x + middle.x) + img->width * (lowArea.y + middle.y);
                                newX =lowArea.x + middle.x;
                                R[i] = 0;
                                G[i] = 0;
                                B[i] = 0;
                                count[i] = 0;
                            }
                        }
                        else if (r >= newValue1 && olderValue1 == newValue1)
                        {
                            // SUBTRACT
                            int r2 = r - 1;
                            for (int i = 0; i < 4; i++)
                            {
                                if (i == 0)
                                {
                                    newX = lowArea.x + int(middle.x - sin(angle)*(r2-2*newValue1));
                                    newY = lowArea.y + int(middle.y - cos(angle)*(r2-2*newValue1));
                                }
                                if (i == 1)
                                {
                                    newX = lowArea.x + int(middle.x - sin(angle)*(r2-2*newValue1));
                                    newY = lowArea.y + int(middle.y + cos(angle)*(r2-2*newValue1));
                                }
                                if (i == 2)
                                {
                                    newX = lowArea.x + int(middle.x + sin(angle)*(r2-2*newValue1));
                                    newY = lowArea.y + int(middle.y + cos(angle)*(r2-2*newValue1));
                                }
                                if (i == 3)
                                {
                                    newX = lowArea.x + int(middle.x + sin(angle)*(r2-2*newValue1));
                                    newY = lowArea.y + 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[i]--;
                                    R[i] -= temp->data[location].r;
                                    G[i] -= temp->data[location].g;
                                    B[i] -= temp->data[location].b;
                                }
                            }
                        }
    
                        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
                            for (int i = 0; i < 4; i++)
                            {
                                if (i == 0)
                                {
                                    newX = lowArea.x + int(middle.x - sin(angle)*r);
                                    newY = lowArea.y + int(middle.y - cos(angle)*r);
                                }
                                if (i == 1)
                                {
                                    newX = lowArea.x + int(middle.x - sin(angle)*r);
                                    newY = lowArea.y + int(middle.y + cos(angle)*r);
                                }
                                if (i == 2)
                                {
                                    newX = lowArea.x + int(middle.x + sin(angle)*r);
                                    newY = lowArea.y + int(middle.y + cos(angle)*r);
                                }
                                if (i == 3)
                                {
                                    newX = lowArea.x + int(middle.x + sin(angle)*r);
                                    newY = lowArea.y + 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[i]++;
                                    R[i] += temp->data[location].r;
                                    G[i] += temp->data[location].g;
                                    B[i] += temp->data[location].b;
                                }
                            }
                            // DRAW
                            for (int i = 0; i < 4; i++)
                            {
                                if (i == 0)
                                {
                                    newX = lowArea.x + int(middle.x - sin(angle)*(r-newValue1));
                                    newY = lowArea.y + int(middle.y - cos(angle)*(r-newValue1));
                                }
                                if (i == 1)
                                {
                                    newX = lowArea.x + int(middle.x - sin(angle)*(r-newValue1));
                                    newY = lowArea.y + int(middle.y + cos(angle)*(r-newValue1));
                                }
                                if (i == 2)
                                {
                                    newX = lowArea.x + int(middle.x + sin(angle)*(r-newValue1));
                                    newY = lowArea.y + int(middle.y + cos(angle)*(r-newValue1));
                                }
                                if (i == 3)
                                {
                                    newX = lowArea.x + int(middle.x + sin(angle)*(r-newValue1));
                                    newY = lowArea.y + int(middle.y - cos(angle)*(r-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[i] / count[i]), limitRGBA.intForceLimit(G[i] / count[i]), limitRGBA.intForceLimit(B[i] / count[i]), 255};
                                }
                            }
                        }
                    }
                }
            }
*/

            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, location, location2;
            int newValue1;
            int oldValue1, olderValue1;

            int R, G, B, 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;
                            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 -= temp->data[location].r;
                                G -= temp->data[location].g;
                                B -= temp->data[location].b;
                            }
                        }

                        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 += temp->data[location].r;
                                G += temp->data[location].g;
                                B += temp->data[location].b;
                            }
                            // DRAW
                            newX = int(middle.x - sin(angle)*(r-1*newValue1));
                            newY = int(middle.y - cos(angle)*(r-1*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), 255};
                            }
                        }
                    }
                }
            }

            // 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;
                            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 -= temp->data[location].r;
                                G -= temp->data[location].g;
                                B -= temp->data[location].b;
                            }
                        }

                        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 += temp->data[location].r;
                                G += temp->data[location].g;
                                B += temp->data[location].b;
                            }
                            // DRAW
                            newX = int(middle.x - sin(angle)*(r-1*newValue1));
                            newY = int(middle.y + cos(angle)*(r-1*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), 255};
                            }
                        }
                    }
                }
            }

            // 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;
                            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 -= temp->data[location].r;
                                G -= temp->data[location].g;
                                B -= temp->data[location].b;
                            }
                        }

                        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 += temp->data[location].r;
                                G += temp->data[location].g;
                                B += temp->data[location].b;
                            }
                            // DRAW
                            newX = int(middle.x + sin(angle)*(r-1*newValue1));
                            newY = int(middle.y - cos(angle)*(r-1*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), 255};
                            }
                        }
                    }
                }
            }

            // 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;
                            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 -= temp->data[location].r;
                                G -= temp->data[location].g;
                                B -= temp->data[location].b;
                            }
                        }

                        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 += temp->data[location].r;
                                G += temp->data[location].g;
                                B += temp->data[location].b;
                            }
                            // DRAW
                            newX = int(middle.x + sin(angle)*(r-1*newValue1));
                            newY = int(middle.y + cos(angle)*(r-1*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), 255};
                            }
                        }
                    }
                }
            }

            // 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)
                    {
                        newX = (middle.x - (x - lowArea.x));
                        newY = (middle.y - (y - lowArea.y));
                        radius = sqrt(newX*newX + newY*newY);
                        angle = atan((float)abs(newX) / abs(newY));
                        int secondX, secondY;
                        for (int r = 0; r < radius; r++)
                        {
                            if (newX != 0)
                                secondX = x + int((1.0 * newX / abs(newX)) * sin(angle)*r);
                            else
                                secondX = x;
                            if (newY != 0)
                                secondY = y + int((1.0 * newY / abs(newY)) * cos(angle)*r);
                            else
                                secondY = y;
                                
                            if (secondX >= lowArea.x && secondX <= highArea.x && secondY >= lowArea.y && secondY <= highArea.y)
                            {
                                location2 = secondX + img->width * secondY;
                                if (img->data[location2].a != 0)
                                {
                                    img->data[location] = img->data[location2];
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
        if (mode == 7) // spheric
        {
            int newX, newY;
            imageRgbaSetArea(img, lowArea.x, lowArea.y, highArea.x+1, highArea.y+1, (Rgba){0, 0, 0, 0});
            point middle = point(int((highArea.x - lowArea.x)/2+1), int((highArea.y - lowArea.y)/2+1));

            int positionX;
            if (mouse.x <= middle.x)
                positionX = highArea.x - mouse.x;
            else
                positionX = mouse.x;

            int positionY;
            if (mouse.y <= middle.y)
                positionY = highArea.y - mouse.y;
            else
                positionY = mouse.y;

            middle = mouse;
            
//            int radius = int(sqrt(((highArea.x-lowArea.x+1)/2)*((highArea.x-lowArea.x+1)/2) + ((highArea.y-lowArea.y+1)/2)*((highArea.y-lowArea.y+1)/2)));
            int radius = int(sqrt(positionX*positionX + positionY*positionY));
            int R = 0, G = 0, B = 0, count = 0;
            int location;
            int newValue1;
            
            for (int r = 1; r <= radius; r++)
            {
                R = 0;
                G = 0;
                B = 0;
                count = 0;
                float angleAdd = (atan((float)1 / r));
                newValue1 = int((float) r / radius * value1);
                for (int angle = 0; angle < ((2*M_PI)/angleAdd + 2*newValue1); angle++)
                {
                    // remove
                    if ((angle - 2*newValue1 - angleAdd) >= 0)
                    {
                        newX = int(lowArea.x + middle.x + sin((angle - 2*newValue1 - 1) * angleAdd) * r);
                        newY = int(lowArea.y + middle.y + cos((angle - 2*newValue1 - 1) * angleAdd) * r);
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            R -= temp->data[location].r;
                            G -= temp->data[location].g;
                            B -= temp->data[location].b;
                            count--;
                        }
                    }

                    // add
                    if (angle >= 0)
                    {
                        newX = int(lowArea.x + middle.x + sin((angle) * angleAdd) * r);
                        newY = int(lowArea.y + middle.y + cos((angle) * angleAdd) * r);
                        if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                        {
                            location = newX + img->width * newY;
                            R += temp->data[location].r;
                            G += temp->data[location].g;
                            B += temp->data[location].b;
                            count++;
                        }
                    }
                    
                    // draw
                    if ((angle - 2*newValue1) >= 0)
                    {
                        newX = int(lowArea.x + middle.x + sin((angle - newValue1) * angleAdd) * r);
                        newY = int(lowArea.y + middle.y + cos((angle - newValue1) * angleAdd) * r);
                        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),
                                                            255
                                                            };
                        }
                    }
                }
            }
            
            // fehlerkorrektur
            float angle;
            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)
                    {
                        if (img->data[x + img->width * y].a == 0)
                        {
                            newX = (middle.x - (x - lowArea.x));
                            newY = (middle.y - (y - lowArea.y));
                            radius = int(sqrt(newX*newX + newY*newY));
                            if (newY == 0 && newX > 0)
                                angle = M_PI / 2;
                            else
                                angle = atan((float)newX / newY);
                            
                            if (newX == 0 && newY == 0)
                                angle = 0;
        
                            if (newY >= 0)
                                angle += M_PI;


                            float angleAdd = atan((float)1 / radius);
                            for (; angle < (4*M_PI); angle += angleAdd)
                            {
                                newX = int(lowArea.x + middle.x + sin(angle) * radius);
                                newY = int(lowArea.y + middle.y + cos(angle) * radius);
                                if (newX >= lowArea.x && newX <= highArea.x && newY >= lowArea.y && newY <= highArea.y)
                                {
                                    if (img->data[newX + img->width * newY].a != 0)
                                    {
                                        img->data[x + img->width * y] = img->data[newX + img->width * newY];
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void blur::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
    {
        glutSetWindowTitle("Paint Application | Blur | Mode 1: Simple Blur");
        limitValue1.set(1, 250);
        value1 = 10;
        limitValue2.set(0, 0);
        value2 = 0;
    }
    else if (mode == 2)
    {
        glutSetWindowTitle("Paint Application | Blur | Mode 2: Gaussian Blur");
        limitValue1.set(1, 100);
        value1 = 5;
        limitValue2.set(0, 0);
        value2 = 0;
    }
    else if (mode == 3)
    {
        glutSetWindowTitle("Paint Application | Blur | Mode 3: Motion Blur Horizontal");
        limitValue1.set(1, 250);
        value1 = 5;
        limitValue2.set(0, 0);
        value2 = 0;
    }
    else if (mode == 4)
    {
        glutSetWindowTitle("Paint Application | Blur | Mode 4: Motion Blur Vertical");
        limitValue1.set(1, 250);
        value1 = 5;
        limitValue2.set(0, 0);
        value2 = 0;
    }
    else if (mode == 5)
    {
        glutSetWindowTitle("Paint Application | Blur | Mode 5: Motion Blur");
        limitValue1.set(1, 250);
        value1 = 5;
        limitValue2.set(1, 179);
        value2 = 45;
    }
    else if (mode == 6)
    {
        glutSetWindowTitle("Paint Application | Blur | Mode 6: Radial Blur");
        limitValue1.set(1, int(sqrt(((highArea.x-lowArea.x+1)/2)*((highArea.x-lowArea.x+1)/2) + ((highArea.y-lowArea.y+1)/2)*((highArea.y-lowArea.y+1)/2))/2));
        value1 = 10;
        limitValue2.set(0, 0);
        value2 = 0;
    }
    else if (mode == 7)
    {
        glutSetWindowTitle("Paint Application | Blur | Mode 7: Spheric Blur");
        limitValue1.set(1, 250);
        value1 = 10;
        limitValue2.set(0, 0);
        value2 = 0;
    }
        
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

void blur::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        value1 += 1;
    else if (_key == GLUT_KEY_DOWN)
        value1 -= 1;

    if (_key == GLUT_KEY_LEFT)
        value2 -= 3;
    else if (_key == GLUT_KEY_RIGHT)
        value2 += 3;

    value1 = limitValue1.intForceLimit(value1);
    if (value2 > limitValue2.high)
        value2 = limitValue2.low;
    if (value2 < limitValue2.low)
        value2 = limitValue2.high;

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

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

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

    imageRgbaCopy(img, temp);
    imageRgbaCopy(img, temp2);
    
    M[0] = new matrix ((float[9]) { -0.1, -0.1, -0.1,
                                    -0.1, 1.8, -0.1,
                                    -0.1, -0.1, -0.1 }, 1, 1);
    M[1] = new matrix ((float[9]) { -0.2, -0.2, -0.2,
                                    -0.2, 2.6, -0.2,
                                    -0.2, -0.2, -0.2 }, 1, 1);
    M[2] = new matrix ((float[9]) { -0.3, -0.3, -0.3,
                                    -0.3, 3.4, -0.3,
                                    -0.3, -0.3, -0.3 }, 1, 1);
    M[3] = new matrix ((float[9]) { -0.4, -0.4, -0.4,
                                    -0.4, 4.2, -0.4,
                                    -0.4, -0.4, -0.4 }, 1, 1);
    M[4] = new matrix ((float[9]) { -0.5, -0.5, -0.5,
                                    -0.5, 5.0, -0.5,
                                    -0.5, -0.5, -0.5 }, 1, 1);
    M[5] = new matrix ((float[9]) { -0.7, -0.7, -0.7,
                                    -0.7, 6.6, -0.7,
                                    -0.7, -0.7, -0.7 }, 1, 1);
    M[6] = new matrix ((float[9]) { -0.9, -0.9, -0.9,
                                    -0.9, 8.2, -0.9,
                                    -0.9, -0.9, -0.9 }, 1, 1);
    M[7] = new matrix ((float[9]) { -1.1, -1.1, -1.1,
                                    -1.1, 9.8, -1.1,
                                    -1.1, -1.1, -1.1 }, 1, 1);
    M[8] = new matrix ((float[9]) { -1.4, -1.4, -1.4,
                                    -1.4, 12.2, -1.4,
                                    -1.4, -1.4, -1.4 }, 1, 1);
    M[9] = new matrix ((float[9]) { -1.8, -1.8, -1.8,
                                    -1.8, 15.4, -1.8,
                                    -1.8, -1.8, -1.8 }, 1, 1);

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

sharpen::~sharpen()
{
    for (int i = 0; i < 10; i++)
        if (M[i])    
        {
            delete M[i];
            M[i] = 0;
        }

}

void sharpen::LBAction()
{
    if (LBpressed)
    {
        int location;
        
        if (mode == 1 || mode == 2)
        {
            gaussian(img, temp2, lowArea.x, lowArea.y, highArea.x, highArea.y, value1, mode);

            display = img;
            this->refreshImage();
            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(2 * temp->data[location].r - img->data[location].r);
                    img->data[location].g = limitRGBA.intForceLimit(2 * temp->data[location].g - img->data[location].g);
                    img->data[location].b = limitRGBA.intForceLimit(2 * temp->data[location].b - img->data[location].b);
                }
            }
        }
        if (mode == 3)
        {
            for (int y = lowArea.y; y <= highArea.y; y++)
            {
                for (int x = lowArea.x; x <= highArea.x; x++)
                {
                    img->data[x + img->width * y] = applyMatrix(temp, M[int(value1)], x, y, lowArea, highArea);
                }
            }            
        }
    }
}

void sharpen::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
    {
        glutSetWindowTitle("Paint Application | Sharpen | Mode 1: Simple Sharpen");
        limitValue1.set(1, 250);
        value1 = 5;
    }
    else if (mode == 2)
    {
        glutSetWindowTitle("Paint Application | Sharpen | Mode 2: Gaussian Sharpen");
        limitValue1.set(1, 100);
        value1 = 5;
    }
    else if (mode == 3)
    {
        glutSetWindowTitle("Paint Application | Sharpen | Mode 3: Predefined Sharpen");
        limitValue1.set(0, 9);
        value1 = 1;
    }

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

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

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

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

void edge::matrixAction(int _x, int _y)
{
    if (mode != 3 && mode != 6 && mode != 7)
        img->data[_x + img->width * _y] = applyMatrix(temp, M[int(value1)], _x, _y, lowArea, highArea);
    else if (mode == 3)
    {
        int location = _x + img->width * _y;
        temp2->data[location] = applyMatrix(temp, M[int(value1)], _x, _y, lowArea, highArea);
        img->data[location] = applyMatrix(temp, M[int(value1)+5], _x, _y, lowArea, highArea);
        img->data[location].r = limitRGBA.intForceLimit(img->data[location].r + temp2->data[location].r);
        img->data[location].g = limitRGBA.intForceLimit(img->data[location].g + temp2->data[location].g);
        img->data[location].b = limitRGBA.intForceLimit(img->data[location].b + temp2->data[location].b);
    }
    else if (mode == 6)
    {
        int location = _x + img->width * _y;
        temp2->data[location] = applyMatrix(temp, M[int(value1)], _x, _y, lowArea, highArea);
        img->data[location].r = limitRGBA.intForceLimit(temp->data[location].r + temp2->data[location].r);
        img->data[location].g = limitRGBA.intForceLimit(temp->data[location].g + temp2->data[location].g);
        img->data[location].b = limitRGBA.intForceLimit(temp->data[location].b + temp2->data[location].b);
    }
    else if (mode == 7)
    {
        int location = _x + img->width * _y;
        temp2->data[location] = applyMatrix(temp, M[int(value1)], _x, _y, lowArea, highArea);
        img->data[location].r = limitRGBA.intForceLimit(temp->data[location].r - temp2->data[location].r);
        img->data[location].g = limitRGBA.intForceLimit(temp->data[location].g - temp2->data[location].g);
        img->data[location].b = limitRGBA.intForceLimit(temp->data[location].b - temp2->data[location].b);
    }
}

edge::~edge()
{
    for (int i = 0; i < 10; i++)
        if (M[i])    
        {
            delete M[i];
            M[i] = 0;
        }

}

void edge::changeMode(char _mode)
{
    for (int i = 0; i < 10; i++)
        if (M[i])
        {
            delete M[i];
            M[i] = 0;
        }
    
    mode = _mode;
    if (mode == 1)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 1: Laplace");
        limitValue1.set(0, 4);
        value1 = 0;
    }
    if (mode == 2)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 2: Strong Laplace");
        limitValue1.set(0, 4);
        value1 = 0;
        M[0] = new matrix ((float[9]) { 1, 1, 1,
                                        1, -8, 1,
                                        1, 1, 1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 0, 1, 1, 1, 0,
                                         1, 0, 0, 0, 1,
                                         1, 0, -12, 0, 1,
                                         1, 0, 0, 0, 1,
                                         0, 1, 1, 1, 0 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 0, 0, 1, 1, 1, 0, 0,
                                         0, 1, 0, 0, 0, 1, 0,
                                         1, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, -16, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 1,
                                         0, 1, 0, 0, 0, 1, 0,
                                         0, 0, 1, 1, 1, 0, 0 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 0, 0, 1, 1, 1, 1, 1, 0, 0,
                                         0, 1, 0, 0, 0, 0, 0, 1, 0,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, 0, -24, 0, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         0, 1, 0, 0, 0, 0, 0, 1, 0,
                                         0, 0, 1, 1, 1, 1, 1, 0, 0 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
                                          0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
                                          0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, -28, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
                                          0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
                                          0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0 }, 5, 1);
    }
    else if (mode == 3)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 3: Sobel Combined");
        limitValue1.set(0, 4);
        value1 = 0;
    }
    else if (mode == 4)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 4: Sobel Horizontal");
        limitValue1.set(0, 4);
        value1 = 0;
    }
    else if (mode == 5)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 5: Sobel Vertical");
        limitValue1.set(5, 9);
        value1 = 5;
    }
    else if (mode == 6)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 6: Lighten Edges");
        limitValue1.set(0, 4);
        value1 = 0;
    }
    else if (mode == 7)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 7: Darken Edges");
        limitValue1.set(0, 4);
        value1 = 0;
    }
    else if (mode == 8)
    {
        glutSetWindowTitle("Paint Application | Edge | Mode 8: Ghost");
        limitValue1.set(0, 4);
        value1 = 0;
        M[0] = new matrix ((float[9]) { 1, 1, 1,
                                        1, -7, 1,
                                        1, 1, 1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 0, 1, 1, 1, 0,
                                         1, 0, 0, 0, 1,
                                         1, 0, -11, 0, 1,
                                         1, 0, 0, 0, 1,
                                         0, 1, 1, 1, 0 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 0, 0, 1, 1, 1, 0, 0,
                                         0, 1, 0, 0, 0, 1, 0,
                                         1, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, -15, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 1,
                                         0, 1, 0, 0, 0, 1, 0,
                                         0, 0, 1, 1, 1, 0, 0 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 0, 0, 1, 1, 1, 1, 1, 0, 0,
                                         0, 1, 0, 0, 0, 0, 0, 1, 0,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, 0, -23, 0, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         0, 1, 0, 0, 0, 0, 0, 1, 0,
                                         0, 0, 1, 1, 1, 1, 1, 0, 0 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
                                          0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
                                          0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, -27, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
                                          0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
                                          0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0 }, 5, 1);
    }

    if (mode == 3 || mode == 4 || mode == 5)
    {
        M[0] = new matrix ((float[9]) { -1, 0, 1,
                                        -2, 0, 2,
                                        -1, 0, 1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { -1, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 1,
                                         -2, 0, 0, 0, 2,
                                         -1, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -2, 0, 0, 0, 0, 0, 2,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -2, 0, 0, 0, 0, 0, 0, 0, 2,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, 5, 1);
                                          
        M[5] = new matrix ((float[9]) { -1, -2, -1,
                                        0, 0, 0,
                                        1, 2, 1 }, 1, 1);
       
        M[6] = new matrix ((float[25]) { -1, -1, -2, -1, -1,
                                         0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0,
                                         1, 1, 2, 1, 1 }, 2, 1);
    
        M[7] = new matrix ((float[49]) { -1, -1, -1, -2, -1, -1, -1,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         1, 1, 1, 2, 1, 1, 1 }, 3, 1);
       
        M[8] = new matrix ((float[81]) { -1, -1, -1, -1, -2, -1, -1, -1, -1,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         1, 1, 1, 1, 2, 1, 1, 1, 1 }, 4, 1);
       
        M[9] = new matrix ((float[121]) { -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1 }, 5, 1);
        
    }
    if (mode == 1 || mode == 6 || mode == 7)
    {
        M[0] = new matrix ((float[9]) { 0, 1, 0,
                                        1, -4, 1,
                                        0, 1, 0 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 0, 0, 1, 0, 0,
                                         0, 0, 0, 0, 0,
                                         1, 0, -4, 0, 1,
                                         0, 0, 0, 0, 0,
                                         0, 0, 1, 0, 0 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 0, 0, 0, 1, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         1, 0, 0, -4, 0, 0, 1,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 1, 0, 0, 0 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 0, 0, 0, 0, 1, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         1, 0, 0, 0, -4, 0, 0, 0, 1,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 1, 0, 0, 0, 0 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          1, 0, 0, 0, 0, -4, 0, 0, 0, 0, 1,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }, 5, 1);
    }
        
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

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

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

    imageRgbaCopy(img, temp);
    
    limitValue1.set(0, 4);
    value1 = 0;

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

emboss::~emboss()
{
    for (int i = 0; i < 10; i++)
        if (M[i])    
        {
            delete M[i];
            M[i] = 0;
        }
}

void emboss::changeMode(char _mode)
{
    for (int i = 0; i < 10; i++)
        if (M[i])    
        {
            delete M[i];
            M[i] = 0;
        }

    mode = _mode;
    if (mode == 1)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 1: Right");
        M[0] = new matrix ((float[9]) { 1, 0, -1,
                                        2, 1, -2,
                                        1, 0, -1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 1, 0, 0, 0, -1,
                                         1, 0, 0, 0, -1,
                                         2, 0, 1, 0, -2,
                                         1, 0, 0, 0, -1,
                                         1, 0, 0, 0, -1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         2, 0, 0, 1, 0, 0, -2,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         2, 0, 0, 0, 1, 0, 0, 0, -2,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          2, 0, 0, 0, 0, 1, 0, 0, 0, 0, -2,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1 }, 5, 1);
    }
    if (mode == 2)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 2: Right-Up");
        M[0] = new matrix ((float[9]) { 1, -2, -1,
                                        2, 1, -2,
                                        1, 2, -1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 1, -1, -2, -1, -1,
                                         1, 0, 0, 0, -1,
                                         2, 0, 1, 0, -2,
                                         1, 0, 0, 0, -1,
                                         1, 1, 2, 1, -1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 1, -1, -1, -2, -1, -1, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         2, 0, 0, 1, 0, 0, -2,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 1, 1, 2, 1, 1, -1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 1, -1, -1, -1, -2, -1, -1, -1, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         2, 0, 0, 0, 1, 0, 0, 0, -2,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 1, 1, 1, 2, 1, 1, 1, -1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          2, 0, 0, 0, 0, 1, 0, 0, 0, 0, -2,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 1, 1, 1, 1, 2, 1, 1, 1, 1, -1 }, 5, 1);
    }
    if (mode == 3)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 3: Up");
        M[0] = new matrix ((float[9]) { -1, -2, -1,
                                        0, 1, 0,
                                        1, 2, 1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { -1, -1, -2, -1, -1,
                                         0, 0, 0, 0, 0,
                                         0, 0, 1, 0, 0,
                                         0, 0, 0, 0, 0,
                                         1, 1, 2, 1, 1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { -1, -1, -1, -2, -1, -1, -1,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 1, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         1, 1, 1, 2, 1, 1, 1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { -1, -1, -1, -1, -2, -1, -1, -1, -1,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 1, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         1, 1, 1, 1, 2, 1, 1, 1, 1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1 }, 5, 1);
        
    }
    if (mode == 4)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 4: Left-Up");
        M[0] = new matrix ((float[9]) { -1, -2, -1,
                                        -2, 1, 2,
                                        1, 2, 1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { -1, -1, -2, -1, -1,
                                         -1, 0, 0, 0, 1,
                                         -2, 0, 1, 0, 2,
                                         -1, 0, 0, 0, 1,
                                         1, 1, 2, 1, 1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { -1, -1, -1, -2, -1, -1, -1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -2, 0, 0, 1, 0, 0, 2,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         1, 1, 1, 2, 1, 1, 1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { -1, -1, -1, -1, -2, -1, -1, -1, -1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -2, 0, 0, 0, 1, 0, 0, 0, 2,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         1, 1, 1, 1, 2, 1, 1, 1, 1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1 }, 5, 1);
        
    }
    if (mode == 5)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 5: Left");
        M[0] = new matrix ((float[9]) { -1, 0, 1,
                                        -2, 1, 2,
                                        -1, 0, 1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { -1, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 1,
                                         -2, 0, 1, 0, 2,
                                         -1, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { -1, 0, 0, 0, 0, 1, 0,
                                         -1, 0, 0, 0, 0, 1, 0,
                                         -1, 0, 0, 0, 0, 1, 0,
                                         -2, 0, 0, 1, 0, 2, 0,
                                         -1, 0, 0, 0, 0, 1, 0,
                                         -1, 0, 0, 0, 0, 1, 0,
                                         -1, 0, 0, 0, 0, 1, 0 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -2, 0, 0, 0, 1, 0, 0, 0, 2,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, 5, 1);
    }
    if (mode == 6)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 6: Left-Down");
        M[0] = new matrix ((float[9]) { 1, 2, 1,
                                        -2, 1, 2,
                                        -1, -2, -1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 1, 1, 2, 1, 1,
                                         -1, 0, 0, 0, 1,
                                         -2, 0, 1, 0, 2,
                                         -1, 0, 0, 0, 1,
                                         -1, -1, -2, -1, -1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 1, 1, 1, 2, 1, 1, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -2, 0, 0, 1, 0, 0, 2,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 1,
                                         -1, -1, -1, -2, -1, -1, -1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 1, 1, 1, 1, 2, 1, 1, 1, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -2, 0, 0, 0, 1, 0, 0, 0, 2,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, 0, 0, 0, 0, 0, 0, 0, 1,
                                         -1, -1, -1, -1, -2, -1, -1, -1, -1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                          -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1 }, 5, 1);
    }
    if (mode == 7)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 7: Down");
        M[0] = new matrix ((float[9]) { 1, 2, 1,
                                        0, 1, 0,
                                        -1, -2, -1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 1, 1, 2, 1, 1,
                                         0, 0, 0, 0, 0,
                                         0, 0, 1, 0, 0,
                                         0, 0, 0, 0, 0,
                                         -1, -1, -2, -1, -1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 1, 1, 1, 2, 1, 1, 1,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 1, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0,
                                         -1, -1, -1, -2, -1, -1, -1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 1, 1, 1, 1, 2, 1, 1, 1, 1,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 1, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0, 0,
                                         -1, -1, -1, -1, -2, -1, -1, -1, -1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                          -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1 }, 5, 1);
        
    }
    if (mode == 8)
    {
        glutSetWindowTitle("Paint Application | Emboss | Mode 8: Right-Down");
        M[0] = new matrix ((float[9]) { 1, 2, -1,
                                        2, 1, -2,
                                        1, -2, -1 }, 1, 1);
       
        M[1] = new matrix ((float[25]) { 1, 1, 2, 1, -1,
                                         1, 0, 0, 0, -1,
                                         2, 0, 1, 0, -2,
                                         1, 0, 0, 0, -1,
                                         1, -1, -2, -1, -1 }, 2, 1);
    
        M[2] = new matrix ((float[49]) { 1, 1, 1, 2, 1, 1, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         2, 0, 0, 1, 0, 0, -2,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, -1,
                                         1, -1, -1, -2, -1, -1, -1 }, 3, 1);
       
        M[3] = new matrix ((float[81]) { 1, 1, 1, 1, 2, 1, 1, 1, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         2, 0, 0, 0, 1, 0, 0, 0, -2,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, 0, 0, 0, 0, 0, 0, 0, -1,
                                         1, -1, -1, -1, -2, -1, -1, -1, -1 }, 4, 1);
       
        M[4] = new matrix ((float[121]) { 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          2, 0, 0, 0, 0, 1, 0, 0, 0, 0, -2,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1,
                                          1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1 }, 5, 1);
    }

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

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

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

    imageRgbaCopy(img, temp);
    
    limitValue1.set(0, 4);
    value1 = 1;
    
    M[0] = new matrix ((float[9]) { 1, 0, 1,
                                    0, 0, 0,
                                    1, 0, 1 }, 1, 4);
   
    M[1] = new matrix ((float[25]) { 1, 0, 0, 0, 1,
                                     0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0,
                                     1, 0, 0, 0, 1 }, 2, 4);

    M[2] = new matrix ((float[49]) { 1, 0, 0, 0, 0, 0, 1,
                                     0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0,
                                     1, 0, 0, 0, 0, 0, 1 }, 3, 4);
   
    M[3] = new matrix ((float[81]) { 1, 0, 0, 0, 0, 0, 0, 0, 1,
                                     0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     1, 0, 0, 0, 0, 0, 0, 0, 1 }, 4, 4);
   
    M[4] = new matrix ((float[121]) { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, 5, 4);
   
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}

separate::~separate()
{
    for (int i = 0; i < 10; i++)
        if (M[i])    
        {
            delete M[i];
            M[i] = 0;
        }
}

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

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

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

void halfblur::LBAction()
{
    if (LBpressed)
    {
        int location;
        
        imageRgbaCopy(temp, temp2);

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

        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(((float)(100-value2)/100) * temp->data[location].r + ((float)(value2)/100) * temp2->data[location].r);
                img->data[location].g = limitRGBA.intForceLimit(((float)(100-value2)/100) * temp->data[location].g + ((float)(value2)/100) * temp2->data[location].g);
                img->data[location].b = limitRGBA.intForceLimit(((float)(100-value2)/100) * temp->data[location].b + ((float)(value2)/100) * temp2->data[location].b);
                img->data[location].a = 255;
            }
        }

        display = img;
        this->refreshImage();
    }
}

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

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

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

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

void whiteblur::LBAction()
{
    if (LBpressed)
    {
        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))
                {
                    temp2->data[location] = temp->data[location];
                    temp2->data[location].a = 255;
                }
                else
                    temp2->data[location].a = 0;
            }
        }

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

        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 * temp2->data[location].r);
                img->data[location].g = limitRGBA.intForceLimit(temp->data[location].g + ((float)(temp2->data[location].a)/255) * newStrength * temp2->data[location].g);
                img->data[location].b = limitRGBA.intForceLimit(temp->data[location].b + ((float)(temp2->data[location].a)/255) * newStrength * temp2->data[location].b);
                img->data[location].a = 255;
            }
        }

        display = img;
        this->refreshImage();
    }
}

void whiteblur::changeMode(char _mode)
{
    mode = _mode;
    if (mode == 1)
        glutSetWindowTitle("Paint Application | Whiteblur | Mode 1: Simple");
    else if (mode == 2)
        glutSetWindowTitle("Paint Application | Whiteblur | Mode 2: Gaussian");
        
    LBpressed = true;
    this->LBAction();
    LBpressed = false;
}
    
// Blackblur                                                                 //
blackblur::blackblur(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application | Whiteblur");

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

    imageRgbaCopy(img, temp);
    
    limitValue1.set(1, 200);
    value1 = 40;
    limitValue2.set(0, 255);
    value2 = 150;

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

void blackblur::LBAction()
{
    if (LBpressed)
    {
        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 <= value2)
                {
                    temp2->data[location] = temp->data[location];
                    temp2->data[location].a = 255;
                }
                else
                    temp2->data[location].a = 0;
            }
        }

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

        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 * temp2->data[location].r);
                img->data[location].g = limitRGBA.intForceLimit(temp->data[location].g - ((float)(temp2->data[location].a)/255) * newStrength * temp2->data[location].g);
                img->data[location].b = limitRGBA.intForceLimit(temp->data[location].b - ((float)(temp2->data[location].a)/255) * newStrength * temp2->data[location].b);
                img->data[location].a = 255;
            }
        }

        display = img;
        this->refreshImage();
    }
}

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

---