mambax7 / xoopseditors

#

# ========================================================================#

class imageLib

{

    private   $fileName;

    private   $image;

    protected $imageResized;

    private   $widthOriginal;     # Always be the original width

    private   $heightOriginal;

    private   $width;         # Current width (width after resize)

    private   $height;

    private   $imageSize;

    private   $fileExtension;

    private $isImage = false;

    private $debug      = true;

    private $errorArray = [];

    private $forceStretch        = true;

    private $aggresiveSharpening = false;

    private $transparentArray = ['.png', '.gif'];

    private $keepTransparency = true;

    private $fillColorArray   = ['r' => 255, 'g' => 255, 'b' => 255];

    private $sharpenArray = ['jpg'];

    private $psdReaderPath;

    private $filterOverlayPath;

    private $isInterlace;

    private $captionBoxPositionArray = [];

    private $fontDir = 'fonts';

    private $cropFromTopPercent = 10;

    ## --------------------------------------------------------

    public function __construct($fileName)

        # Author:     Jarrod Oberto

        # Date:       27-02-08

        # Purpose:    Constructor

        # Param in:   $fileName: File name and path.

        # Param out:  n/a

        # Reference:

        # Notes:

        #

    {

        if (!$this->testGDInstalled()) {

            if ($this->debug) {

                die('The GD Library is not installed.');

            } else {

                die();

            }

        }

        $this->initialise();

        // *** Save the image file name. Only store this incase you want to display it

        $this->fileName      = $fileName;

        $this->fileExtension = strtolower(strrchr($fileName, '.'));

        // *** Open up the file

        try {

            $this->image = $this->openImage($fileName);

        } catch (Exception $e) {

        }

        // *** Assign here so we don't modify the original

        $this->imageResized = $this->image;

        // *** If file is an image

        $this->isImage = $this->testIsImage();

        if ($this->isImage) {

            // *** Get width and height

            $this->width          = imagesx($this->image);

            $this->widthOriginal  = imagesx($this->image);

            $this->height         = imagesy($this->image);

            $this->heightOriginal = imagesy($this->image);

            /*  Added 15-09-08

             *  Get the filesize using this build in method.

             *  Stores an array of size

             *

             *  $this->imageSize[1] = width

             *  $this->imageSize[2] = height

             *  $this->imageSize[3] = width x height

             *

             */

            $this->imageSize = getimagesize($this->fileName);

        } else {

            $this->errorArray[] = 'File is not an image';

        }

    }

    ## --------------------------------------------------------

    private function initialise()

    {

        $this->psdReaderPath     = __DIR__ . '/classPhpPsdReader.php';

        $this->filterOverlayPath = __DIR__ . '/filters';

        // *** Set if image should be interlaced or not.

        $this->isInterlace = false;

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Resize

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function resizeImage($newWidth, $newHeight, $option = 0, $sharpen = false, $autoRotate = true)

        # Author:     Jarrod Oberto

        # Date:       27-02-08

        # Purpose:    Resizes the image

        # Param in:   $newWidth:

        #             $newHeight:

        #             $option:     0 / exact = defined size;

        #                          1 / portrait = keep aspect set height;

        #                          2 / landscape = keep aspect set width;

        #                          3 / auto = auto;

        #                          4 / crop= resize and crop;

        #

        #         $option can also be an array containing options for

        #         cropping. E.G., array('crop', 'r')

        #

        #         This array only applies to 'crop' and the 'r' refers to

        #         "crop right". Other value include; tl, t, tr, l, m (default),

        #         r, bl, b, br, or you can specify your own co-ords (which

        #         isn't recommended.

        #

        #       $sharpen:    true: sharpen (jpg only);

        #                false: don't sharpen

        # Param out:  n/a

        # Reference:

        # Notes:      To clarify the $option input:

        #               0 = The exact height and width dimensions you set.

        #               1 = Whatever height is passed in will be the height that

        #                   is set. The width will be calculated and set automatically

        #                   to a the value that keeps the original aspect ratio.

        #               2 = The same but based on the width. We try make the image the

        #                  biggest size we can while stil fitting inside the box size

        #               3 = Depending whether the image is landscape or portrait, this

        #                   will automatically determine whether to resize via

        #                   dimension 1,2 or 0

        #               4 = Will resize and then crop the image for best fit

        #

        #       forceStretch can be applied to options 1,2,3 and 4

        #

    {

        // *** We can pass in an array of options to change the crop position

        $cropPos = 'm';

        if (is_array($option) && 'crop' === strtolower($option[0])) {

            $cropPos = $option[1];         # get the crop option

        } elseif (false !== strpos($option, '-')) {

            // *** Or pass in a hyphen seperated option

            $optionPiecesArray = explode('-', $option);

            $cropPos           = end($optionPiecesArray);

        }

        // *** Check the option is valid

        try {

            $option = $this->prepOption($option);

        } catch (Exception $e) {

        }

        // *** Make sure the file passed in is valid

        if (!$this->image) {

            if ($this->debug) {

                die('file ' . $this->getFileName() . ' is missing or invalid');

            } else {

                die();

            }

        }

        // *** Get optimal width and height - based on $option

        $dimensionsArray = $this->getDimensions($newWidth, $newHeight, $option);

        $optimalWidth  = $dimensionsArray['optimalWidth'];

        $optimalHeight = $dimensionsArray['optimalHeight'];

        // *** Resample - create image canvas of x, y size

        $this->imageResized = imagecreatetruecolor($optimalWidth, $optimalHeight);

        $this->keepTransparancy($optimalWidth, $optimalHeight, $this->imageResized);

        imagecopyresampled($this->imageResized, $this->image, 0, 0, 0, 0, $optimalWidth, $optimalHeight, $this->width, $this->height);

        // *** If '4', then crop too

        if (4 == $option || 'crop' === $option) {

            if (($optimalWidth >= $newWidth && $optimalHeight >= $newHeight)) {

                $this->crop($optimalWidth, $optimalHeight, $newWidth, $newHeight, $cropPos);

            }

        }

        // *** If Rotate.

        if ($autoRotate) {

            try {

                $exifData = $this->getExif(false);

            } catch (Exception $e) {

            }

            if (count($exifData) > 0) {

                switch ($exifData['orientation']) {

                    case 8:

                        $this->imageResized = imagerotate($this->imageResized, 90, 0);

                        break;

                    case 3:

                        $this->imageResized = imagerotate($this->imageResized, 180, 0);

                        break;

                    case 6:

                        $this->imageResized = imagerotate($this->imageResized, -90, 0);

                        break;

                }

            }

        }

        // *** Sharpen image (if jpg and the user wishes to do so)

        if ($sharpen && in_array($this->fileExtension, $this->sharpenArray)) {

            // *** Sharpen

            try {

                $this->sharpen();

            } catch (Exception $e) {

            }

        }

    }

    ## --------------------------------------------------------

    public function cropImage($newWidth, $newHeight, $cropPos = 'm')

        # Author:     Jarrod Oberto

        # Date:       08-09-11

        # Purpose:    Crops the image

        # Param in:   $newWidth: crop with

        #             $newHeight: crop height

        #             $cropPos: Can be any of the following:

        #                   tl, t, tr, l, m, r, bl, b, br, auto

        #             Or:

        #                   a custom position such as '30x50'

        # Param out:  n/a

        # Reference:

        # Notes:

        #

    {

        // *** Make sure the file passed in is valid

        if (!$this->image) {

            if ($this->debug) {

                die('file ' . $this->getFileName() . ' is missing or invalid');

            } else {

                die();

            }

        }

        $this->imageResized = $this->image;

        $this->crop($this->width, $this->height, $newWidth, $newHeight, $cropPos);

    }

    ## --------------------------------------------------------

    private function keepTransparancy($width, $height, $im)

        # Author:     Jarrod Oberto

        # Date:       08-04-11

        # Purpose:    Keep transparency for png and gif image

        # Param in:

        # Param out:  n/a

        # Reference:

        # Notes:

        #

    {

        // *** If PNG, perform some transparency retention actions (gif untested)

        if (in_array($this->fileExtension, $this->transparentArray) && $this->keepTransparency) {

            imagealphablending($im, false);

            imagesavealpha($im, true);

            $transparent = imagecolorallocatealpha($im, 255, 255, 255, 127);

            imagefilledrectangle($im, 0, 0, $width, $height, $transparent);

        } else {

            $color = imagecolorallocate($im, $this->fillColorArray['r'], $this->fillColorArray['g'], $this->fillColorArray['b']);

            imagefilledrectangle($im, 0, 0, $width, $height, $color);

        }

    }

    ## --------------------------------------------------------

    private function crop($optimalWidth, $optimalHeight, $newWidth, $newHeight, $cropPos)

        # Author:     Jarrod Oberto

        # Date:       15-09-08

        # Purpose:    Crops the image

        # Param in:   $newWidth:

        #             $newHeight:

        # Param out:  n/a

        # Reference:

        # Notes:

        #

    {

        // *** Get cropping co-ordinates

        $cropArray  = $this->getCropPlacing($optimalWidth, $optimalHeight, $newWidth, $newHeight, $cropPos);

        $cropStartX = $cropArray['x'];

        $cropStartY = $cropArray['y'];

        // *** Crop this bad boy

        $crop = imagecreatetruecolor($newWidth, $newHeight);

        $this->keepTransparancy($optimalWidth, $optimalHeight, $crop);

        imagecopyresampled($crop, $this->imageResized, 0, 0, $cropStartX, $cropStartY, $newWidth, $newHeight, $newWidth, $newHeight);

        $this->imageResized = $crop;

        // *** Set new width and height to our variables

        $this->width  = $newWidth;

        $this->height = $newHeight;

    }

    ## --------------------------------------------------------

    private function getCropPlacing($optimalWidth, $optimalHeight, $newWidth, $newHeight, $pos = 'm')

        #

        # Author:   Jarrod Oberto

        # Date:   July 11

        # Purpose:  Set the cropping area.

        # Params in:

        # Params out: (array) the crop x and y co-ordinates.

        # Notes:    When specifying the exact pixel crop position (eg 10x15), be

        #       very careful as it's easy to crop out of the image leaving

        #       black borders.

        #

    {

        $pos = strtolower($pos);

        // *** If co-ords have been entered

        if (strstr($pos, 'x')) {

            $pos = str_replace(' ', '', $pos);

            $xyArray = explode('x', $pos);

            list($cropStartX, $cropStartY) = $xyArray;

        } else {

            switch ($pos) {

                case 'tl':

                    $cropStartX = 0;

                    $cropStartY = 0;

                    break;

                case 't':

                    $cropStartX = ($optimalWidth / 2) - ($newWidth / 2);

                    $cropStartY = 0;

                    break;

                case 'tr':

                    $cropStartX = $optimalWidth - $newWidth;

                    $cropStartY = 0;

                    break;

                case 'l':

                    $cropStartX = 0;

                    $cropStartY = ($optimalHeight / 2) - ($newHeight / 2);

                    break;

                case 'm':

                    $cropStartX = ($optimalWidth / 2) - ($newWidth / 2);

                    $cropStartY = ($optimalHeight / 2) - ($newHeight / 2);

                    break;

                case 'r':

                    $cropStartX = $optimalWidth - $newWidth;

                    $cropStartY = ($optimalHeight / 2) - ($newHeight / 2);

                    break;

                case 'bl':

                    $cropStartX = 0;

                    $cropStartY = $optimalHeight - $newHeight;

                    break;

                case 'b':

                    $cropStartX = ($optimalWidth / 2) - ($newWidth / 2);

                    $cropStartY = $optimalHeight - $newHeight;

                    break;

                case 'br':

                    $cropStartX = $optimalWidth - $newWidth;

                    $cropStartY = $optimalHeight - $newHeight;

                    break;

                case 'auto':

                    // *** If image is a portrait crop from top, not center. v1.5

                    if ($optimalHeight > $optimalWidth) {

                        $cropStartX = ($optimalWidth / 2) - ($newWidth / 2);

                        $cropStartY = ($this->cropFromTopPercent / 100) * $optimalHeight;

                    } else {

                        // *** Else crop from the center

                        $cropStartX = ($optimalWidth / 2) - ($newWidth / 2);

                        $cropStartY = ($optimalHeight / 2) - ($newHeight / 2);

                    }

                    break;

                default:

                    // *** Default to center

                    $cropStartX = ($optimalWidth / 2) - ($newWidth / 2);

                    $cropStartY = ($optimalHeight / 2) - ($newHeight / 2);

                    break;

            }

        }

        return ['x' => $cropStartX, 'y' => $cropStartY];

    }

    ## --------------------------------------------------------

    private function getDimensions($newWidth, $newHeight, $option)

        # Author:     Jarrod Oberto

        # Date:       17-11-09

        # Purpose:    Get new image dimensions based on user specificaions

        # Param in:   $newWidth:

        #             $newHeight:

        # Param out:  Array of new width and height values

        # Reference:

        # Notes:      If $option = 3 then this function is call recursivly

        #

        #       To clarify the $option input:

        #               0 = The exact height and width dimensions you set.

        #               1 = Whatever height is passed in will be the height that

        #                   is set. The width will be calculated and set automatically

        #                   to a the value that keeps the original aspect ratio.

        #               2 = The same but based on the width.

        #               3 = Depending whether the image is landscape or portrait, this

        #                   will automatically determine whether to resize via

        #                   dimension 1,2 or 0.

        #               4 = Resize the image as much as possible, then crop the

        #         remainder.

    {

        switch ((string)$option) {

            case '0':

            case 'exact':

                $optimalWidth  = $newWidth;

                $optimalHeight = $newHeight;

                break;

            case '1':

            case 'portrait':

                $dimensionsArray = $this->getSizeByFixedHeight($newWidth, $newHeight);

                $optimalWidth    = $dimensionsArray['optimalWidth'];

                $optimalHeight   = $dimensionsArray['optimalHeight'];

                break;

            case '2':

            case 'landscape':

                $dimensionsArray = $this->getSizeByFixedWidth($newWidth, $newHeight);

                $optimalWidth    = $dimensionsArray['optimalWidth'];

                $optimalHeight   = $dimensionsArray['optimalHeight'];

                break;

            case '3':

            case 'auto':

                $dimensionsArray = $this->getSizeByAuto($newWidth, $newHeight);

                $optimalWidth    = $dimensionsArray['optimalWidth'];

                $optimalHeight   = $dimensionsArray['optimalHeight'];

                break;

            case '4':

            case 'crop':

                $dimensionsArray = $this->getOptimalCrop($newWidth, $newHeight);

                $optimalWidth    = $dimensionsArray['optimalWidth'];

                $optimalHeight   = $dimensionsArray['optimalHeight'];

                break;

        }

        return ['optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight];

    }

    ## --------------------------------------------------------

    private function getSizeByFixedHeight($newWidth, $newHeight)

    {

        // *** If forcing is off...

        if (!$this->forceStretch) {

            // *** ...check if actual height is less than target height

            if ($this->height < $newHeight) {

                return ['optimalWidth' => $this->width, 'optimalHeight' => $this->height];

            }

        }

        $ratio = $this->width / $this->height;

        $newWidth = $newHeight * $ratio;

        //return $newWidth;

        return ['optimalWidth' => $newWidth, 'optimalHeight' => $newHeight];

    }

    ## --------------------------------------------------------

    private function getSizeByFixedWidth($newWidth, $newHeight)

    {

        // *** If forcing is off...

        if (!$this->forceStretch) {

            // *** ...check if actual width is less than target width

            if ($this->width < $newWidth) {

                return ['optimalWidth' => $this->width, 'optimalHeight' => $this->height];

            }

        }

        $ratio = $this->height / $this->width;

        $newHeight = $newWidth * $ratio;

        //return $newHeight;

        return ['optimalWidth' => $newWidth, 'optimalHeight' => $newHeight];

    }

    ## --------------------------------------------------------

    private function getSizeByAuto($newWidth, $newHeight)

        # Author:     Jarrod Oberto

        # Date:       19-08-08

        # Purpose:    Depending on the height, choose to resize by 0, 1, or 2

        # Param in:   The new height and new width

        # Notes:

        #

    {

        // *** If forcing is off...

        if (!$this->forceStretch) {

            // *** ...check if actual size is less than target size

            if ($this->width < $newWidth && $this->height < $newHeight) {

                return ['optimalWidth' => $this->width, 'optimalHeight' => $this->height];

            }

        }

        if ($this->height < $this->width) // *** Image to be resized is wider (landscape)

        {

            //$optimalWidth = $newWidth;

            //$optimalHeight= $this->getSizeByFixedWidth($newWidth);

            $dimensionsArray = $this->getSizeByFixedWidth($newWidth, $newHeight);

            $optimalWidth    = $dimensionsArray['optimalWidth'];

            $optimalHeight   = $dimensionsArray['optimalHeight'];

        } elseif ($this->height > $this->width) // *** Image to be resized is taller (portrait)

        {

            //$optimalWidth = $this->getSizeByFixedHeight($newHeight);

            //$optimalHeight= $newHeight;

            $dimensionsArray = $this->getSizeByFixedHeight($newWidth, $newHeight);

            $optimalWidth    = $dimensionsArray['optimalWidth'];

            $optimalHeight   = $dimensionsArray['optimalHeight'];

        } else // *** Image to be resizerd is a square

        {

            if ($newHeight < $newWidth) {

                //$optimalWidth = $newWidth;

                //$optimalHeight= $this->getSizeByFixedWidth($newWidth);

                $dimensionsArray = $this->getSizeByFixedWidth($newWidth, $newHeight);

                $optimalWidth    = $dimensionsArray['optimalWidth'];

                $optimalHeight   = $dimensionsArray['optimalHeight'];

            } elseif ($newHeight > $newWidth) {

                //$optimalWidth = $this->getSizeByFixedHeight($newHeight);

                //$optimalHeight= $newHeight;

                $dimensionsArray = $this->getSizeByFixedHeight($newWidth, $newHeight);

                $optimalWidth    = $dimensionsArray['optimalWidth'];

                $optimalHeight   = $dimensionsArray['optimalHeight'];

            } else {

                // *** Sqaure being resized to a square

                $optimalWidth  = $newWidth;

                $optimalHeight = $newHeight;

            }

        }

        return ['optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight];

    }

    ## --------------------------------------------------------

    private function getOptimalCrop($newWidth, $newHeight)

        # Author:     Jarrod Oberto

        # Date:       17-11-09

        # Purpose:    Get optimal crop dimensions

        # Param in:   width and height as requested by user (fig 3)

        # Param out:  Array of optimal width and height (fig 2)

        # Reference:

        # Notes:      The optimal width and height return are not the same as the

        #             same as the width and height passed in. For example:

        #

        #

        #   |-----------------|     |------------|       |-------|

        #   |                 | =>  |**|      |**|   =>  |       |

        #   |                 |     |**|      |**|       |       |

        #   |                 |     |------------|       |-------|

        #   |-----------------|

        #        original                optimal             crop

        #          size                   size               size

        #  Fig      1                      2                  3

        #

        #       300 x 250           150 x 125          150 x 100

        #

        #  The optimal size is the smallest size (that is closest to the crop size)

        #  while retaining proportion/ratio.

        #

        #  The crop size is the optimal size that has been cropped on one axis to

        #  make the image the exact size specified by the user.

        #

        #      * represent cropped area

        #

    {

        // *** If forcing is off...

        if (!$this->forceStretch) {

            // *** ...check if actual size is less than target size

            if ($this->width < $newWidth && $this->height < $newHeight) {

                return ['optimalWidth' => $this->width, 'optimalHeight' => $this->height];

            }

        }

        $heightRatio = $this->height / $newHeight;

        $widthRatio  = $this->width / $newWidth;

        if ($heightRatio < $widthRatio) {

            $optimalRatio = $heightRatio;

        } else {

            $optimalRatio = $widthRatio;

        }

        $optimalHeight = round($this->height / $optimalRatio);

        $optimalWidth  = round($this->width / $optimalRatio);

        return ['optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight];

    }

    ## --------------------------------------------------------

    private function sharpen()

        # Author:     Jarrod Oberto

        # Date:       08 04 2011

        # Purpose:    Sharpen image

        # Param in:   n/a

        # Param out:  n/a

        # Reference:

        # Notes:

        # Credit:   Incorporates Joe Lencioni (August 6, 2008) code

    {

        if (version_compare(PHP_VERSION, '5.1.0') >= 0) {

            // ***

            if ($this->aggresiveSharpening) { # A more aggressive sharpening solution

                $sharpenMatrix = [

                    [-1, -1, -1],

                    [-1, 16, -1],

                    [-1, -1, -1]

                ];

                $divisor       = 8;

                $offset        = 0;

                imageconvolution($this->imageResized, $sharpenMatrix, $divisor, $offset);

            } else # More subtle and personally more desirable

            {

                $sharpness = $this->findSharp($this->widthOriginal, $this->width);

                $sharpenMatrix = [

                    [-1, -2, -1],

                    [-2, $sharpness + 12, -2], //Lessen the effect of a filter by increasing the value in the center cell

                    [-1, -2, -1]

                ];

                $divisor       = $sharpness; // adjusts brightness

                $offset        = 0;

                imageconvolution($this->imageResized, $sharpenMatrix, $divisor, $offset);

            }

        } else {

            if ($this->debug) {

                die('Sharpening required PHP 5.1.0 or greater.');

            }

        }

    }

    ## --------------------------------------------------------

    private function sharpen2($level)

    {

        $sharpenMatrix = [

            [$level, $level, $level],

            [$level, (8 * $level) + 1, $level], //Lessen the effect of a filter by increasing the value in the center cell

            [$level, $level, $level]

        ];

    }

    ## --------------------------------------------------------

    private function findSharp($orig, $final)

        # Author:     Ryan Rud (http://adryrun.com)

        # Purpose:    Find optimal sharpness

        # Param in:   n/a

        # Param out:  n/a

        # Reference:

        # Notes:

        #

    {

        $final = $final * (750.0 / $orig);

        $a     = 52;

        $b     = -0.27810650887573124;

        $c     = .00047337278106508946;

        $result = $a + $b * $final + $c * $final * $final;

        return max(round($result), 0);

    }

    ## --------------------------------------------------------

    private function prepOption($option)

        # Author:     Jarrod Oberto

        # Purpose:    Prep option like change the passed in option to lowercase

        # Param in:   (str/int) $option: eg. 'exact', 'crop'. 0, 4

        # Param out:  lowercase string

        # Reference:

        # Notes:

        #

    {

        if (is_array($option)) {

            if ('crop' === strtolower($option[0]) && 2 == count($option)) {

                return 'crop';

            } else {

                die('Crop resize option array is badly formatted.');

            }

        } elseif (false !== strpos($option, 'crop')) {

            return 'crop';

        }

        if (is_string($option)) {

            return strtolower($option);

        }

        return $option;

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Presets

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    #

    # Preset are pre-defined templates you can apply to your image.

    #

    # These are inteded to be applied to thumbnail images.

    #

    public function borderPreset($preset)

    {

        switch ($preset) {

            case 'simple':

                $this->addBorder(7, '#fff');

                $this->addBorder(6, '#f2f1f0');

                $this->addBorder(2, '#fff');

                $this->addBorder(1, '#ccc');

                break;

            default:

                break;

        }

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Draw border

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function addBorder($thickness = 1, $rgbArray = [255, 255, 255])

        # Author:     Jarrod Oberto

        # Date:       05-05-11

        # Purpose:    Add a border to the image

        # Param in:

        # Param out:

        # Reference:

        # Notes:    This border is added to the INSIDE of the image

        #

    {

        if ($this->imageResized) {

            $rgbArray = $this->formatColor($rgbArray);

            $r        = $rgbArray['r'];

            $g        = $rgbArray['g'];

            $b        = $rgbArray['b'];

            $x1 = 0;

            $y1 = 0;

            $x2 = imagesx($this->imageResized) - 1;

            $y2 = imagesy($this->imageResized) - 1;

            $rgbArray = imagecolorallocate($this->imageResized, $r, $g, $b);

            for ($i = 0; $i < $thickness; ++$i) {

                imagerectangle($this->imageResized, ++$x1, ++$y1, $x2--, $y2--, $rgbArray);

            }

        }

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Gray Scale

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function greyScale()

        # Author:     Jarrod Oberto

        # Date:       07-05-2011

        # Purpose:    Make image greyscale

        # Param in:   n/a

        # Param out:

        # Reference:

        # Notes:

        #

    {

        if ($this->imageResized) {

            imagefilter($this->imageResized, IMG_FILTER_GRAYSCALE);

        }

    }

    ## --------------------------------------------------------

    public function greyScaleEnhanced()

        # Author:     Jarrod Oberto

        # Date:       07-05-2011

        # Purpose:    Make image greyscale

        # Param in:   n/a

        # Param out:

        # Reference:

        # Notes:

        #

    {

        if ($this->imageResized) {

            imagefilter($this->imageResized, IMG_FILTER_GRAYSCALE);

            imagefilter($this->imageResized, IMG_FILTER_CONTRAST, -15);

            imagefilter($this->imageResized, IMG_FILTER_BRIGHTNESS, 2);

            try {

                $this->sharpen($this->width);

            } catch (Exception $e) {

            }

        }

    }

    ## --------------------------------------------------------

    public function greyScaleDramatic()

        # Alias of gd_filter_monopin

    {

        $this->gd_filter_monopin();

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Black 'n White

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function blackAndWhite()

        # Author:     Jarrod Oberto

        # Date:       07-05-2011

        # Purpose:    Make image black and white

        # Param in:   n/a

        # Param out:

        # Reference:

        # Notes:

        #

    {

        if ($this->imageResized) {

            imagefilter($this->imageResized, IMG_FILTER_GRAYSCALE);

            imagefilter($this->imageResized, IMG_FILTER_CONTRAST, -1000);

        }

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Negative

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function negative()

        # Author:     Jarrod Oberto

        # Date:       07-05-2011

        # Purpose:    Make image negative

        # Param in:   n/a

        # Param out:

        # Reference:

        # Notes:

        #

    {

        if ($this->imageResized) {

            imagefilter($this->imageResized, IMG_FILTER_NEGATE);

        }

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Sepia

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function sepia()

        # Author:     Jarrod Oberto

        # Date:       07-05-2011

        # Purpose:    Make image sepia

        # Param in:   n/a

        # Param out:

        # Reference:

        # Notes:

        #

    {

        if ($this->imageResized) {

            imagefilter($this->imageResized, IMG_FILTER_GRAYSCALE);

            imagefilter($this->imageResized, IMG_FILTER_BRIGHTNESS, -10);

            imagefilter($this->imageResized, IMG_FILTER_CONTRAST, -20);

            imagefilter($this->imageResized, IMG_FILTER_COLORIZE, 60, 30, -15);

        }

    }

    ## --------------------------------------------------------

    public function sepia2()

    {

        if ($this->imageResized) {

            $total = imagecolorstotal($this->imageResized);

            for ($i = 0; $i < $total; ++$i) {

                $index = imagecolorsforindex($this->imageResized, $i);

                $red   = ($index['red'] * 0.393 + $index['green'] * 0.769 + $index['blue'] * 0.189) / 1.351;

                $green = ($index['red'] * 0.349 + $index['green'] * 0.686 + $index['blue'] * 0.168) / 1.203;

                $blue  = ($index['red'] * 0.272 + $index['green'] * 0.534 + $index['blue'] * 0.131) / 2.140;

                imagecolorset($this->imageResized, $i, $red, $green, $blue);

            }

        }

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Vintage

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function vintage()

        # Alias of gd_filter_monopin

    {

        $this->gd_filter_vintage();

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Presets By Marc Hibbins

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    /** Apply 'Monopin' preset */

    public function gd_filter_monopin()

    {

        if ($this->imageResized) {

            imagefilter($this->imageResized, IMG_FILTER_GRAYSCALE);

            imagefilter($this->imageResized, IMG_FILTER_BRIGHTNESS, -15);

            imagefilter($this->imageResized, IMG_FILTER_CONTRAST, -15);

            $this->imageResized = $this->gd_apply_overlay($this->imageResized, 'vignette', 100);

        }

    }

    ## --------------------------------------------------------

    public function gd_filter_vintage()

    {

        if ($this->imageResized) {

            $this->imageResized = $this->gd_apply_overlay($this->imageResized, 'vignette', 45);

            imagefilter($this->imageResized, IMG_FILTER_BRIGHTNESS, 20);

            imagefilter($this->imageResized, IMG_FILTER_CONTRAST, -35);

            imagefilter($this->imageResized, IMG_FILTER_COLORIZE, 60, -10, 35);

            imagefilter($this->imageResized, IMG_FILTER_SMOOTH, 7);

            $this->imageResized = $this->gd_apply_overlay($this->imageResized, 'scratch', 10);

        }

    }

    ## --------------------------------------------------------

    /** Apply a PNG overlay

     * @param $im

     * @param $type

     * @param $amount

     * @return mixed

     */

    private function gd_apply_overlay($im, $type, $amount)

        #

        # Original Author:    Marc Hibbins

        # License:  Attribution-ShareAlike 3.0

        # Purpose:

        # Params in:

        # Params out:

        # Notes:

        #

    {

        $width  = imagesx($im);

        $height = imagesy($im);

        $filter = imagecreatetruecolor($width, $height);

        imagealphablending($filter, false);

        imagesavealpha($filter, true);

        $transparent = imagecolorallocatealpha($filter, 255, 255, 255, 127);

        imagefilledrectangle($filter, 0, 0, $width, $height, $transparent);

        // *** Resize overlay

        $overlay = $this->filterOverlayPath . '/' . $type . '.png';

        $png     = imagecreatefrompng($overlay);

        imagecopyresampled($filter, $png, 0, 0, 0, 0, $width, $height, imagesx($png), imagesy($png));

        $comp = imagecreatetruecolor($width, $height);

        imagecopy($comp, $im, 0, 0, 0, 0, $width, $height);

        imagecopy($comp, $filter, 0, 0, 0, 0, $width, $height);

        imagecopymerge($im, $comp, 0, 0, 0, 0, $width, $height, $amount);

        imagedestroy($comp);

        return $im;

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Colorise

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function image_colorize($rgb)

    {

        imagetruecolortopalette($this->imageResized, true, 256);

        $numColors = imagecolorstotal($this->imageResized);

        for ($x = 0; $x < $numColors; ++$x) {

            list($r, $g, $b) = array_values(imagecolorsforindex($this->imageResized, $x));

            // calculate grayscale in percent

            $grayscale = ($r + $g + $b) / 3 / 0xff;

            imagecolorset(

                $this->imageResized,

                $x,

                $grayscale * $rgb[0],

                $grayscale * $rgb[1],

                $grayscale * $rgb[2]

            );

        }

        return true;

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Reflection

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function addReflection($reflectionHeight = 50, $startingTransparency = 30, $inside = false, $bgColor = '#fff', $stretch = false, $divider = 0)

    {

        // *** Convert color

        $rgbArray = $this->formatColor($bgColor);

        $r        = $rgbArray['r'];

        $g        = $rgbArray['g'];

        $b        = $rgbArray['b'];

        $im = $this->imageResized;

        $li = imagecreatetruecolor($this->width, 1);

        $bgc = imagecolorallocate($li, $r, $g, $b);

        imagefilledrectangle($li, 0, 0, $this->width, 1, $bgc);

        $bg = imagecreatetruecolor($this->width, $reflectionHeight);

        $wh = imagecolorallocate($im, 255, 255, 255);

        $im = imagerotate($im, -180, $wh);

        imagecopyresampled($bg, $im, 0, 0, 0, 0, $this->width, $this->height, $this->width, $this->height);

        $im = $bg;

        $bg = imagecreatetruecolor($this->width, $reflectionHeight);

        for ($x = 0; $x < $this->width; ++$x) {

            imagecopy($bg, $im, $x, 0, $this->width - $x - 1, 0, 1, $reflectionHeight);

        }

        $im = $bg;

        $transaprencyAmount = $this->invertTransparency($startingTransparency, 100);

        // *** Fade

        if ($stretch) {

            $step = 100 / ($reflectionHeight + $startingTransparency);

        } else {

            $step = 100 / $reflectionHeight;

        }

        for ($i = 0; $i <= $reflectionHeight; ++$i) {

            if ($startingTransparency > 100) {

                $startingTransparency = 100;

            }

            if ($startingTransparency < 1) {

                $startingTransparency = 1;

            }

            imagecopymerge($bg, $li, 0, $i, 0, 0, $this->width, 1, $startingTransparency);

            $startingTransparency += $step;

        }

        // *** Apply fade

        imagecopymerge($im, $li, 0, 0, 0, 0, $this->width, $divider, 100); // Divider

        // *** width, height of reflection.

        $x = imagesx($im);

        $y = imagesy($im);

        // *** Determines if the reflection should be displayed inside or outside the image

        if ($inside) {

            // Create new blank image with sizes.

            $final = imagecreatetruecolor($this->width, $this->height);

            imagecopymerge($final, $this->imageResized, 0, 0, 0, $reflectionHeight, $this->width, $this->height - $reflectionHeight, 100);

            imagecopymerge($final, $im, 0, $this->height - $reflectionHeight, 0, 0, $x, $y, 100);

        } else {

            // Create new blank image with sizes.

            $final = imagecreatetruecolor($this->width, $this->height + $y);

            imagecopymerge($final, $this->imageResized, 0, 0, 0, 0, $this->width, $this->height, 100);

            imagecopymerge($final, $im, 0, $this->height, 0, 0, $x, $y, 100);

        }

        $this->imageResized = $final;

        imagedestroy($li);

        imagedestroy($im);

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Rotate

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function rotate($value = 90, $bgColor = 'transparent')

        # Author:     Jarrod Oberto

        # Date:       07-05-2011

        # Purpose:    Rotate image

        # Param in:   (mixed) $degrees: (int) number of degress to rotate image

        #             (str) param "left": rotate left

        #             (str) param "right": rotate right

        #             (str) param "upside": upside-down image

        # Param out:

        # Reference:

        # Notes:    The default direction of imageRotate() is counter clockwise.

        #

    {

        if ($this->imageResized) {

            if (is_int($value)) {

                $degrees = $value;

            }

            // *** Convert color

            $rgbArray = $this->formatColor($bgColor);

            $r        = $rgbArray['r'];

            $g        = $rgbArray['g'];

            $b        = $rgbArray['b'];

            if (isset($rgbArray['a'])) {

                $a = $rgbArray['a'];

            }

            if (is_string($value)) {

                $value = strtolower($value);

                switch ($value) {

                    case 'left':

                        $degrees = 90;

                        break;

                    case 'right':

                        $degrees = 270;

                        break;

                    case 'upside':

                        $degrees = 180;

                        break;

                    default:

                        break;

                }

            }

            // *** The default direction of imageRotate() is counter clockwise

            //   * This makes it clockwise

            $degrees = 360 - $degrees;

            // *** Create background color

            $bg = imagecolorallocatealpha($this->imageResized, $r, $g, $b, $a);

            // *** Fill with background

            imagefill($this->imageResized, 0, 0, $bg);

            // *** Rotate

            $this->imageResized = imagerotate($this->imageResized, $degrees, $bg); // Rotate 45 degrees and allocated the transparent colour as the one to make transparent (obviously)

            // Ensure alpha transparency

            ImageSaveAlpha($this->imageResized, true);

        }

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Round corners

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function roundCorners($radius = 5, $bgColor = 'transparent')

        # Author:     Jarrod Oberto

        # Date:       19-05-2011

        # Purpose:    Create rounded corners on your image

        # Param in:   (int) radius = the amount of curvature

        #             (mixed) $bgColor = the corner background color

        # Param out:  n/a

        # Reference:

        # Notes:

        #

    {

        // *** Check if the user wants transparency

        $isTransparent = false;

        if (!is_array($bgColor)) {

            if ('transparent' === strtolower($bgColor)) {

                $isTransparent = true;

            }

        }

        // *** If we use transparency, we need to color our curved mask with a unique color

        if ($isTransparent) {

            $bgColor = $this->findUnusedGreen();

        }

        // *** Convert color

        $rgbArray = $this->formatColor($bgColor);

        $r        = $rgbArray['r'];

        $g        = $rgbArray['g'];

        $b        = $rgbArray['b'];

        if (isset($rgbArray['a'])) {

            $a = $rgbArray['a'];

        }

        // *** Create top-left corner mask (square)

        $cornerImg = imagecreatetruecolor($radius, $radius);

        //$cornerImg = imagecreate($radius, $radius);

        //imagealphablending($cornerImg, true);

        //imagesavealpha($cornerImg, true);

        //imagealphablending($this->imageResized, false);

        //imagesavealpha($this->imageResized, true);

        // *** Give it a color

        $maskColor = imagecolorallocate($cornerImg, 0, 0, 0);

        // *** Replace the mask color (black) to transparent

        imagecolortransparent($cornerImg, $maskColor);

        // *** Create the image background color

        $imagebgColor = imagecolorallocate($cornerImg, $r, $g, $b);

        // *** Fill the corner area to the user defined color

        imagefill($cornerImg, 0, 0, $imagebgColor);

        imagefilledellipse($cornerImg, $radius, $radius, $radius * 2, $radius * 2, $maskColor);

        // *** Map to top left corner

        imagecopymerge($this->imageResized, $cornerImg, 0, 0, 0, 0, $radius, $radius, 100); #tl

        // *** Map rounded corner to other corners by rotating and applying the mask

        $cornerImg = imagerotate($cornerImg, 90, 0);

        imagecopymerge($this->imageResized, $cornerImg, 0, $this->height - $radius, 0, 0, $radius, $radius, 100); #bl

        $cornerImg = imagerotate($cornerImg, 90, 0);

        imagecopymerge($this->imageResized, $cornerImg, $this->width - $radius, $this->height - $radius, 0, 0, $radius, $radius, 100); #br

        $cornerImg = imagerotate($cornerImg, 90, 0);

        imagecopymerge($this->imageResized, $cornerImg, $this->width - $radius, 0, 0, 0, $radius, $radius, 100); #tr

        // *** If corners are to be transparent, we fill our chromakey color as transparent.

        if ($isTransparent) {

            //imagecolortransparent($this->imageResized, $imagebgColor);

            $this->imageResized = $this->transparentImage($this->imageResized);

            imagesavealpha($this->imageResized, true);

        }

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Shadow

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function addShadow($shadowAngle = 45, $blur = 15, $bgColor = 'transparent')

        #

        # Author:   Jarrod Oberto (Adapted from Pascal Naidon)

        # Ref:    http://www.les-stooges.org/pascal/webdesign/vignettes/index.php?la=en

        # Purpose:  Add a drop shadow to your image

        # Params in:  (int) $angle: the angle of the shadow

        #       (int) $blur: the blur distance

        #       (mixed) $bgColor: the color of the background

        # Params out:

        # Notes:

        #

    {

        // *** A higher number results in a smoother shadow

        define('STEPS', $blur * 2);

        // *** Set the shadow distance

        $shadowDistance = $blur * 0.25;

        // *** Set blur width and height

        $blurWidth = $blurHeight = $blur;

        if (0 == $shadowAngle) {

            $distWidth  = 0;

            $distHeight = 0;

        } else {

            $distWidth  = $shadowDistance * cos(deg2rad($shadowAngle));

            $distHeight = $shadowDistance * sin(deg2rad($shadowAngle));

        }

        // *** Convert color

        if ('transparent' !== strtolower($bgColor)) {

            $rgbArray = $this->formatColor($bgColor);

            $r0       = $rgbArray['r'];

            $g0       = $rgbArray['g'];

            $b0       = $rgbArray['b'];

        }

        $image  = $this->imageResized;

        $width  = $this->width;

        $height = $this->height;

        $newImage = imagecreatetruecolor($width, $height);

        imagecopyresampled($newImage, $image, 0, 0, 0, 0, $width, $height, $width, $height);

        // *** RGB

        $rgb    = imagecreatetruecolor($width + $blurWidth, $height + $blurHeight);

        $colour = imagecolorallocate($rgb, 0, 0, 0);

        imagefilledrectangle($rgb, 0, 0, $width + $blurWidth, $height + $blurHeight, $colour);

        $colour = imagecolorallocate($rgb, 255, 255, 255);

        //imagefilledrectangle($rgb, $blurWidth*0.5-$distWidth, $blurHeight*0.5-$distHeight, $width+$blurWidth*0.5-$distWidth, $height+$blurWidth*0.5-$distHeight, $colour);

        imagefilledrectangle($rgb, $blurWidth * 0.5 - $distWidth, $blurHeight * 0.5 - $distHeight, $width + $blurWidth * 0.5 - $distWidth, $height + $blurWidth * 0.5 - $distHeight, $colour);

        //imagecopymerge($rgb, $newImage, 1+$blurWidth*0.5-$distWidth, 1+$blurHeight*0.5-$distHeight, 0,0, $width, $height, 100);

        imagecopymerge($rgb, $newImage, $blurWidth * 0.5 - $distWidth, $blurHeight * 0.5 - $distHeight, 0, 0, $width + $blurWidth, $height + $blurHeight, 100);

        // *** Shadow (alpha)

        $shadow = imagecreatetruecolor($width + $blurWidth, $height + $blurHeight);

        imagealphablending($shadow, false);

        $colour = imagecolorallocate($shadow, 0, 0, 0);

        imagefilledrectangle($shadow, 0, 0, $width + $blurWidth, $height + $blurHeight, $colour);

        for ($i = 0; $i <= STEPS; ++$i) {

            $t         = ((1.0 * $i) / STEPS);

            $intensity = 255 * $t * $t;

            $colour = imagecolorallocate($shadow, $intensity, $intensity, $intensity);

            $points = [

                $blurWidth * $t,

                $blurHeight,     // Point 1 (x, y)

                $blurWidth,

                $blurHeight * $t,  // Point 2 (x, y)

                $width,

                $blurHeight * $t,  // Point 3 (x, y)

                $width + $blurWidth * (1 - $t),

                $blurHeight,     // Point 4 (x, y)

                $width + $blurWidth * (1 - $t),

                $height,     // Point 5 (x, y)

                $width,

                $height + $blurHeight * (1 - $t),  // Point 6 (x, y)

                $blurWidth,

                $height + $blurHeight * (1 - $t),  // Point 7 (x, y)

                $blurWidth * $t,

                $height      // Point 8 (x, y)

            ];

            imagepolygon($shadow, $points, 8, $colour);

        }

        for ($i = 0; $i <= STEPS; ++$i) {

            $t         = ((1.0 * $i) / STEPS);

            $intensity = 255 * $t * $t;

            $colour = imagecolorallocate($shadow, $intensity, $intensity, $intensity);

            imagefilledarc($shadow, $blurWidth - 1, $blurHeight - 1, 2 * (1 - $t) * $blurWidth, 2 * (1 - $t) * $blurHeight, 180, 268, $colour, IMG_ARC_PIE);

            imagefilledarc($shadow, $width, $blurHeight - 1, 2 * (1 - $t) * $blurWidth, 2 * (1 - $t) * $blurHeight, 270, 358, $colour, IMG_ARC_PIE);

            imagefilledarc($shadow, $width, $height, 2 * (1 - $t) * $blurWidth, 2 * (1 - $t) * $blurHeight, 0, 90, $colour, IMG_ARC_PIE);

            imagefilledarc($shadow, $blurWidth - 1, $height, 2 * (1 - $t) * $blurWidth, 2 * (1 - $t) * $blurHeight, 90, 180, $colour, IMG_ARC_PIE);

        }

        $colour = imagecolorallocate($shadow, 255, 255, 255);

        imagefilledrectangle($shadow, $blurWidth, $blurHeight, $width, $height, $colour);

        imagefilledrectangle($shadow, $blurWidth * 0.5 - $distWidth, $blurHeight * 0.5 - $distHeight, $width + $blurWidth * 0.5 - 1 - $distWidth, $height + $blurHeight * 0.5 - 1 - $distHeight, $colour);

        // *** The magic

        imagealphablending($rgb, false);

        for ($theX = 0; $theX < imagesx($rgb); $theX++) {

            for ($theY = 0; $theY < imagesy($rgb); $theY++) {

                // *** Get the RGB values for every pixel of the RGB image

                $colArray = imagecolorat($rgb, $theX, $theY);

                $r        = ($colArray >> 16) & 0xFF;

                $g        = ($colArray >> 8) & 0xFF;

                $b        = $colArray & 0xFF;

                // *** Get the alpha value for every pixel of the shadow image

                $colArray = imagecolorat($shadow, $theX, $theY);

                $a        = $colArray & 0xFF;

                $a        = 127 - floor($a / 2);

                $t        = $a / 128.0;

                // *** Create color

                if ('transparent' === strtolower($bgColor)) {

                    $myColour = imagecolorallocatealpha($rgb, $r, $g, $b, $a);

                } else {

                    $myColour = imagecolorallocate($rgb, $r * (1.0 - $t) + $r0 * $t, $g * (1.0 - $t) + $g0 * $t, $b * (1.0 - $t) + $b0 * $t);

                }

                // *** Add color to new rgb image

                imagesetpixel($rgb, $theX, $theY, $myColour);

            }

        }

        imagealphablending($rgb, true);

        imagesavealpha($rgb, true);

        $this->imageResized = $rgb;

        imagedestroy($image);

        imagedestroy($newImage);

        imagedestroy($shadow);

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Add Caption Box

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function addCaptionBox($side = 'b', $thickness = 50, $padding = 0, $bgColor = '#000', $transaprencyAmount = 30)

        #

        # Author:   Jarrod Oberto

        # Date:   26 May 2011

        # Purpose:  Add a caption box

        # Params in:  (str) $side: the side to add the caption box (t, r, b, or l).

        #       (int) $thickness: how thick you want the caption box to be.

        #       (mixed) $bgColor: The color of the caption box.

        #       (int) $transaprencyAmount: The amount of transparency to be

        #       applied.

        # Params out: n/a

        # Notes:

        #

    {

        $side = strtolower($side);

        // *** Convert color

        $rgbArray = $this->formatColor($bgColor);

        $r        = $rgbArray['r'];

        $g        = $rgbArray['g'];

        $b        = $rgbArray['b'];

        $positionArray = $this->calculateCaptionBoxPosition($side, $thickness, $padding);

        // *** Store incase we want to use method addTextToCaptionBox()

        $this->captionBoxPositionArray = $positionArray;

        $transaprencyAmount = $this->invertTransparency($transaprencyAmount, 127, false);

        $transparent        = imagecolorallocatealpha($this->imageResized, $r, $g, $b, $transaprencyAmount);

        imagefilledrectangle($this->imageResized, $positionArray['x1'], $positionArray['y1'], $positionArray['x2'], $positionArray['y2'], $transparent);

    }

    ## --------------------------------------------------------

    public function addTextToCaptionBox($text, $fontColor = '#fff', $fontSize = 12, $angle = 0, $font = null)

        #

        # Author:   Jarrod Oberto

        # Date:   03 Aug 11

        # Purpose:  Simplify adding text to a caption box by automatically

        #       locating the center of the caption box

        # Params in:  The usually text paams (less a couple)

        # Params out: n/a

        # Notes:

        #

    {

        // *** Get the caption box measurements

        if (4 == count($this->captionBoxPositionArray)) {

            $x1 = $this->captionBoxPositionArray['x1'];

            $x2 = $this->captionBoxPositionArray['x2'];

            $y1 = $this->captionBoxPositionArray['y1'];

            $y2 = $this->captionBoxPositionArray['y2'];

        } else {

            if ($this->debug) {

                die('No caption box found.');

            } else {

                return false;

            }

        }

        // *** Get text font

        try {

            $font = $this->getTextFont($font);

        } catch (Exception $e) {

        }

        // *** Get text size

        $textSizeArray = $this->getTextSize($fontSize, $angle, $font, $text);

        $textWidth     = $textSizeArray['width'];

        $textHeight    = $textSizeArray['height'];

        // *** Find the width/height middle points

        $boxXMiddle = (($x2 - $x1) / 2);

        $boxYMiddle = (($y2 - $y1) / 2);

        // *** Box middle - half the text width/height

        $xPos = ($x1 + $boxXMiddle) - ($textWidth / 2);

        $yPos = ($y1 + $boxYMiddle) - ($textHeight / 2);

        $pos = $xPos . 'x' . $yPos;

        $this->addText($text, $pos, $padding = 0, $fontColor, $fontSize, $angle, $font);

    }

    ## --------------------------------------------------------

    private function calculateCaptionBoxPosition($side, $thickness, $padding)

    {

        $positionArray = [];

        switch ($side) {

            case 't':

                $positionArray['x1'] = 0;

                $positionArray['y1'] = $padding;

                $positionArray['x2'] = $this->width;

                $positionArray['y2'] = $thickness + $padding;

                break;

            case 'r':

                $positionArray['x1'] = $this->width - $thickness - $padding;

                $positionArray['y1'] = 0;

                $positionArray['x2'] = $this->width - $padding;

                $positionArray['y2'] = $this->height;

                break;

            case 'b':

                $positionArray['x1'] = 0;

                $positionArray['y1'] = $this->height - $thickness - $padding;

                $positionArray['x2'] = $this->width;

                $positionArray['y2'] = $this->height - $padding;

                break;

            case 'l':

                $positionArray['x1'] = $padding;

                $positionArray['y1'] = 0;

                $positionArray['x2'] = $thickness + $padding;

                $positionArray['y2'] = $this->height;

                break;

            default:

                break;

        }

        return $positionArray;

    }

    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*-

        Get EXIF Data

    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-*-*-*-*-*-*-*/

    public function getExif($debug = true)

        # Author:     Jarrod Oberto

        # Date:       07-05-2011

        # Purpose:    Get image EXIF data

        # Param in:   n/a

        # Param out:  An associate array of EXIF data

        # Reference:

        # Notes:

        # 23 May 13 : added orientation flag -jco

        #

    {

        if (!$this->debug || !$debug) {

            $debug = false;

        }

        // *** Check all is good - check the EXIF library exists and the file exists, too.

        if (!$this->testEXIFInstalled()) {

            if ($debug) {

                die('The EXIF Library is not installed.');

            } else {

                return [];

            }

        }

        if (!file_exists($this->fileName)) {

            if ($debug) {

                die('Image not found.');

            } else {

                return [];

            }

        }

        if ('.jpg' !== $this->fileExtension) {

            if ($debug) {

                die('Metadata not supported for this image type.');

            } else {

                return [];

            }

        }

        $exifData = exif_read_data($this->fileName, 'IFD0');

        // *** Format the apperture value

        $ev            = isset($exifData['ApertureValue']) ? $exifData['ApertureValue'] : '';

        $apPeicesArray = explode('/', $ev);

        if (2 == count($apPeicesArray)) {

            $apertureValue = round($apPeicesArray[0] / $apPeicesArray[1], 2, PHP_ROUND_HALF_DOWN) . ' EV';

        } else {

            $apertureValue = '';

        }

        // *** Format the focal length

        $focalLength   = isset($exifData['FocalLength']) ? $exifData['FocalLength'] : '';

        $flPeicesArray = explode('/', $focalLength);

        if (2 == count($flPeicesArray)) {

            $focalLength = $flPeicesArray[0] / $flPeicesArray[1] . '.0 mm';

        } else {

            $focalLength = '';

        }

        // *** Format fNumber

        $fNumber       = isset($exifData['FNumber']) ? $exifData['FNumber'] : '';

        $fnPeicesArray = explode('/', $fNumber);

        if (2 == count($fnPeicesArray)) {

            $fNumber = $fnPeicesArray[0] / $fnPeicesArray[1];

        } else {

            $fNumber = '';

        }