Пример #1
0
 /**
  * 
  * @param \Domain\Entity\Imagem $imagem
  * @param type $imagemBase64
  * @param type $redimensionar
  * @return type
  */
 private static function imagemCriarArquivoTemporario(&$imagem, $imagemBase64, $redimensionar)
 {
     $imagemDecodificada = base64_decode($imagemBase64);
     if (strpos($imagemDecodificada, 'WEBP') !== false) {
         $temp = tempnam(TMPDIR, 'imagemwebp');
         $fp = fopen($temp, 'w');
         fwrite($fp, $imagemDecodificada);
         fclose($fp);
         $imagemParaRedimensionar = imagecreatefromwebp($temp);
         unlink($temp);
     } else {
         $imagemParaRedimensionar = imagecreatefromstring($imagemDecodificada);
     }
     $imagemFinal = Formulario::imagemRedimensionar($imagemParaRedimensionar, $redimensionar);
     $arquivoTemporario = tempnam(TMPDIR, 'imagem');
     // formato WEBP que utiliza menor tamanho e preserva a qualidade
     if (function_exists('imagewebp')) {
         imagewebp($imagemFinal, $arquivoTemporario);
         $mimeType = 'image/webp';
     } else {
         // do contrário coloca em JPEG mantendo a qualidade (muito grande)
         imagejpeg($imagemFinal, $arquivoTemporario, 100);
         $mimeType = 'image/jpeg';
     }
     if (is_null($imagem)) {
         $imagem = new \Domain\Entity\Imagem();
         $imagem->setFilename(basename($arquivoTemporario));
     }
     $imagem->setMimeType($mimeType);
     imagedestroy($imagemFinal);
     return $arquivoTemporario;
 }
Пример #2
0
 public function input($input)
 {
     // if is not a string, not an existing file or not a file ressource
     if (!is_string($input) || !file_exists($input) || !is_file($input)) {
         throw new \InvalidArgumentException('Input file is not a valid ressource.');
     }
     $this->inputPath = $input;
     list($this->inputWidth, $this->inputHeight, $this->inputType) = getimagesize($input);
     switch ($this->inputType) {
         case IMAGETYPE_GIF:
             if (!function_exists('imagecreatefromgif')) {
                 throw new CapabilityException('GIF is not supported.');
             }
             $this->input = imagecreatefromgif($input);
             break;
         case IMAGETYPE_JPEG:
             if (!function_exists('imagecreatefromjpeg')) {
                 throw new CapabilityException('JPEG is not supported.');
             }
             $this->input = imagecreatefromjpeg($input);
             break;
         case IMAGETYPE_PNG:
             if (!function_exists('imagecreatefrompng')) {
                 throw new CapabilityException('PNG is not supported.');
             }
             $this->input = imagecreatefrompng($input);
             break;
         case IMAGETYPE_WBMP:
             if (!function_exists('imagecreatefromwbmp')) {
                 throw new CapabilityException('WBMP is not supported.');
             }
             $this->input = imagecreatefromwbmp($input);
             break;
             // Not supported yet in PHP 5.5. WebP is supported since in PHP 5.5 (https://bugs.php.net/bug.php?id=65038)
         // Not supported yet in PHP 5.5. WebP is supported since in PHP 5.5 (https://bugs.php.net/bug.php?id=65038)
         case defined('IMAGETYPE_WEBP') && IMAGETYPE_WEBP:
             if (!function_exists('imagecreatefromwebp')) {
                 throw new CapabilityException('WebP is not supported.');
             }
             $this->input = imagecreatefromwebp($input);
             break;
         case IMAGETYPE_XBM:
             if (!function_exists('imagecreatefromxbm')) {
                 throw new CapabilityException('XBM is not supported.');
             }
             $this->input = imagecreatefromxbm($input);
             break;
         case defined('IMAGETYPE_WEBP') && IMAGETYPE_XPM:
             if (!function_exists('imagecreatefromxpm')) {
                 throw new CapabilityException('XPM is not supported.');
             }
             $this->input = imagecreatefromxpm($input);
             break;
         default:
             throw new CapabilityException('Unsupported input file type.');
             break;
     }
     $this->applyExifTransformations($this->input);
 }
Пример #3
0
 /**
  * Create image ressource from filename.
  *
  * @param string Path to the image.
  * @return void
  **/
 protected function create($filename)
 {
     $this->filename = $filename;
     // if is not a string, not an existing file or not a file ressource
     if (!is_string($this->filename) || !file_exists($this->filename) || !is_file($this->filename)) {
         throw new \InvalidArgumentException('Filename is not a valid ressource.');
     }
     switch (exif_imagetype($this->filename)) {
         case IMAGETYPE_GIF:
             if (!function_exists('imagecreatefromgif')) {
                 throw new CapabilityException('GIF is not supported.');
             }
             $this->image = imagecreatefromgif($this->filename);
             break;
         case IMAGETYPE_JPEG:
             if (!function_exists('imagecreatefromjpeg')) {
                 throw new CapabilityException('JPEG is not supported.');
             }
             $this->image = imagecreatefromjpeg($this->filename);
             break;
         case IMAGETYPE_PNG:
             if (!function_exists('imagecreatefrompng')) {
                 throw new CapabilityException('PNG is not supported.');
             }
             $this->image = imagecreatefrompng($this->filename);
             break;
         case IMAGETYPE_WBMP:
             if (!function_exists('imagecreatefromwbmp')) {
                 throw new CapabilityException('WBMP is not supported.');
             }
             $this->image = imagecreatefromwbmp($this->filename);
             break;
             // Not supported yet in PHP 5.5. WebP is supported since in PHP 5.5 (https://bugs.php.net/bug.php?id=65038)
         // Not supported yet in PHP 5.5. WebP is supported since in PHP 5.5 (https://bugs.php.net/bug.php?id=65038)
         case defined('IMAGETYPE_WEBP') && IMAGETYPE_WEBP:
             if (!function_exists('imagecreatefromwebp')) {
                 throw new CapabilityException('WebP is not supported.');
             }
             $this->image = imagecreatefromwebp($this->filename);
             break;
         case IMAGETYPE_XBM:
             if (!function_exists('imagecreatefromxbm')) {
                 throw new CapabilityException('XBM is not supported.');
             }
             $this->image = imagecreatefromxbm($this->filename);
             break;
         case defined('IMAGETYPE_WEBP') && IMAGETYPE_XPM:
             if (!function_exists('imagecreatefromxpm')) {
                 throw new CapabilityException('XPM is not supported.');
             }
             $this->image = imagecreatefromxpm($this->filename);
             break;
         default:
             throw new CapabilityException('Unsupported input file type.');
             break;
     }
     $this->setWidth(imagesx($this->image));
     $this->setHeight(imagesy($this->image));
 }
Пример #4
0
 /**
  * @param  string $format
  * @param  string $contents
  * @param  bool   $throw
  * @return resource
  * @throws InvalidImageException
  */
 public function getGdResourceFromContents($format, $contents, $throw = false)
 {
     if (PhpGdContext::FORMAT_WEBP === $format) {
         $resource = @imagecreatefromwebp('data://image/webp;base64,' . base64_encode($contents));
     } else {
         $resource = @imagecreatefromstring($contents);
     }
     if (!$resource && $throw) {
         throw new InvalidImageException('image.corrupted');
     }
     return $resource;
 }
Пример #5
0
 private function openImage($file, $type)
 {
     $extension = $type ? '.' . $type : strtolower(strrchr($file, '.'));
     switch ($extension) {
         case '.jpg':
         case '.jpeg':
             $img = @imagecreatefromjpeg($file);
             break;
         case '.gif':
             $img = @imagecreatefromgif($file);
             break;
         case '.png':
             $img = @imagecreatefrompng($file);
             break;
         case '.webp':
             $img = imagecreatefromwebp($file);
             break;
         default:
             $img = false;
             break;
     }
     return $img;
 }
Пример #6
0
 private function resize_with_gd($image_path, $save_as, $new_w, $new_h, $crop_w, $crop_h, $crop_x, $crop_y)
 {
     if ($this->is_webp($image_path)) {
         $mime = 'image/webp';
     } else {
         $info = getimagesize($image_path);
         if (!is_array($info)) {
             return false;
         }
         $image_w = $info[0];
         $image_h = $info[1];
         $mime = $info['mime'];
     }
     $crop = false;
     if ($crop_w != 0 && $crop_h != 0) {
         $crop = true;
     }
     if (function_exists('imagecreatetruecolor')) {
         $new_image = imagecreatetruecolor($new_w, $new_h);
         if ($crop) {
             $crop_image = imagecreatetruecolor($crop_w, $crop_h);
         }
     } else {
         $new_image = imagecreate($new_w, $new_h);
         if ($crop) {
             $crop_image = imagecreate($crop_w, $crop_h);
         }
     }
     $real_save_as = $save_as;
     $save_as = tempnam(PERCH_RESFILEPATH, '_gd_tmp_');
     switch ($mime) {
         case 'image/jpeg':
             $orig_image = imagecreatefromjpeg($image_path);
             if (function_exists('imagecopyresampled')) {
                 imagecopyresampled($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             } else {
                 imagecopyresized($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             }
             // sharpen
             if ($this->sharpening) {
                 $new_image = $this->sharpen_with_gd($new_image, $this->sharpening);
             }
             // progressive jpg?
             if ($this->progressive_jpeg) {
                 imageinterlace($new_image, 1);
             }
             if ($crop) {
                 imagecopy($crop_image, $new_image, 0, 0, $crop_x, $crop_y, $new_w, $new_h);
                 imagejpeg($crop_image, $save_as, $this->jpeg_quality);
             } else {
                 imagejpeg($new_image, $save_as, $this->jpeg_quality);
             }
             break;
         case 'image/gif':
             $orig_image = imagecreatefromgif($image_path);
             imagetruecolortopalette($new_image, true, 256);
             $new_image = $this->gd_set_transparency($new_image, $orig_image);
             if (function_exists('imagecopyresampled')) {
                 imagecopyresampled($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             } else {
                 imagecopyresized($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             }
             if ($crop) {
                 imagetruecolortopalette($crop_image, true, 256);
                 $crop_image = $this->gd_set_transparency($crop_image, $new_image);
                 imagecopy($crop_image, $new_image, 0, 0, $crop_x, $crop_y, $new_w, $new_h);
                 imagegif($crop_image, $save_as);
             } else {
                 imagegif($new_image, $save_as);
             }
             break;
         case 'image/png':
             $orig_image = imagecreatefrompng($image_path);
             imagealphablending($new_image, false);
             imagesavealpha($new_image, true);
             if (function_exists('imagecopyresampled')) {
                 imagecopyresampled($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             } else {
                 imagecopyresized($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             }
             // sharpen
             if ($this->sharpening) {
                 $colour = imagecolorat($new_image, 0, 0);
                 $new_image = $this->sharpen_with_gd($new_image, $this->sharpening);
                 imagesetpixel($new_image, 0, 0, $colour);
             }
             if ($crop) {
                 imagealphablending($crop_image, false);
                 imagesavealpha($crop_image, true);
                 imagecopy($crop_image, $new_image, 0, 0, $crop_x, $crop_y, $new_w, $new_h);
                 imagepng($crop_image, $save_as, $this->png_compression);
             } else {
                 imagepng($new_image, $save_as, $this->png_compression);
             }
             break;
         case 'image/webp':
             $orig_image = imagecreatefromwebp($image_path);
             $image_w = imagesx($orig_image);
             $image_h = imagesy($orig_image);
             imagealphablending($new_image, false);
             imagesavealpha($new_image, true);
             if (function_exists('imagecopyresampled')) {
                 imagecopyresampled($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             } else {
                 imagecopyresized($new_image, $orig_image, 0, 0, 0, 0, $new_w, $new_h, $image_w, $image_h);
             }
             // sharpen
             if ($this->sharpening) {
                 $colour = imagecolorat($new_image, 0, 0);
                 $new_image = $this->sharpen_with_gd($new_image, $this->sharpening);
                 imagesetpixel($new_image, 0, 0, $colour);
             }
             if ($crop) {
                 imagealphablending($crop_image, false);
                 imagesavealpha($crop_image, true);
                 imagecopy($crop_image, $new_image, 0, 0, $crop_x, $crop_y, $new_w, $new_h);
                 imagewebp($crop_image, $save_as);
             } else {
                 imagewebp($new_image, $save_as);
             }
             break;
         default:
             $orig_image = imagecreatefromjpeg($image_path);
             break;
     }
     imagedestroy($orig_image);
     imagedestroy($new_image);
     if ($crop) {
         imagedestroy($crop_image);
     }
     if (isset($orig_image)) {
         unset($orig_image);
     }
     if (isset($new_image)) {
         unset($new_image);
     }
     if (isset($crop_image)) {
         unset($crop_image);
     }
     copy($save_as, $real_save_as);
     unlink($save_as);
     return $mime;
 }
Пример #7
0
 public function generateFilePreview($file_id)
 {
     debug("generating preview");
     $file_id = intval($file_id);
     $file_info = $this->getFileInfoById($file_id);
     if ($file_info == null) {
         debug("cannot generate preview, file_id not found");
         return false;
     }
     //direct path
     $realpath = realpath(self::getFilesFolderName() . "/" . $file_info->fullpath);
     debug("realpath: " . $realpath);
     $info = pathinfo($realpath);
     //to extract extension
     $previewWidth = self::$PREVIEW_IMAGE_SIZE;
     $ext = strtolower($info['extension']);
     $img = null;
     switch ($ext) {
         case 'jpeg':
         case 'jpg':
             $img = imagecreatefromjpeg($realpath);
             break;
         case 'png':
             $img = imagecreatefrompng($realpath);
             break;
         case 'webp':
             $img = imagecreatefromwebp($realpath);
             break;
         default:
             debug("cannot preview, unknown extension: " . $ext);
             return false;
     }
     if (!$img) {
         debug("Image couldnt be loaded: " . $realpath);
         return false;
     }
     $width = imagesx($img);
     $height = imagesy($img);
     // calculate preview size
     $new_width = $previewWidth;
     $new_height = floor($height * ($previewWidth / $width));
     // create a new temporary image
     $tmp_img = imagecreatetruecolor($new_width, $new_height);
     // copy and resize old image into new image
     imagecopyresized($tmp_img, $img, 0, 0, 0, 0, $new_width, $new_height, $width, $height);
     $picpath = $file_info->unit_name . "/" . $file_info->folder;
     $tn_filename = PREVIEW_PREFIX . $file_info->filename . PREVIEW_SUFIX;
     $tn_path = $this->getFilesFolderName() . "/" . $picpath . "/" . $tn_filename;
     // save preview into a file
     $result = null;
     if (PREVIEW_SUFIX == ".png") {
         $result = imagepng($tmp_img, $tn_path);
     } else {
         if (PREVIEW_SUFIX == ".jpg") {
             $result = imagejpeg($tmp_img, $tn_path);
         } else {
             if (PREVIEW_SUFIX == ".webp") {
                 $result = imagewebp($tmp_img, $tn_path);
             } else {
                 debug("unsupported preview extension");
                 return false;
             }
         }
     }
     if (!$result) {
         debug("Error saving generated preview: " . $tn_path);
         return false;
     }
     debug("preview generated: " . $tn_path);
     return true;
 }
function imageComparison($firstImage, $secondImage)
{
    $firstImageInfo = pathinfo($firstImage);
    //first image info
    switch ($firstImageInfo['extension']) {
        //switch image extension
        case "jpg":
            $image = imagecreatefromjpeg($firstImage);
            break;
        case "jpeg":
            $image1 = imagecreatefromjpeg($secondImage);
            break;
        case "png":
            $image = imagecreatefrompng($firstImage);
            break;
        case "wbmp":
            $image = imagecreatefromwbmp($firstImage);
            break;
        case "webp":
            $image = imagecreatefromwebp($firstImage);
            break;
        case "xbm":
            $image = imagecreatefromxbm($firstImage);
            break;
        case "xpm":
            $image = imagecreatefromxpm($firstImage);
            break;
    }
    if (!isset($image)) {
        //error: not find extension
        return false;
    }
    $width = imagesx($image);
    //image width
    $height = imagesy($image);
    //image height
    $color = array();
    //array color pixel
    for ($a = 1; $a <= $width; $a++) {
        for ($b = 1; $b <= $height; $b++) {
            $color[] = imagecolorat($image, $a, $b);
        }
    }
    $firstComparison = $color;
    //first image
    $secondImageInfo = pathinfo($secondImage);
    switch ($secondImageInfo['extension']) {
        case "jpg":
            $image1 = imagecreatefromjpeg($secondImage);
            break;
        case "jpeg":
            $image1 = imagecreatefromjpeg($secondImage);
            break;
        case "png":
            $image1 = imagecreatefrompng($secondImage);
            break;
        case "wbmp":
            $image1 = imagecreatefromwbmp($secondImage);
            break;
        case "webp":
            $image1 = imagecreatefromwebp($secondImage);
            break;
        case "xbm":
            $image1 = imagecreatefromxbm($secondImage);
            break;
        case "xpm":
            $image1 = imagecreatefromxpm($secondImage);
            break;
    }
    if (!isset($image1)) {
        return false;
    }
    $width = imagesx($image1);
    $height = imagesy($image1);
    $color1 = array();
    for ($a = 1; $a <= $width; $a++) {
        for ($b = 1; $b <= $height; $b++) {
            $color1[] = imagecolorat($image1, $a, $b);
        }
    }
    $secondComparison = $color1;
    //second image
    $comparison = count($firstComparison);
    for ($x = 0; $x <= $comparison; $x++) {
        if ($firstComparison[$x] !== $secondComparison[$x]) {
            return false;
        }
    }
}
Пример #9
0
 /**
  * Actually uploads the file, and act on it according to the set processing class variables
  *
  * This function copies the uploaded file to the given location, eventually performing actions on it.
  * Typically, you can call {@link process} several times for the same file,
  * for instance to create a resized image and a thumbnail of the same file.
  * The original uploaded file remains intact in its temporary location, so you can use {@link process} several times.
  * You will be able to delete the uploaded file with {@link clean} when you have finished all your {@link process} calls.
  *
  * According to the processing class variables set in the calling file, the file can be renamed,
  * and if it is an image, can be resized or converted.
  *
  * When the processing is completed, and the file copied to its new location, the
  * processing class variables will be reset to their default value.
  * This allows you to set new properties, and perform another {@link process} on the same uploaded file
  *
  * If the function is called with a null or empty argument, then it will return the content of the picture
  *
  * It will set {@link processed} (and {@link error} is an error occurred)
  *
  * @access public
  * @param  string $server_path Optional path location of the uploaded file, with an ending slash
  * @return string Optional content of the image
  */
 function process($server_path = null)
 {
     $this->error = '';
     $this->processed = true;
     $return_mode = false;
     $return_content = null;
     // clean up dst variables
     $this->file_dst_path = '';
     $this->file_dst_pathname = '';
     $this->file_dst_name = '';
     $this->file_dst_name_body = '';
     $this->file_dst_name_ext = '';
     // clean up some parameters
     $this->file_max_size = $this->getsize($this->file_max_size);
     $this->jpeg_size = $this->getsize($this->jpeg_size);
     // some parameters are being deprecated, and replaced with others
     if (is_null($this->image_overlay_opacity)) {
         $this->image_overlay_opacity = $this->image_overlay_percent;
     }
     if ($this->image_text_opacity == 100) {
         $this->image_text_opacity = $this->image_text_percent;
     }
     if ($this->image_text_background_opacity == 100) {
         $this->image_text_background_opacity = $this->image_text_background_percent;
     }
     // copy some variables as we need to keep them clean
     $file_src_name = $this->file_src_name;
     $file_src_name_body = $this->file_src_name_body;
     $file_src_name_ext = $this->file_src_name_ext;
     if (!$this->uploaded) {
         $this->error = $this->translate('file_not_uploaded');
         $this->processed = false;
     }
     if ($this->processed) {
         if (empty($server_path) || is_null($server_path)) {
             $this->log .= '<b>process file and return the content</b><br />';
             $return_mode = true;
         } else {
             if (strtolower(substr(PHP_OS, 0, 3)) === 'win') {
                 if (substr($server_path, -1, 1) != '\\') {
                     $server_path = $server_path . '\\';
                 }
             } else {
                 if (substr($server_path, -1, 1) != '/') {
                     $server_path = $server_path . '/';
                 }
             }
             $this->log .= '<b>process file to ' . $server_path . '</b><br />';
         }
     }
     if ($this->processed) {
         // checks file max size
         if ($this->file_src_size > $this->file_max_size) {
             $this->processed = false;
             $this->error = $this->translate('file_too_big');
         } else {
             $this->log .= '- file size OK<br />';
         }
     }
     if ($this->processed) {
         // if we have an image without extension, set it
         if ($this->file_force_extension && $this->file_is_image && !$this->file_src_name_ext) {
             $file_src_name_ext = $this->image_src_type;
         }
         // turn dangerous scripts into text files
         if ($this->no_script) {
             // if the file has no extension, we try to guess it from the MIME type
             if ($this->file_force_extension && empty($file_src_name_ext)) {
                 if ($key = array_search($this->file_src_mime, $this->mime_types)) {
                     $file_src_name_ext = $key;
                     $file_src_name = $file_src_name_body . '.' . $file_src_name_ext;
                     $this->log .= '- file renamed as ' . $file_src_name_body . '.' . $file_src_name_ext . '!<br />';
                 }
             }
             // if the file is text based, or has a dangerous extension, we rename it as .txt
             if ((substr($this->file_src_mime, 0, 5) == 'text/' && $this->file_src_mime != 'text/rtf' || strpos($this->file_src_mime, 'javascript') !== false) && substr($file_src_name, -4) != '.txt' || preg_match('/\\.(php|php5|php4|php3|phtml|pl|py|cgi|asp|js)$/i', $this->file_src_name) || $this->file_force_extension && empty($file_src_name_ext)) {
                 $this->file_src_mime = 'text/plain';
                 if ($this->file_src_name_ext) {
                     $file_src_name_body = $file_src_name_body . '.' . $this->file_src_name_ext;
                 }
                 $file_src_name_ext = 'txt';
                 $file_src_name = $file_src_name_body . '.' . $file_src_name_ext;
                 $this->log .= '- script renamed as ' . $file_src_name_body . '.' . $file_src_name_ext . '!<br />';
             }
         }
         if ($this->mime_check && empty($this->file_src_mime)) {
             $this->processed = false;
             $this->error = $this->translate('no_mime');
         } else {
             if ($this->mime_check && !empty($this->file_src_mime) && strpos($this->file_src_mime, '/') !== false) {
                 list($m1, $m2) = explode('/', $this->file_src_mime);
                 $allowed = false;
                 // check wether the mime type is allowed
                 if (!is_array($this->allowed)) {
                     $this->allowed = array($this->allowed);
                 }
                 foreach ($this->allowed as $k => $v) {
                     list($v1, $v2) = explode('/', $v);
                     if ($v1 == '*' && $v2 == '*' || $v1 == $m1 && ($v2 == $m2 || $v2 == '*')) {
                         $allowed = true;
                         break;
                     }
                 }
                 // check wether the mime type is forbidden
                 if (!is_array($this->forbidden)) {
                     $this->forbidden = array($this->forbidden);
                 }
                 foreach ($this->forbidden as $k => $v) {
                     list($v1, $v2) = explode('/', $v);
                     if ($v1 == '*' && $v2 == '*' || $v1 == $m1 && ($v2 == $m2 || $v2 == '*')) {
                         $allowed = false;
                         break;
                     }
                 }
                 if (!$allowed) {
                     $this->processed = false;
                     $this->error = $this->translate('incorrect_file');
                 } else {
                     $this->log .= '- file mime OK : ' . $this->file_src_mime . '<br />';
                 }
             } else {
                 $this->log .= '- file mime (not checked) : ' . $this->file_src_mime . '<br />';
             }
         }
         // if the file is an image, we can check on its dimensions
         // these checks are not available if open_basedir restrictions are in place
         if ($this->file_is_image) {
             if (is_numeric($this->image_src_x) && is_numeric($this->image_src_y)) {
                 $ratio = $this->image_src_x / $this->image_src_y;
                 if (!is_null($this->image_max_width) && $this->image_src_x > $this->image_max_width) {
                     $this->processed = false;
                     $this->error = $this->translate('image_too_wide');
                 }
                 if (!is_null($this->image_min_width) && $this->image_src_x < $this->image_min_width) {
                     $this->processed = false;
                     $this->error = $this->translate('image_too_narrow');
                 }
                 if (!is_null($this->image_max_height) && $this->image_src_y > $this->image_max_height) {
                     $this->processed = false;
                     $this->error = $this->translate('image_too_high');
                 }
                 if (!is_null($this->image_min_height) && $this->image_src_y < $this->image_min_height) {
                     $this->processed = false;
                     $this->error = $this->translate('image_too_short');
                 }
                 if (!is_null($this->image_max_ratio) && $ratio > $this->image_max_ratio) {
                     $this->processed = false;
                     $this->error = $this->translate('ratio_too_high');
                 }
                 if (!is_null($this->image_min_ratio) && $ratio < $this->image_min_ratio) {
                     $this->processed = false;
                     $this->error = $this->translate('ratio_too_low');
                 }
                 if (!is_null($this->image_max_pixels) && $this->image_src_pixels > $this->image_max_pixels) {
                     $this->processed = false;
                     $this->error = $this->translate('too_many_pixels');
                 }
                 if (!is_null($this->image_min_pixels) && $this->image_src_pixels < $this->image_min_pixels) {
                     $this->processed = false;
                     $this->error = $this->translate('not_enough_pixels');
                 }
             } else {
                 $this->log .= '- no image properties available, can\'t enforce dimension checks : ' . $this->file_src_mime . '<br />';
             }
         }
     }
     if ($this->processed) {
         $this->file_dst_path = $server_path;
         // repopulate dst variables from src
         $this->file_dst_name = $file_src_name;
         $this->file_dst_name_body = $file_src_name_body;
         $this->file_dst_name_ext = $file_src_name_ext;
         if ($this->file_overwrite) {
             $this->file_auto_rename = false;
         }
         if ($this->image_convert && $this->file_is_image) {
             // if we convert as an image
             if ($this->file_src_name_ext) {
                 $this->file_dst_name_ext = $this->image_convert;
             }
             $this->log .= '- new file name ext : ' . $this->image_convert . '<br />';
         }
         if (!is_null($this->file_new_name_body)) {
             // rename file body
             $this->file_dst_name_body = $this->file_new_name_body;
             $this->log .= '- new file name body : ' . $this->file_new_name_body . '<br />';
         }
         if (!is_null($this->file_new_name_ext)) {
             // rename file ext
             $this->file_dst_name_ext = $this->file_new_name_ext;
             $this->log .= '- new file name ext : ' . $this->file_new_name_ext . '<br />';
         }
         if (!is_null($this->file_name_body_add)) {
             // append a string to the name
             $this->file_dst_name_body = $this->file_dst_name_body . $this->file_name_body_add;
             $this->log .= '- file name body append : ' . $this->file_name_body_add . '<br />';
         }
         if (!is_null($this->file_name_body_pre)) {
             // prepend a string to the name
             $this->file_dst_name_body = $this->file_name_body_pre . $this->file_dst_name_body;
             $this->log .= '- file name body prepend : ' . $this->file_name_body_pre . '<br />';
         }
         if ($this->file_safe_name) {
             // formats the name
             $this->file_dst_name_body = utf8_encode(strtr(utf8_decode($this->file_dst_name_body), utf8_decode('ŠŽšžŸÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÑÒÓÔÕÖØÙÚÛÜÝàáâãäåçèéêëìíîïñòóôõöøùúûüýÿ'), 'SZszYAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy'));
             $this->file_dst_name_body = strtr($this->file_dst_name_body, array('Þ' => 'TH', 'þ' => 'th', 'Ð' => 'DH', 'ð' => 'dh', 'ß' => 'ss', 'Œ' => 'OE', 'œ' => 'oe', 'Æ' => 'AE', 'æ' => 'ae', 'µ' => 'u'));
             $this->file_dst_name_body = preg_replace(array('/\\s/', '/\\.[\\.]+/', '/[^\\w_\\.\\-]/'), array('_', '.', ''), $this->file_dst_name_body);
             $this->log .= '- file name safe format<br />';
         }
         $this->log .= '- destination variables<br />';
         if (empty($this->file_dst_path) || is_null($this->file_dst_path)) {
             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;file_dst_path         : n/a<br />';
         } else {
             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;file_dst_path         : ' . $this->file_dst_path . '<br />';
         }
         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;file_dst_name_body    : ' . $this->file_dst_name_body . '<br />';
         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;file_dst_name_ext     : ' . $this->file_dst_name_ext . '<br />';
         // do we do some image manipulation?
         $image_manipulation = $this->file_is_image && ($this->image_resize || $this->image_convert != '' || is_numeric($this->image_brightness) || is_numeric($this->image_contrast) || is_numeric($this->image_opacity) || is_numeric($this->image_threshold) || !empty($this->image_tint_color) || !empty($this->image_overlay_color) || $this->image_pixelate || $this->image_unsharp || !empty($this->image_text) || $this->image_greyscale || $this->image_negative || !empty($this->image_watermark) || is_numeric($this->image_rotate) || is_numeric($this->jpeg_size) || !empty($this->image_flip) || !empty($this->image_crop) || !empty($this->image_precrop) || !empty($this->image_border) || !empty($this->image_border_transparent) || $this->image_frame > 0 || $this->image_bevel > 0 || $this->image_reflection_height);
         // set the destination file name
         $this->file_dst_name = $this->file_dst_name_body . (!empty($this->file_dst_name_ext) ? '.' . $this->file_dst_name_ext : '');
         if (!$return_mode) {
             if (!$this->file_auto_rename) {
                 $this->log .= '- no auto_rename if same filename exists<br />';
                 $this->file_dst_pathname = $this->file_dst_path . $this->file_dst_name;
             } else {
                 $this->log .= '- checking for auto_rename<br />';
                 $this->file_dst_pathname = $this->file_dst_path . $this->file_dst_name;
                 $body = $this->file_dst_name_body;
                 $ext = '';
                 // if we have changed the extension, then we add our increment before
                 if ($file_src_name_ext != $this->file_src_name_ext) {
                     if (substr($this->file_dst_name_body, -1 - strlen($this->file_src_name_ext)) == '.' . $this->file_src_name_ext) {
                         $body = substr($this->file_dst_name_body, 0, strlen($this->file_dst_name_body) - 1 - strlen($this->file_src_name_ext));
                         $ext = '.' . $this->file_src_name_ext;
                     }
                 }
                 $cpt = 1;
                 while (@file_exists($this->file_dst_pathname)) {
                     $this->file_dst_name_body = $body . '_' . $cpt . $ext;
                     $this->file_dst_name = $this->file_dst_name_body . (!empty($this->file_dst_name_ext) ? '.' . $this->file_dst_name_ext : '');
                     $cpt++;
                     $this->file_dst_pathname = $this->file_dst_path . $this->file_dst_name;
                 }
                 if ($cpt > 1) {
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;auto_rename to ' . $this->file_dst_name . '<br />';
                 }
             }
             $this->log .= '- destination file details<br />';
             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;file_dst_name         : ' . $this->file_dst_name . '<br />';
             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;file_dst_pathname     : ' . $this->file_dst_pathname . '<br />';
             if ($this->file_overwrite) {
                 $this->log .= '- no overwrite checking<br />';
             } else {
                 if (@file_exists($this->file_dst_pathname)) {
                     $this->processed = false;
                     $this->error = $this->translate('already_exists', array($this->file_dst_name));
                 } else {
                     $this->log .= '- ' . $this->file_dst_name . ' doesn\'t exist already<br />';
                 }
             }
         }
     }
     if ($this->processed) {
         // if we have already moved the uploaded file, we use the temporary copy as source file, and check if it exists
         if (!empty($this->file_src_temp)) {
             $this->log .= '- use the temp file instead of the original file since it is a second process<br />';
             $this->file_src_pathname = $this->file_src_temp;
             if (!file_exists($this->file_src_pathname)) {
                 $this->processed = false;
                 $this->error = $this->translate('temp_file_missing');
             }
             // if we haven't a temp file, and that we do check on uploads, we use is_uploaded_file()
         } else {
             if (!$this->no_upload_check) {
                 if (!is_uploaded_file($this->file_src_pathname)) {
                     $this->processed = false;
                     $this->error = $this->translate('source_missing');
                 }
                 // otherwise, if we don't check on uploaded files (local file for instance), we use file_exists()
             } else {
                 if (!file_exists($this->file_src_pathname)) {
                     $this->processed = false;
                     $this->error = $this->translate('source_missing');
                 }
             }
         }
         // checks if the destination directory exists, and attempt to create it
         if (!$return_mode) {
             if ($this->processed && !file_exists($this->file_dst_path)) {
                 if ($this->dir_auto_create) {
                     $this->log .= '- ' . $this->file_dst_path . ' doesn\'t exist. Attempting creation:';
                     if (!$this->rmkdir($this->file_dst_path, $this->dir_chmod)) {
                         $this->log .= ' failed<br />';
                         $this->processed = false;
                         $this->error = $this->translate('destination_dir');
                     } else {
                         $this->log .= ' success<br />';
                     }
                 } else {
                     $this->error = $this->translate('destination_dir_missing');
                 }
             }
             if ($this->processed && !is_dir($this->file_dst_path)) {
                 $this->processed = false;
                 $this->error = $this->translate('destination_path_not_dir');
             }
             // checks if the destination directory is writeable, and attempt to make it writeable
             $hash = md5($this->file_dst_name_body . rand(1, 1000));
             if ($this->processed && !($f = @fopen($this->file_dst_path . $hash . (!empty($this->file_dst_name_ext) ? '.' . $this->file_dst_name_ext : ''), 'a+'))) {
                 if ($this->dir_auto_chmod) {
                     $this->log .= '- ' . $this->file_dst_path . ' is not writeable. Attempting chmod:';
                     if (!@chmod($this->file_dst_path, $this->dir_chmod)) {
                         $this->log .= ' failed<br />';
                         $this->processed = false;
                         $this->error = $this->translate('destination_dir_write');
                     } else {
                         $this->log .= ' success<br />';
                         if (!($f = @fopen($this->file_dst_path . $hash . (!empty($this->file_dst_name_ext) ? '.' . $this->file_dst_name_ext : ''), 'a+'))) {
                             // we re-check
                             $this->processed = false;
                             $this->error = $this->translate('destination_dir_write');
                         } else {
                             @fclose($f);
                         }
                     }
                 } else {
                     $this->processed = false;
                     $this->error = $this->translate('destination_path_write');
                 }
             } else {
                 if ($this->processed) {
                     @fclose($f);
                 }
                 @unlink($this->file_dst_path . $hash . (!empty($this->file_dst_name_ext) ? '.' . $this->file_dst_name_ext : ''));
             }
             // if we have an uploaded file, and if it is the first process, and if we can't access the file directly (open_basedir restriction)
             // then we create a temp file that will be used as the source file in subsequent processes
             // the third condition is there to check if the file is not accessible *directly* (it already has positively gone through is_uploaded_file(), so it exists)
             if (!$this->no_upload_check && empty($this->file_src_temp) && !@file_exists($this->file_src_pathname)) {
                 $this->log .= '- attempting to use a temp file:';
                 $hash = md5($this->file_dst_name_body . rand(1, 1000));
                 if (move_uploaded_file($this->file_src_pathname, $this->file_dst_path . $hash . (!empty($this->file_dst_name_ext) ? '.' . $this->file_dst_name_ext : ''))) {
                     $this->file_src_pathname = $this->file_dst_path . $hash . (!empty($this->file_dst_name_ext) ? '.' . $this->file_dst_name_ext : '');
                     $this->file_src_temp = $this->file_src_pathname;
                     $this->log .= ' file created<br />';
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;temp file is: ' . $this->file_src_temp . '<br />';
                 } else {
                     $this->log .= ' failed<br />';
                     $this->processed = false;
                     $this->error = $this->translate('temp_file');
                 }
             }
         }
     }
     if ($this->processed) {
         // we do a quick check to ensure the file is really an image
         // we can do this only now, as it would have failed before in case of open_basedir
         if ($image_manipulation && !@getimagesize($this->file_src_pathname)) {
             $this->log .= '- the file is not an image!<br />';
             $image_manipulation = false;
         }
         if ($image_manipulation) {
             // make sure GD doesn't complain too much
             @ini_set("gd.jpeg_ignore_warning", 1);
             // checks if the source file is readable
             if ($this->processed && !($f = @fopen($this->file_src_pathname, 'r'))) {
                 $this->processed = false;
                 $this->error = $this->translate('source_not_readable');
             } else {
                 @fclose($f);
             }
             // we now do all the image manipulations
             $this->log .= '- image resizing or conversion wanted<br />';
             if ($this->gdversion()) {
                 switch ($this->image_src_type) {
                     case 'jpg':
                         if (!function_exists('imagecreatefromjpeg')) {
                             $this->processed = false;
                             $this->error = $this->translate('no_create_support', array('JPEG'));
                         } else {
                             $image_src = @imagecreatefromjpeg($this->file_src_pathname);
                             if (!$image_src) {
                                 $this->processed = false;
                                 $this->error = $this->translate('create_error', array('JPEG'));
                             } else {
                                 $this->log .= '- source image is JPEG<br />';
                             }
                         }
                         break;
                     case 'png':
                         if (!function_exists('imagecreatefrompng')) {
                             $this->processed = false;
                             $this->error = $this->translate('no_create_support', array('PNG'));
                         } else {
                             $image_src = @imagecreatefrompng($this->file_src_pathname);
                             if (!$image_src) {
                                 $this->processed = false;
                                 $this->error = $this->translate('create_error', array('PNG'));
                             } else {
                                 $this->log .= '- source image is PNG<br />';
                             }
                         }
                         break;
                     case 'gif':
                         if (!function_exists('imagecreatefromgif')) {
                             $this->processed = false;
                             $this->error = $this->translate('no_create_support', array('GIF'));
                         } else {
                             $image_src = @imagecreatefromgif($this->file_src_pathname);
                             if (!$image_src) {
                                 $this->processed = false;
                                 $this->error = $this->translate('create_error', array('GIF'));
                             } else {
                                 $this->log .= '- source image is GIF<br />';
                             }
                         }
                         break;
                     case 'bmp':
                         if (!method_exists($this, 'imagecreatefrombmp')) {
                             $this->processed = false;
                             $this->error = $this->translate('no_create_support', array('BMP'));
                         } else {
                             $image_src = @$this->imagecreatefrombmp($this->file_src_pathname);
                             if (!$image_src) {
                                 $this->processed = false;
                                 $this->error = $this->translate('create_error', array('BMP'));
                             } else {
                                 $this->log .= '- source image is BMP<br />';
                             }
                         }
                         break;
                     case 'webp':
                         if (!function_exists('imagecreatefromwebp')) {
                             $this->processed = false;
                             $this->error = $this->translate('no_create_support', array('WEBP'));
                         } else {
                             $image_src = @imagecreatefromwebp($this->file_src_pathname);
                             if (!$image_src) {
                                 $this->processed = false;
                                 $this->error = $this->translate('create_error', array('WEBP'));
                             } else {
                                 $this->log .= '- source image is WEBP<br />';
                             }
                         }
                         break;
                     default:
                         $this->processed = false;
                         $this->error = $this->translate('source_invalid');
                 }
             } else {
                 $this->processed = false;
                 $this->error = $this->translate('gd_missing');
             }
             if ($this->processed && $image_src) {
                 // we have to set image_convert if it is not already
                 if (empty($this->image_convert)) {
                     $this->log .= '- setting destination file type to ' . $this->image_src_type . '<br />';
                     $this->image_convert = $this->image_src_type;
                 }
                 if (!in_array($this->image_convert, $this->image_supported)) {
                     $this->image_convert = 'jpg';
                 }
                 // we set the default color to be the background color if we don't output in a transparent format
                 if ($this->image_convert != 'png' && $this->image_convert != 'gif' && !empty($this->image_default_color) && empty($this->image_background_color)) {
                     $this->image_background_color = $this->image_default_color;
                 }
                 if (!empty($this->image_background_color)) {
                     $this->image_default_color = $this->image_background_color;
                 }
                 if (empty($this->image_default_color)) {
                     $this->image_default_color = '#FFFFFF';
                 }
                 $this->image_src_x = imagesx($image_src);
                 $this->image_src_y = imagesy($image_src);
                 $gd_version = $this->gdversion();
                 $ratio_crop = null;
                 if (!imageistruecolor($image_src)) {
                     // $this->image_src_type == 'gif'
                     $this->log .= '- image is detected as having a palette<br />';
                     $this->image_is_palette = true;
                     $this->image_transparent_color = imagecolortransparent($image_src);
                     if ($this->image_transparent_color >= 0 && imagecolorstotal($image_src) > $this->image_transparent_color) {
                         $this->image_is_transparent = true;
                         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;palette image is detected as transparent<br />';
                     }
                     // if the image has a palette (GIF), we convert it to true color, preserving transparency
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;convert palette image to true color<br />';
                     $true_color = imagecreatetruecolor($this->image_src_x, $this->image_src_y);
                     imagealphablending($true_color, false);
                     imagesavealpha($true_color, true);
                     for ($x = 0; $x < $this->image_src_x; $x++) {
                         for ($y = 0; $y < $this->image_src_y; $y++) {
                             if ($this->image_transparent_color >= 0 && imagecolorat($image_src, $x, $y) == $this->image_transparent_color) {
                                 imagesetpixel($true_color, $x, $y, 127 << 24);
                             } else {
                                 $rgb = imagecolorsforindex($image_src, imagecolorat($image_src, $x, $y));
                                 imagesetpixel($true_color, $x, $y, $rgb['alpha'] << 24 | $rgb['red'] << 16 | $rgb['green'] << 8 | $rgb['blue']);
                             }
                         }
                     }
                     $image_src = $this->imagetransfer($true_color, $image_src);
                     imagealphablending($image_src, false);
                     imagesavealpha($image_src, true);
                     $this->image_is_palette = false;
                 }
                 $image_dst =& $image_src;
                 // pre-crop image, before resizing
                 if (!empty($this->image_precrop)) {
                     list($ct, $cr, $cb, $cl) = $this->getoffsets($this->image_precrop, $this->image_src_x, $this->image_src_y, true, true);
                     $this->log .= '- pre-crop image : ' . $ct . ' ' . $cr . ' ' . $cb . ' ' . $cl . ' <br />';
                     $this->image_src_x = $this->image_src_x - $cl - $cr;
                     $this->image_src_y = $this->image_src_y - $ct - $cb;
                     if ($this->image_src_x < 1) {
                         $this->image_src_x = 1;
                     }
                     if ($this->image_src_y < 1) {
                         $this->image_src_y = 1;
                     }
                     $tmp = $this->imagecreatenew($this->image_src_x, $this->image_src_y);
                     // we copy the image into the recieving image
                     imagecopy($tmp, $image_dst, 0, 0, $cl, $ct, $this->image_src_x, $this->image_src_y);
                     // if we crop with negative margins, we have to make sure the extra bits are the right color, or transparent
                     if ($ct < 0 || $cr < 0 || $cb < 0 || $cl < 0) {
                         // use the background color if present
                         if (!empty($this->image_background_color)) {
                             list($red, $green, $blue) = $this->getcolors($this->image_background_color);
                             $fill = imagecolorallocate($tmp, $red, $green, $blue);
                         } else {
                             $fill = imagecolorallocatealpha($tmp, 0, 0, 0, 127);
                         }
                         // fills eventual negative margins
                         if ($ct < 0) {
                             imagefilledrectangle($tmp, 0, 0, $this->image_src_x, -$ct, $fill);
                         }
                         if ($cr < 0) {
                             imagefilledrectangle($tmp, $this->image_src_x + $cr, 0, $this->image_src_x, $this->image_src_y, $fill);
                         }
                         if ($cb < 0) {
                             imagefilledrectangle($tmp, 0, $this->image_src_y + $cb, $this->image_src_x, $this->image_src_y, $fill);
                         }
                         if ($cl < 0) {
                             imagefilledrectangle($tmp, 0, 0, -$cl, $this->image_src_y, $fill);
                         }
                     }
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // resize image (and move image_src_x, image_src_y dimensions into image_dst_x, image_dst_y)
                 if ($this->image_resize) {
                     $this->log .= '- resizing...<br />';
                     if ($this->image_ratio_x) {
                         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;calculate x size<br />';
                         $this->image_dst_x = round($this->image_src_x * $this->image_y / $this->image_src_y);
                         $this->image_dst_y = $this->image_y;
                     } else {
                         if ($this->image_ratio_y) {
                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;calculate y size<br />';
                             $this->image_dst_x = $this->image_x;
                             $this->image_dst_y = round($this->image_src_y * $this->image_x / $this->image_src_x);
                         } else {
                             if (is_numeric($this->image_ratio_pixels)) {
                                 $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;calculate x/y size to match a number of pixels<br />';
                                 $pixels = $this->image_src_y * $this->image_src_x;
                                 $diff = sqrt($this->image_ratio_pixels / $pixels);
                                 $this->image_dst_x = round($this->image_src_x * $diff);
                                 $this->image_dst_y = round($this->image_src_y * $diff);
                             } else {
                                 if ($this->image_ratio || $this->image_ratio_crop || $this->image_ratio_fill || $this->image_ratio_no_zoom_in || $this->image_ratio_no_zoom_out) {
                                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;check x/y sizes<br />';
                                     if (!$this->image_ratio_no_zoom_in && !$this->image_ratio_no_zoom_out || $this->image_ratio_no_zoom_in && ($this->image_src_x > $this->image_x || $this->image_src_y > $this->image_y) || $this->image_ratio_no_zoom_out && $this->image_src_x < $this->image_x && $this->image_src_y < $this->image_y) {
                                         $this->image_dst_x = $this->image_x;
                                         $this->image_dst_y = $this->image_y;
                                         if ($this->image_ratio_crop) {
                                             if (!is_string($this->image_ratio_crop)) {
                                                 $this->image_ratio_crop = '';
                                             }
                                             $this->image_ratio_crop = strtolower($this->image_ratio_crop);
                                             if ($this->image_src_x / $this->image_x > $this->image_src_y / $this->image_y) {
                                                 $this->image_dst_y = $this->image_y;
                                                 $this->image_dst_x = intval($this->image_src_x * ($this->image_y / $this->image_src_y));
                                                 $ratio_crop = array();
                                                 $ratio_crop['x'] = $this->image_dst_x - $this->image_x;
                                                 if (strpos($this->image_ratio_crop, 'l') !== false) {
                                                     $ratio_crop['l'] = 0;
                                                     $ratio_crop['r'] = $ratio_crop['x'];
                                                 } else {
                                                     if (strpos($this->image_ratio_crop, 'r') !== false) {
                                                         $ratio_crop['l'] = $ratio_crop['x'];
                                                         $ratio_crop['r'] = 0;
                                                     } else {
                                                         $ratio_crop['l'] = round($ratio_crop['x'] / 2);
                                                         $ratio_crop['r'] = $ratio_crop['x'] - $ratio_crop['l'];
                                                     }
                                                 }
                                                 $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;ratio_crop_x         : ' . $ratio_crop['x'] . ' (' . $ratio_crop['l'] . ';' . $ratio_crop['r'] . ')<br />';
                                                 if (is_null($this->image_crop)) {
                                                     $this->image_crop = array(0, 0, 0, 0);
                                                 }
                                             } else {
                                                 $this->image_dst_x = $this->image_x;
                                                 $this->image_dst_y = intval($this->image_src_y * ($this->image_x / $this->image_src_x));
                                                 $ratio_crop = array();
                                                 $ratio_crop['y'] = $this->image_dst_y - $this->image_y;
                                                 if (strpos($this->image_ratio_crop, 't') !== false) {
                                                     $ratio_crop['t'] = 0;
                                                     $ratio_crop['b'] = $ratio_crop['y'];
                                                 } else {
                                                     if (strpos($this->image_ratio_crop, 'b') !== false) {
                                                         $ratio_crop['t'] = $ratio_crop['y'];
                                                         $ratio_crop['b'] = 0;
                                                     } else {
                                                         $ratio_crop['t'] = round($ratio_crop['y'] / 2);
                                                         $ratio_crop['b'] = $ratio_crop['y'] - $ratio_crop['t'];
                                                     }
                                                 }
                                                 $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;ratio_crop_y         : ' . $ratio_crop['y'] . ' (' . $ratio_crop['t'] . ';' . $ratio_crop['b'] . ')<br />';
                                                 if (is_null($this->image_crop)) {
                                                     $this->image_crop = array(0, 0, 0, 0);
                                                 }
                                             }
                                         } else {
                                             if ($this->image_ratio_fill) {
                                                 if (!is_string($this->image_ratio_fill)) {
                                                     $this->image_ratio_fill = '';
                                                 }
                                                 $this->image_ratio_fill = strtolower($this->image_ratio_fill);
                                                 if ($this->image_src_x / $this->image_x < $this->image_src_y / $this->image_y) {
                                                     $this->image_dst_y = $this->image_y;
                                                     $this->image_dst_x = intval($this->image_src_x * ($this->image_y / $this->image_src_y));
                                                     $ratio_crop = array();
                                                     $ratio_crop['x'] = $this->image_dst_x - $this->image_x;
                                                     if (strpos($this->image_ratio_fill, 'l') !== false) {
                                                         $ratio_crop['l'] = 0;
                                                         $ratio_crop['r'] = $ratio_crop['x'];
                                                     } else {
                                                         if (strpos($this->image_ratio_fill, 'r') !== false) {
                                                             $ratio_crop['l'] = $ratio_crop['x'];
                                                             $ratio_crop['r'] = 0;
                                                         } else {
                                                             $ratio_crop['l'] = round($ratio_crop['x'] / 2);
                                                             $ratio_crop['r'] = $ratio_crop['x'] - $ratio_crop['l'];
                                                         }
                                                     }
                                                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;ratio_fill_x         : ' . $ratio_crop['x'] . ' (' . $ratio_crop['l'] . ';' . $ratio_crop['r'] . ')<br />';
                                                     if (is_null($this->image_crop)) {
                                                         $this->image_crop = array(0, 0, 0, 0);
                                                     }
                                                 } else {
                                                     $this->image_dst_x = $this->image_x;
                                                     $this->image_dst_y = intval($this->image_src_y * ($this->image_x / $this->image_src_x));
                                                     $ratio_crop = array();
                                                     $ratio_crop['y'] = $this->image_dst_y - $this->image_y;
                                                     if (strpos($this->image_ratio_fill, 't') !== false) {
                                                         $ratio_crop['t'] = 0;
                                                         $ratio_crop['b'] = $ratio_crop['y'];
                                                     } else {
                                                         if (strpos($this->image_ratio_fill, 'b') !== false) {
                                                             $ratio_crop['t'] = $ratio_crop['y'];
                                                             $ratio_crop['b'] = 0;
                                                         } else {
                                                             $ratio_crop['t'] = round($ratio_crop['y'] / 2);
                                                             $ratio_crop['b'] = $ratio_crop['y'] - $ratio_crop['t'];
                                                         }
                                                     }
                                                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;ratio_fill_y         : ' . $ratio_crop['y'] . ' (' . $ratio_crop['t'] . ';' . $ratio_crop['b'] . ')<br />';
                                                     if (is_null($this->image_crop)) {
                                                         $this->image_crop = array(0, 0, 0, 0);
                                                     }
                                                 }
                                             } else {
                                                 if ($this->image_src_x / $this->image_x > $this->image_src_y / $this->image_y) {
                                                     $this->image_dst_x = $this->image_x;
                                                     $this->image_dst_y = intval($this->image_src_y * ($this->image_x / $this->image_src_x));
                                                 } else {
                                                     $this->image_dst_y = $this->image_y;
                                                     $this->image_dst_x = intval($this->image_src_x * ($this->image_y / $this->image_src_y));
                                                 }
                                             }
                                         }
                                     } else {
                                         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;doesn\'t calculate x/y sizes<br />';
                                         $this->image_dst_x = $this->image_src_x;
                                         $this->image_dst_y = $this->image_src_y;
                                     }
                                 } else {
                                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;use plain sizes<br />';
                                     $this->image_dst_x = $this->image_x;
                                     $this->image_dst_y = $this->image_y;
                                 }
                             }
                         }
                     }
                     if ($this->image_dst_x < 1) {
                         $this->image_dst_x = 1;
                     }
                     if ($this->image_dst_y < 1) {
                         $this->image_dst_y = 1;
                     }
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     if ($gd_version >= 2) {
                         $res = imagecopyresampled($tmp, $image_src, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y, $this->image_src_x, $this->image_src_y);
                     } else {
                         $res = imagecopyresized($tmp, $image_src, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y, $this->image_src_x, $this->image_src_y);
                     }
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;resized image object created<br />';
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;image_src_x y        : ' . $this->image_src_x . ' x ' . $this->image_src_y . '<br />';
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;image_dst_x y        : ' . $this->image_dst_x . ' x ' . $this->image_dst_y . '<br />';
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 } else {
                     $this->image_dst_x = $this->image_src_x;
                     $this->image_dst_y = $this->image_src_y;
                 }
                 // crop image (and also crops if image_ratio_crop is used)
                 if (!empty($this->image_crop) || !is_null($ratio_crop)) {
                     list($ct, $cr, $cb, $cl) = $this->getoffsets($this->image_crop, $this->image_dst_x, $this->image_dst_y, true, true);
                     // we adjust the cropping if we use image_ratio_crop
                     if (!is_null($ratio_crop)) {
                         if (array_key_exists('t', $ratio_crop)) {
                             $ct += $ratio_crop['t'];
                         }
                         if (array_key_exists('r', $ratio_crop)) {
                             $cr += $ratio_crop['r'];
                         }
                         if (array_key_exists('b', $ratio_crop)) {
                             $cb += $ratio_crop['b'];
                         }
                         if (array_key_exists('l', $ratio_crop)) {
                             $cl += $ratio_crop['l'];
                         }
                     }
                     $this->log .= '- crop image : ' . $ct . ' ' . $cr . ' ' . $cb . ' ' . $cl . ' <br />';
                     $this->image_dst_x = $this->image_dst_x - $cl - $cr;
                     $this->image_dst_y = $this->image_dst_y - $ct - $cb;
                     if ($this->image_dst_x < 1) {
                         $this->image_dst_x = 1;
                     }
                     if ($this->image_dst_y < 1) {
                         $this->image_dst_y = 1;
                     }
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     // we copy the image into the recieving image
                     imagecopy($tmp, $image_dst, 0, 0, $cl, $ct, $this->image_dst_x, $this->image_dst_y);
                     // if we crop with negative margins, we have to make sure the extra bits are the right color, or transparent
                     if ($ct < 0 || $cr < 0 || $cb < 0 || $cl < 0) {
                         // use the background color if present
                         if (!empty($this->image_background_color)) {
                             list($red, $green, $blue) = $this->getcolors($this->image_background_color);
                             $fill = imagecolorallocate($tmp, $red, $green, $blue);
                         } else {
                             $fill = imagecolorallocatealpha($tmp, 0, 0, 0, 127);
                         }
                         // fills eventual negative margins
                         if ($ct < 0) {
                             imagefilledrectangle($tmp, 0, 0, $this->image_dst_x, -$ct - 1, $fill);
                         }
                         if ($cr < 0) {
                             imagefilledrectangle($tmp, $this->image_dst_x + $cr, 0, $this->image_dst_x, $this->image_dst_y, $fill);
                         }
                         if ($cb < 0) {
                             imagefilledrectangle($tmp, 0, $this->image_dst_y + $cb, $this->image_dst_x, $this->image_dst_y, $fill);
                         }
                         if ($cl < 0) {
                             imagefilledrectangle($tmp, 0, 0, -$cl - 1, $this->image_dst_y, $fill);
                         }
                     }
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // flip image
                 if ($gd_version >= 2 && !empty($this->image_flip)) {
                     $this->image_flip = strtolower($this->image_flip);
                     $this->log .= '- flip image : ' . $this->image_flip . '<br />';
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     for ($x = 0; $x < $this->image_dst_x; $x++) {
                         for ($y = 0; $y < $this->image_dst_y; $y++) {
                             if (strpos($this->image_flip, 'v') !== false) {
                                 imagecopy($tmp, $image_dst, $this->image_dst_x - $x - 1, $y, $x, $y, 1, 1);
                             } else {
                                 imagecopy($tmp, $image_dst, $x, $this->image_dst_y - $y - 1, $x, $y, 1, 1);
                             }
                         }
                     }
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // rotate image
                 if ($gd_version >= 2 && is_numeric($this->image_rotate)) {
                     if (!in_array($this->image_rotate, array(0, 90, 180, 270))) {
                         $this->image_rotate = 0;
                     }
                     if ($this->image_rotate != 0) {
                         if ($this->image_rotate == 90 || $this->image_rotate == 270) {
                             $tmp = $this->imagecreatenew($this->image_dst_y, $this->image_dst_x);
                         } else {
                             $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                         }
                         $this->log .= '- rotate image : ' . $this->image_rotate . '<br />';
                         for ($x = 0; $x < $this->image_dst_x; $x++) {
                             for ($y = 0; $y < $this->image_dst_y; $y++) {
                                 if ($this->image_rotate == 90) {
                                     imagecopy($tmp, $image_dst, $y, $x, $x, $this->image_dst_y - $y - 1, 1, 1);
                                 } else {
                                     if ($this->image_rotate == 180) {
                                         imagecopy($tmp, $image_dst, $x, $y, $this->image_dst_x - $x - 1, $this->image_dst_y - $y - 1, 1, 1);
                                     } else {
                                         if ($this->image_rotate == 270) {
                                             imagecopy($tmp, $image_dst, $y, $x, $this->image_dst_x - $x - 1, $y, 1, 1);
                                         } else {
                                             imagecopy($tmp, $image_dst, $x, $y, $x, $y, 1, 1);
                                         }
                                     }
                                 }
                             }
                         }
                         if ($this->image_rotate == 90 || $this->image_rotate == 270) {
                             $t = $this->image_dst_y;
                             $this->image_dst_y = $this->image_dst_x;
                             $this->image_dst_x = $t;
                         }
                         // we transfert tmp into image_dst
                         $image_dst = $this->imagetransfer($tmp, $image_dst);
                     }
                 }
                 // pixelate image
                 if (is_numeric($this->image_pixelate) && $this->image_pixelate > 0) {
                     $this->log .= '- pixelate image (' . $this->image_pixelate . 'px)<br />';
                     $filter = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     if ($gd_version >= 2) {
                         imagecopyresampled($filter, $image_dst, 0, 0, 0, 0, round($this->image_dst_x / $this->image_pixelate), round($this->image_dst_y / $this->image_pixelate), $this->image_dst_x, $this->image_dst_y);
                         imagecopyresampled($image_dst, $filter, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y, round($this->image_dst_x / $this->image_pixelate), round($this->image_dst_y / $this->image_pixelate));
                     } else {
                         imagecopyresized($filter, $image_dst, 0, 0, 0, 0, round($this->image_dst_x / $this->image_pixelate), round($this->image_dst_y / $this->image_pixelate), $this->image_dst_x, $this->image_dst_y);
                         imagecopyresized($image_dst, $filter, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y, round($this->image_dst_x / $this->image_pixelate), round($this->image_dst_y / $this->image_pixelate));
                     }
                     imagedestroy($filter);
                 }
                 // unsharp mask
                 if ($gd_version >= 2 && $this->image_unsharp && is_numeric($this->image_unsharp_amount) && is_numeric($this->image_unsharp_radius) && is_numeric($this->image_unsharp_threshold)) {
                     // Unsharp Mask for PHP - version 2.1.1
                     // Unsharp mask algorithm by Torstein Hønsi 2003-07.
                     // Used with permission
                     // Modified to support alpha transparency
                     if ($this->image_unsharp_amount > 500) {
                         $this->image_unsharp_amount = 500;
                     }
                     $this->image_unsharp_amount = $this->image_unsharp_amount * 0.016;
                     if ($this->image_unsharp_radius > 50) {
                         $this->image_unsharp_radius = 50;
                     }
                     $this->image_unsharp_radius = $this->image_unsharp_radius * 2;
                     if ($this->image_unsharp_threshold > 255) {
                         $this->image_unsharp_threshold = 255;
                     }
                     $this->image_unsharp_radius = abs(round($this->image_unsharp_radius));
                     if ($this->image_unsharp_radius != 0) {
                         $this->image_dst_x = imagesx($image_dst);
                         $this->image_dst_y = imagesy($image_dst);
                         $canvas = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y, false, true);
                         $blur = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y, false, true);
                         if (function_exists('imageconvolution')) {
                             // PHP >= 5.1
                             $matrix = array(array(1, 2, 1), array(2, 4, 2), array(1, 2, 1));
                             imagecopy($blur, $image_dst, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y);
                             imageconvolution($blur, $matrix, 16, 0);
                         } else {
                             for ($i = 0; $i < $this->image_unsharp_radius; $i++) {
                                 imagecopy($blur, $image_dst, 0, 0, 1, 0, $this->image_dst_x - 1, $this->image_dst_y);
                                 // left
                                 $this->imagecopymergealpha($blur, $image_dst, 1, 0, 0, 0, $this->image_dst_x, $this->image_dst_y, 50);
                                 // right
                                 $this->imagecopymergealpha($blur, $image_dst, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y, 50);
                                 // center
                                 imagecopy($canvas, $blur, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y);
                                 $this->imagecopymergealpha($blur, $canvas, 0, 0, 0, 1, $this->image_dst_x, $this->image_dst_y - 1, 33.33333);
                                 // up
                                 $this->imagecopymergealpha($blur, $canvas, 0, 1, 0, 0, $this->image_dst_x, $this->image_dst_y, 25);
                                 // down
                             }
                         }
                         $p_new = array();
                         if ($this->image_unsharp_threshold > 0) {
                             for ($x = 0; $x < $this->image_dst_x - 1; $x++) {
                                 for ($y = 0; $y < $this->image_dst_y; $y++) {
                                     $p_orig = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                     $p_blur = imagecolorsforindex($blur, imagecolorat($blur, $x, $y));
                                     $p_new['red'] = abs($p_orig['red'] - $p_blur['red']) >= $this->image_unsharp_threshold ? max(0, min(255, $this->image_unsharp_amount * ($p_orig['red'] - $p_blur['red']) + $p_orig['red'])) : $p_orig['red'];
                                     $p_new['green'] = abs($p_orig['green'] - $p_blur['green']) >= $this->image_unsharp_threshold ? max(0, min(255, $this->image_unsharp_amount * ($p_orig['green'] - $p_blur['green']) + $p_orig['green'])) : $p_orig['green'];
                                     $p_new['blue'] = abs($p_orig['blue'] - $p_blur['blue']) >= $this->image_unsharp_threshold ? max(0, min(255, $this->image_unsharp_amount * ($p_orig['blue'] - $p_blur['blue']) + $p_orig['blue'])) : $p_orig['blue'];
                                     if ($p_orig['red'] != $p_new['red'] || $p_orig['green'] != $p_new['green'] || $p_orig['blue'] != $p_new['blue']) {
                                         $color = imagecolorallocatealpha($image_dst, $p_new['red'], $p_new['green'], $p_new['blue'], $p_orig['alpha']);
                                         imagesetpixel($image_dst, $x, $y, $color);
                                     }
                                 }
                             }
                         } else {
                             for ($x = 0; $x < $this->image_dst_x; $x++) {
                                 for ($y = 0; $y < $this->image_dst_y; $y++) {
                                     $p_orig = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                     $p_blur = imagecolorsforindex($blur, imagecolorat($blur, $x, $y));
                                     $p_new['red'] = $this->image_unsharp_amount * ($p_orig['red'] - $p_blur['red']) + $p_orig['red'];
                                     if ($p_new['red'] > 255) {
                                         $p_new['red'] = 255;
                                     } elseif ($p_new['red'] < 0) {
                                         $p_new['red'] = 0;
                                     }
                                     $p_new['green'] = $this->image_unsharp_amount * ($p_orig['green'] - $p_blur['green']) + $p_orig['green'];
                                     if ($p_new['green'] > 255) {
                                         $p_new['green'] = 255;
                                     } elseif ($p_new['green'] < 0) {
                                         $p_new['green'] = 0;
                                     }
                                     $p_new['blue'] = $this->image_unsharp_amount * ($p_orig['blue'] - $p_blur['blue']) + $p_orig['blue'];
                                     if ($p_new['blue'] > 255) {
                                         $p_new['blue'] = 255;
                                     } elseif ($p_new['blue'] < 0) {
                                         $p_new['blue'] = 0;
                                     }
                                     $color = imagecolorallocatealpha($image_dst, $p_new['red'], $p_new['green'], $p_new['blue'], $p_orig['alpha']);
                                     imagesetpixel($image_dst, $x, $y, $color);
                                 }
                             }
                         }
                         imagedestroy($canvas);
                         imagedestroy($blur);
                     }
                 }
                 // add color overlay
                 if ($gd_version >= 2 && (is_numeric($this->image_overlay_opacity) && $this->image_overlay_opacity > 0 && !empty($this->image_overlay_color))) {
                     $this->log .= '- apply color overlay<br />';
                     list($red, $green, $blue) = $this->getcolors($this->image_overlay_color);
                     $filter = imagecreatetruecolor($this->image_dst_x, $this->image_dst_y);
                     $color = imagecolorallocate($filter, $red, $green, $blue);
                     imagefilledrectangle($filter, 0, 0, $this->image_dst_x, $this->image_dst_y, $color);
                     $this->imagecopymergealpha($image_dst, $filter, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y, $this->image_overlay_opacity);
                     imagedestroy($filter);
                 }
                 // add brightness, contrast and tint, turns to greyscale and inverts colors
                 if ($gd_version >= 2 && ($this->image_negative || $this->image_greyscale || is_numeric($this->image_threshold) || is_numeric($this->image_brightness) || is_numeric($this->image_contrast) || !empty($this->image_tint_color))) {
                     $this->log .= '- apply tint, light, contrast correction, negative, greyscale and threshold<br />';
                     if (!empty($this->image_tint_color)) {
                         list($tint_red, $tint_green, $tint_blue) = $this->getcolors($this->image_tint_color);
                     }
                     //imagealphablending($image_dst, true);
                     for ($y = 0; $y < $this->image_dst_y; $y++) {
                         for ($x = 0; $x < $this->image_dst_x; $x++) {
                             if ($this->image_greyscale) {
                                 $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                 $r = $g = $b = round(0.2125 * $pixel['red'] + 0.7154 * $pixel['green'] + 0.0721 * $pixel['blue']);
                                 $color = imagecolorallocatealpha($image_dst, $r, $g, $b, $pixel['alpha']);
                                 imagesetpixel($image_dst, $x, $y, $color);
                                 unset($color);
                                 unset($pixel);
                             }
                             if (is_numeric($this->image_threshold)) {
                                 $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                 $c = round($pixel['red'] + $pixel['green'] + $pixel['blue']) / 3 - 127;
                                 $r = $g = $b = $c > $this->image_threshold ? 255 : 0;
                                 $color = imagecolorallocatealpha($image_dst, $r, $g, $b, $pixel['alpha']);
                                 imagesetpixel($image_dst, $x, $y, $color);
                                 unset($color);
                                 unset($pixel);
                             }
                             if (is_numeric($this->image_brightness)) {
                                 $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                 $r = max(min(round($pixel['red'] + $this->image_brightness * 2), 255), 0);
                                 $g = max(min(round($pixel['green'] + $this->image_brightness * 2), 255), 0);
                                 $b = max(min(round($pixel['blue'] + $this->image_brightness * 2), 255), 0);
                                 $color = imagecolorallocatealpha($image_dst, $r, $g, $b, $pixel['alpha']);
                                 imagesetpixel($image_dst, $x, $y, $color);
                                 unset($color);
                                 unset($pixel);
                             }
                             if (is_numeric($this->image_contrast)) {
                                 $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                 $r = max(min(round(($this->image_contrast + 128) * $pixel['red'] / 128), 255), 0);
                                 $g = max(min(round(($this->image_contrast + 128) * $pixel['green'] / 128), 255), 0);
                                 $b = max(min(round(($this->image_contrast + 128) * $pixel['blue'] / 128), 255), 0);
                                 $color = imagecolorallocatealpha($image_dst, $r, $g, $b, $pixel['alpha']);
                                 imagesetpixel($image_dst, $x, $y, $color);
                                 unset($color);
                                 unset($pixel);
                             }
                             if (!empty($this->image_tint_color)) {
                                 $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                 $r = min(round($tint_red * $pixel['red'] / 169), 255);
                                 $g = min(round($tint_green * $pixel['green'] / 169), 255);
                                 $b = min(round($tint_blue * $pixel['blue'] / 169), 255);
                                 $color = imagecolorallocatealpha($image_dst, $r, $g, $b, $pixel['alpha']);
                                 imagesetpixel($image_dst, $x, $y, $color);
                                 unset($color);
                                 unset($pixel);
                             }
                             if (!empty($this->image_negative)) {
                                 $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                 $r = round(255 - $pixel['red']);
                                 $g = round(255 - $pixel['green']);
                                 $b = round(255 - $pixel['blue']);
                                 $color = imagecolorallocatealpha($image_dst, $r, $g, $b, $pixel['alpha']);
                                 imagesetpixel($image_dst, $x, $y, $color);
                                 unset($color);
                                 unset($pixel);
                             }
                         }
                     }
                 }
                 // adds a border
                 if ($gd_version >= 2 && !empty($this->image_border)) {
                     list($ct, $cr, $cb, $cl) = $this->getoffsets($this->image_border, $this->image_dst_x, $this->image_dst_y, true, false);
                     $this->log .= '- add border : ' . $ct . ' ' . $cr . ' ' . $cb . ' ' . $cl . '<br />';
                     $this->image_dst_x = $this->image_dst_x + $cl + $cr;
                     $this->image_dst_y = $this->image_dst_y + $ct + $cb;
                     if (!empty($this->image_border_color)) {
                         list($red, $green, $blue) = $this->getcolors($this->image_border_color);
                     }
                     $opacity = is_numeric($this->image_border_opacity) ? (int) (127 - $this->image_border_opacity / 100 * 127) : 0;
                     // we now create an image, that we fill with the border color
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     $background = imagecolorallocatealpha($tmp, $red, $green, $blue, $opacity);
                     imagefilledrectangle($tmp, 0, 0, $this->image_dst_x, $this->image_dst_y, $background);
                     // we then copy the source image into the new image, without merging so that only the border is actually kept
                     imagecopy($tmp, $image_dst, $cl, $ct, 0, 0, $this->image_dst_x - $cr - $cl, $this->image_dst_y - $cb - $ct);
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // adds a fading-to-transparent border
                 if ($gd_version >= 2 && !empty($this->image_border_transparent)) {
                     list($ct, $cr, $cb, $cl) = $this->getoffsets($this->image_border_transparent, $this->image_dst_x, $this->image_dst_y, true, false);
                     $this->log .= '- add transparent border : ' . $ct . ' ' . $cr . ' ' . $cb . ' ' . $cl . '<br />';
                     // we now create an image, that we fill with the border color
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     // we then copy the source image into the new image, without the borders
                     imagecopy($tmp, $image_dst, $cl, $ct, $cl, $ct, $this->image_dst_x - $cr - $cl, $this->image_dst_y - $cb - $ct);
                     // we now add the top border
                     $opacity = 100;
                     for ($y = $ct - 1; $y >= 0; $y--) {
                         $il = (int) ($ct > 0 ? $cl * ($y / $ct) : 0);
                         $ir = (int) ($ct > 0 ? $cr * ($y / $ct) : 0);
                         for ($x = $il; $x < $this->image_dst_x - $ir; $x++) {
                             $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                             $alpha = (1 - $pixel['alpha'] / 127) * $opacity / 100;
                             if ($alpha > 0) {
                                 if ($alpha > 1) {
                                     $alpha = 1;
                                 }
                                 $color = imagecolorallocatealpha($tmp, $pixel['red'], $pixel['green'], $pixel['blue'], round((1 - $alpha) * 127));
                                 imagesetpixel($tmp, $x, $y, $color);
                             }
                         }
                         if ($opacity > 0) {
                             $opacity = $opacity - 100 / $ct;
                         }
                     }
                     // we now add the right border
                     $opacity = 100;
                     for ($x = $this->image_dst_x - $cr; $x < $this->image_dst_x; $x++) {
                         $it = (int) ($cr > 0 ? $ct * (($this->image_dst_x - $x - 1) / $cr) : 0);
                         $ib = (int) ($cr > 0 ? $cb * (($this->image_dst_x - $x - 1) / $cr) : 0);
                         for ($y = $it; $y < $this->image_dst_y - $ib; $y++) {
                             $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                             $alpha = (1 - $pixel['alpha'] / 127) * $opacity / 100;
                             if ($alpha > 0) {
                                 if ($alpha > 1) {
                                     $alpha = 1;
                                 }
                                 $color = imagecolorallocatealpha($tmp, $pixel['red'], $pixel['green'], $pixel['blue'], round((1 - $alpha) * 127));
                                 imagesetpixel($tmp, $x, $y, $color);
                             }
                         }
                         if ($opacity > 0) {
                             $opacity = $opacity - 100 / $cr;
                         }
                     }
                     // we now add the bottom border
                     $opacity = 100;
                     for ($y = $this->image_dst_y - $cb; $y < $this->image_dst_y; $y++) {
                         $il = (int) ($cb > 0 ? $cl * (($this->image_dst_y - $y - 1) / $cb) : 0);
                         $ir = (int) ($cb > 0 ? $cr * (($this->image_dst_y - $y - 1) / $cb) : 0);
                         for ($x = $il; $x < $this->image_dst_x - $ir; $x++) {
                             $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                             $alpha = (1 - $pixel['alpha'] / 127) * $opacity / 100;
                             if ($alpha > 0) {
                                 if ($alpha > 1) {
                                     $alpha = 1;
                                 }
                                 $color = imagecolorallocatealpha($tmp, $pixel['red'], $pixel['green'], $pixel['blue'], round((1 - $alpha) * 127));
                                 imagesetpixel($tmp, $x, $y, $color);
                             }
                         }
                         if ($opacity > 0) {
                             $opacity = $opacity - 100 / $cb;
                         }
                     }
                     // we now add the left border
                     $opacity = 100;
                     for ($x = $cl - 1; $x >= 0; $x--) {
                         $it = (int) ($cl > 0 ? $ct * ($x / $cl) : 0);
                         $ib = (int) ($cl > 0 ? $cb * ($x / $cl) : 0);
                         for ($y = $it; $y < $this->image_dst_y - $ib; $y++) {
                             $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                             $alpha = (1 - $pixel['alpha'] / 127) * $opacity / 100;
                             if ($alpha > 0) {
                                 if ($alpha > 1) {
                                     $alpha = 1;
                                 }
                                 $color = imagecolorallocatealpha($tmp, $pixel['red'], $pixel['green'], $pixel['blue'], round((1 - $alpha) * 127));
                                 imagesetpixel($tmp, $x, $y, $color);
                             }
                         }
                         if ($opacity > 0) {
                             $opacity = $opacity - 100 / $cl;
                         }
                     }
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // add frame border
                 if ($gd_version >= 2 && is_numeric($this->image_frame)) {
                     if (is_array($this->image_frame_colors)) {
                         $vars = $this->image_frame_colors;
                         $this->log .= '- add frame : ' . implode(' ', $this->image_frame_colors) . '<br />';
                     } else {
                         $this->log .= '- add frame : ' . $this->image_frame_colors . '<br />';
                         $vars = explode(' ', $this->image_frame_colors);
                     }
                     $nb = sizeof($vars);
                     $this->image_dst_x = $this->image_dst_x + $nb * 2;
                     $this->image_dst_y = $this->image_dst_y + $nb * 2;
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     imagecopy($tmp, $image_dst, $nb, $nb, 0, 0, $this->image_dst_x - $nb * 2, $this->image_dst_y - $nb * 2);
                     $opacity = is_numeric($this->image_frame_opacity) ? (int) (127 - $this->image_frame_opacity / 100 * 127) : 0;
                     for ($i = 0; $i < $nb; $i++) {
                         list($red, $green, $blue) = $this->getcolors($vars[$i]);
                         $c = imagecolorallocatealpha($tmp, $red, $green, $blue, $opacity);
                         if ($this->image_frame == 1) {
                             imageline($tmp, $i, $i, $this->image_dst_x - $i - 1, $i, $c);
                             imageline($tmp, $this->image_dst_x - $i - 1, $this->image_dst_y - $i - 1, $this->image_dst_x - $i - 1, $i, $c);
                             imageline($tmp, $this->image_dst_x - $i - 1, $this->image_dst_y - $i - 1, $i, $this->image_dst_y - $i - 1, $c);
                             imageline($tmp, $i, $i, $i, $this->image_dst_y - $i - 1, $c);
                         } else {
                             imageline($tmp, $i, $i, $this->image_dst_x - $i - 1, $i, $c);
                             imageline($tmp, $this->image_dst_x - $nb + $i, $this->image_dst_y - $nb + $i, $this->image_dst_x - $nb + $i, $nb - $i, $c);
                             imageline($tmp, $this->image_dst_x - $nb + $i, $this->image_dst_y - $nb + $i, $nb - $i, $this->image_dst_y - $nb + $i, $c);
                             imageline($tmp, $i, $i, $i, $this->image_dst_y - $i - 1, $c);
                         }
                     }
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // add bevel border
                 if ($gd_version >= 2 && $this->image_bevel > 0) {
                     if (empty($this->image_bevel_color1)) {
                         $this->image_bevel_color1 = '#FFFFFF';
                     }
                     if (empty($this->image_bevel_color2)) {
                         $this->image_bevel_color2 = '#000000';
                     }
                     list($red1, $green1, $blue1) = $this->getcolors($this->image_bevel_color1);
                     list($red2, $green2, $blue2) = $this->getcolors($this->image_bevel_color2);
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y);
                     imagecopy($tmp, $image_dst, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y);
                     imagealphablending($tmp, true);
                     for ($i = 0; $i < $this->image_bevel; $i++) {
                         $alpha = round($i / $this->image_bevel * 127);
                         $c1 = imagecolorallocatealpha($tmp, $red1, $green1, $blue1, $alpha);
                         $c2 = imagecolorallocatealpha($tmp, $red2, $green2, $blue2, $alpha);
                         imageline($tmp, $i, $i, $this->image_dst_x - $i - 1, $i, $c1);
                         imageline($tmp, $this->image_dst_x - $i - 1, $this->image_dst_y - $i, $this->image_dst_x - $i - 1, $i, $c2);
                         imageline($tmp, $this->image_dst_x - $i - 1, $this->image_dst_y - $i - 1, $i, $this->image_dst_y - $i - 1, $c2);
                         imageline($tmp, $i, $i, $i, $this->image_dst_y - $i - 1, $c1);
                     }
                     // we transfert tmp into image_dst
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // add watermark image
                 if ($this->image_watermark != '' && file_exists($this->image_watermark)) {
                     $this->log .= '- add watermark<br />';
                     $this->image_watermark_position = strtolower($this->image_watermark_position);
                     $watermark_info = getimagesize($this->image_watermark);
                     $watermark_type = array_key_exists(2, $watermark_info) ? $watermark_info[2] : null;
                     // 1 = GIF, 2 = JPG, 3 = PNG
                     $watermark_checked = false;
                     if ($watermark_type == IMAGETYPE_GIF) {
                         if (!function_exists('imagecreatefromgif')) {
                             $this->error = $this->translate('watermark_no_create_support', array('GIF'));
                         } else {
                             $filter = @imagecreatefromgif($this->image_watermark);
                             if (!$filter) {
                                 $this->error = $this->translate('watermark_create_error', array('GIF'));
                             } else {
                                 $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;watermark source image is GIF<br />';
                                 $watermark_checked = true;
                             }
                         }
                     } else {
                         if ($watermark_type == IMAGETYPE_JPEG) {
                             if (!function_exists('imagecreatefromjpeg')) {
                                 $this->error = $this->translate('watermark_no_create_support', array('JPEG'));
                             } else {
                                 $filter = @imagecreatefromjpeg($this->image_watermark);
                                 if (!$filter) {
                                     $this->error = $this->translate('watermark_create_error', array('JPEG'));
                                 } else {
                                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;watermark source image is JPEG<br />';
                                     $watermark_checked = true;
                                 }
                             }
                         } else {
                             if ($watermark_type == IMAGETYPE_PNG) {
                                 if (!function_exists('imagecreatefrompng')) {
                                     $this->error = $this->translate('watermark_no_create_support', array('PNG'));
                                 } else {
                                     $filter = @imagecreatefrompng($this->image_watermark);
                                     if (!$filter) {
                                         $this->error = $this->translate('watermark_create_error', array('PNG'));
                                     } else {
                                         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;watermark source image is PNG<br />';
                                         $watermark_checked = true;
                                     }
                                 }
                             } else {
                                 if ($watermark_type == IMAGETYPE_BMP) {
                                     if (!method_exists($this, 'imagecreatefrombmp')) {
                                         $this->error = $this->translate('watermark_no_create_support', array('BMP'));
                                     } else {
                                         $filter = @$this->imagecreatefrombmp($this->image_watermark);
                                         if (!$filter) {
                                             $this->error = $this->translate('watermark_create_error', array('BMP'));
                                         } else {
                                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;watermark source image is BMP<br />';
                                             $watermark_checked = true;
                                         }
                                     }
                                 } else {
                                     $this->error = $this->translate('watermark_invalid');
                                 }
                             }
                         }
                     }
                     if ($watermark_checked) {
                         $watermark_dst_width = $watermark_src_width = imagesx($filter);
                         $watermark_dst_height = $watermark_src_height = imagesy($filter);
                         // if watermark is too large/tall, resize it first
                         if (!$this->image_watermark_no_zoom_out && ($watermark_dst_width > $this->image_dst_x || $watermark_dst_height > $this->image_dst_y) || !$this->image_watermark_no_zoom_in && $watermark_dst_width < $this->image_dst_x && $watermark_dst_height < $this->image_dst_y) {
                             $canvas_width = $this->image_dst_x - abs($this->image_watermark_x);
                             $canvas_height = $this->image_dst_y - abs($this->image_watermark_y);
                             if ($watermark_src_width / $canvas_width > $watermark_src_height / $canvas_height) {
                                 $watermark_dst_width = $canvas_width;
                                 $watermark_dst_height = intval($watermark_src_height * ($canvas_width / $watermark_src_width));
                             } else {
                                 $watermark_dst_height = $canvas_height;
                                 $watermark_dst_width = intval($watermark_src_width * ($canvas_height / $watermark_src_height));
                             }
                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;watermark resized from ' . $watermark_src_width . 'x' . $watermark_src_height . ' to ' . $watermark_dst_width . 'x' . $watermark_dst_height . '<br />';
                         }
                         // determine watermark position
                         $watermark_x = 0;
                         $watermark_y = 0;
                         if (is_numeric($this->image_watermark_x)) {
                             if ($this->image_watermark_x < 0) {
                                 $watermark_x = $this->image_dst_x - $watermark_dst_width + $this->image_watermark_x;
                             } else {
                                 $watermark_x = $this->image_watermark_x;
                             }
                         } else {
                             if (strpos($this->image_watermark_position, 'r') !== false) {
                                 $watermark_x = $this->image_dst_x - $watermark_dst_width;
                             } else {
                                 if (strpos($this->image_watermark_position, 'l') !== false) {
                                     $watermark_x = 0;
                                 } else {
                                     $watermark_x = ($this->image_dst_x - $watermark_dst_width) / 2;
                                 }
                             }
                         }
                         if (is_numeric($this->image_watermark_y)) {
                             if ($this->image_watermark_y < 0) {
                                 $watermark_y = $this->image_dst_y - $watermark_dst_height + $this->image_watermark_y;
                             } else {
                                 $watermark_y = $this->image_watermark_y;
                             }
                         } else {
                             if (strpos($this->image_watermark_position, 'b') !== false) {
                                 $watermark_y = $this->image_dst_y - $watermark_dst_height;
                             } else {
                                 if (strpos($this->image_watermark_position, 't') !== false) {
                                     $watermark_y = 0;
                                 } else {
                                     $watermark_y = ($this->image_dst_y - $watermark_dst_height) / 2;
                                 }
                             }
                         }
                         imagealphablending($image_dst, true);
                         imagecopyresampled($image_dst, $filter, $watermark_x, $watermark_y, 0, 0, $watermark_dst_width, $watermark_dst_height, $watermark_src_width, $watermark_src_height);
                     } else {
                         $this->error = $this->translate('watermark_invalid');
                     }
                 }
                 // add text
                 if (!empty($this->image_text)) {
                     $this->log .= '- add text<br />';
                     // calculate sizes in human readable format
                     $src_size = $this->file_src_size / 1024;
                     $src_size_mb = number_format($src_size / 1024, 1, ".", " ");
                     $src_size_kb = number_format($src_size, 1, ".", " ");
                     $src_size_human = $src_size > 1024 ? $src_size_mb . " MB" : $src_size_kb . " kb";
                     $this->image_text = str_replace(array('[src_name]', '[src_name_body]', '[src_name_ext]', '[src_pathname]', '[src_mime]', '[src_size]', '[src_size_kb]', '[src_size_mb]', '[src_size_human]', '[src_x]', '[src_y]', '[src_pixels]', '[src_type]', '[src_bits]', '[dst_path]', '[dst_name_body]', '[dst_name_ext]', '[dst_name]', '[dst_pathname]', '[dst_x]', '[dst_y]', '[date]', '[time]', '[host]', '[server]', '[ip]', '[gd_version]'), array($this->file_src_name, $this->file_src_name_body, $this->file_src_name_ext, $this->file_src_pathname, $this->file_src_mime, $this->file_src_size, $src_size_kb, $src_size_mb, $src_size_human, $this->image_src_x, $this->image_src_y, $this->image_src_pixels, $this->image_src_type, $this->image_src_bits, $this->file_dst_path, $this->file_dst_name_body, $this->file_dst_name_ext, $this->file_dst_name, $this->file_dst_pathname, $this->image_dst_x, $this->image_dst_y, date('Y-m-d'), date('H:i:s'), isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : 'n/a', isset($_SERVER['SERVER_NAME']) ? $_SERVER['SERVER_NAME'] : 'n/a', isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : 'n/a', $this->gdversion(true)), $this->image_text);
                     if (!is_numeric($this->image_text_padding)) {
                         $this->image_text_padding = 0;
                     }
                     if (!is_numeric($this->image_text_line_spacing)) {
                         $this->image_text_line_spacing = 0;
                     }
                     if (!is_numeric($this->image_text_padding_x)) {
                         $this->image_text_padding_x = $this->image_text_padding;
                     }
                     if (!is_numeric($this->image_text_padding_y)) {
                         $this->image_text_padding_y = $this->image_text_padding;
                     }
                     $this->image_text_position = strtolower($this->image_text_position);
                     $this->image_text_direction = strtolower($this->image_text_direction);
                     $this->image_text_alignment = strtolower($this->image_text_alignment);
                     // if the font is a string, we assume that we might want to load a font
                     if (!is_numeric($this->image_text_font) && strlen($this->image_text_font) > 4 && substr(strtolower($this->image_text_font), -4) == '.gdf') {
                         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;try to load font ' . $this->image_text_font . '... ';
                         if ($this->image_text_font = @imageloadfont($this->image_text_font)) {
                             $this->log .= 'success<br />';
                         } else {
                             $this->log .= 'error<br />';
                             $this->image_text_font = 5;
                         }
                     }
                     $text = explode("\n", $this->image_text);
                     $char_width = imagefontwidth($this->image_text_font);
                     $char_height = imagefontheight($this->image_text_font);
                     $text_height = 0;
                     $text_width = 0;
                     $line_height = 0;
                     $line_width = 0;
                     foreach ($text as $k => $v) {
                         if ($this->image_text_direction == 'v') {
                             $h = $char_width * strlen($v);
                             if ($h > $text_height) {
                                 $text_height = $h;
                             }
                             $line_width = $char_height;
                             $text_width += $line_width + ($k < sizeof($text) - 1 ? $this->image_text_line_spacing : 0);
                         } else {
                             $w = $char_width * strlen($v);
                             if ($w > $text_width) {
                                 $text_width = $w;
                             }
                             $line_height = $char_height;
                             $text_height += $line_height + ($k < sizeof($text) - 1 ? $this->image_text_line_spacing : 0);
                         }
                     }
                     $text_width += 2 * $this->image_text_padding_x;
                     $text_height += 2 * $this->image_text_padding_y;
                     $text_x = 0;
                     $text_y = 0;
                     if (is_numeric($this->image_text_x)) {
                         if ($this->image_text_x < 0) {
                             $text_x = $this->image_dst_x - $text_width + $this->image_text_x;
                         } else {
                             $text_x = $this->image_text_x;
                         }
                     } else {
                         if (strpos($this->image_text_position, 'r') !== false) {
                             $text_x = $this->image_dst_x - $text_width;
                         } else {
                             if (strpos($this->image_text_position, 'l') !== false) {
                                 $text_x = 0;
                             } else {
                                 $text_x = ($this->image_dst_x - $text_width) / 2;
                             }
                         }
                     }
                     if (is_numeric($this->image_text_y)) {
                         if ($this->image_text_y < 0) {
                             $text_y = $this->image_dst_y - $text_height + $this->image_text_y;
                         } else {
                             $text_y = $this->image_text_y;
                         }
                     } else {
                         if (strpos($this->image_text_position, 'b') !== false) {
                             $text_y = $this->image_dst_y - $text_height;
                         } else {
                             if (strpos($this->image_text_position, 't') !== false) {
                                 $text_y = 0;
                             } else {
                                 $text_y = ($this->image_dst_y - $text_height) / 2;
                             }
                         }
                     }
                     // add a background, maybe transparent
                     if (!empty($this->image_text_background)) {
                         list($red, $green, $blue) = $this->getcolors($this->image_text_background);
                         if ($gd_version >= 2 && is_numeric($this->image_text_background_opacity) && $this->image_text_background_opacity >= 0 && $this->image_text_background_opacity <= 100) {
                             $filter = imagecreatetruecolor($text_width, $text_height);
                             $background_color = imagecolorallocate($filter, $red, $green, $blue);
                             imagefilledrectangle($filter, 0, 0, $text_width, $text_height, $background_color);
                             $this->imagecopymergealpha($image_dst, $filter, $text_x, $text_y, 0, 0, $text_width, $text_height, $this->image_text_background_opacity);
                             imagedestroy($filter);
                         } else {
                             $background_color = imagecolorallocate($image_dst, $red, $green, $blue);
                             imagefilledrectangle($image_dst, $text_x, $text_y, $text_x + $text_width, $text_y + $text_height, $background_color);
                         }
                     }
                     $text_x += $this->image_text_padding_x;
                     $text_y += $this->image_text_padding_y;
                     $t_width = $text_width - 2 * $this->image_text_padding_x;
                     $t_height = $text_height - 2 * $this->image_text_padding_y;
                     list($red, $green, $blue) = $this->getcolors($this->image_text_color);
                     // add the text, maybe transparent
                     if ($gd_version >= 2 && is_numeric($this->image_text_opacity) && $this->image_text_opacity >= 0 && $this->image_text_opacity <= 100) {
                         if ($t_width < 0) {
                             $t_width = 0;
                         }
                         if ($t_height < 0) {
                             $t_height = 0;
                         }
                         $filter = $this->imagecreatenew($t_width, $t_height, false, true);
                         $text_color = imagecolorallocate($filter, $red, $green, $blue);
                         foreach ($text as $k => $v) {
                             if ($this->image_text_direction == 'v') {
                                 imagestringup($filter, $this->image_text_font, $k * ($line_width + ($k > 0 && $k < sizeof($text) ? $this->image_text_line_spacing : 0)), $text_height - 2 * $this->image_text_padding_y - ($this->image_text_alignment == 'l' ? 0 : ($t_height - strlen($v) * $char_width) / ($this->image_text_alignment == 'r' ? 1 : 2)), $v, $text_color);
                             } else {
                                 imagestring($filter, $this->image_text_font, $this->image_text_alignment == 'l' ? 0 : ($t_width - strlen($v) * $char_width) / ($this->image_text_alignment == 'r' ? 1 : 2), $k * ($line_height + ($k > 0 && $k < sizeof($text) ? $this->image_text_line_spacing : 0)), $v, $text_color);
                             }
                         }
                         $this->imagecopymergealpha($image_dst, $filter, $text_x, $text_y, 0, 0, $t_width, $t_height, $this->image_text_opacity);
                         imagedestroy($filter);
                     } else {
                         $text_color = imageColorAllocate($image_dst, $red, $green, $blue);
                         foreach ($text as $k => $v) {
                             if ($this->image_text_direction == 'v') {
                                 imagestringup($image_dst, $this->image_text_font, $text_x + $k * ($line_width + ($k > 0 && $k < sizeof($text) ? $this->image_text_line_spacing : 0)), $text_y + $text_height - 2 * $this->image_text_padding_y - ($this->image_text_alignment == 'l' ? 0 : ($t_height - strlen($v) * $char_width) / ($this->image_text_alignment == 'r' ? 1 : 2)), $v, $text_color);
                             } else {
                                 imagestring($image_dst, $this->image_text_font, $text_x + ($this->image_text_alignment == 'l' ? 0 : ($t_width - strlen($v) * $char_width) / ($this->image_text_alignment == 'r' ? 1 : 2)), $text_y + $k * ($line_height + ($k > 0 && $k < sizeof($text) ? $this->image_text_line_spacing : 0)), $v, $text_color);
                             }
                         }
                     }
                 }
                 // add a reflection
                 if ($this->image_reflection_height) {
                     $this->log .= '- add reflection : ' . $this->image_reflection_height . '<br />';
                     // we decode image_reflection_height, which can be a integer, a string in pixels or percentage
                     $image_reflection_height = $this->image_reflection_height;
                     if (strpos($image_reflection_height, '%') > 0) {
                         $image_reflection_height = $this->image_dst_y * str_replace('%', '', $image_reflection_height / 100);
                     }
                     if (strpos($image_reflection_height, 'px') > 0) {
                         $image_reflection_height = str_replace('px', '', $image_reflection_height);
                     }
                     $image_reflection_height = (int) $image_reflection_height;
                     if ($image_reflection_height > $this->image_dst_y) {
                         $image_reflection_height = $this->image_dst_y;
                     }
                     if (empty($this->image_reflection_opacity)) {
                         $this->image_reflection_opacity = 60;
                     }
                     // create the new destination image
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y + $image_reflection_height + $this->image_reflection_space, true);
                     $transparency = $this->image_reflection_opacity;
                     // copy the original image
                     imagecopy($tmp, $image_dst, 0, 0, 0, 0, $this->image_dst_x, $this->image_dst_y + ($this->image_reflection_space < 0 ? $this->image_reflection_space : 0));
                     // we have to make sure the extra bit is the right color, or transparent
                     if ($image_reflection_height + $this->image_reflection_space > 0) {
                         // use the background color if present
                         if (!empty($this->image_background_color)) {
                             list($red, $green, $blue) = $this->getcolors($this->image_background_color);
                             $fill = imagecolorallocate($tmp, $red, $green, $blue);
                         } else {
                             $fill = imagecolorallocatealpha($tmp, 0, 0, 0, 127);
                         }
                         // fill in from the edge of the extra bit
                         imagefill($tmp, round($this->image_dst_x / 2), $this->image_dst_y + $image_reflection_height + $this->image_reflection_space - 1, $fill);
                     }
                     // copy the reflection
                     for ($y = 0; $y < $image_reflection_height; $y++) {
                         for ($x = 0; $x < $this->image_dst_x; $x++) {
                             $pixel_b = imagecolorsforindex($tmp, imagecolorat($tmp, $x, $y + $this->image_dst_y + $this->image_reflection_space));
                             $pixel_o = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $this->image_dst_y - $y - 1 + ($this->image_reflection_space < 0 ? $this->image_reflection_space : 0)));
                             $alpha_o = 1 - $pixel_o['alpha'] / 127;
                             $alpha_b = 1 - $pixel_b['alpha'] / 127;
                             $opacity = $alpha_o * $transparency / 100;
                             if ($opacity > 0) {
                                 $red = round(($pixel_o['red'] * $opacity + $pixel_b['red'] * $alpha_b) / ($alpha_b + $opacity));
                                 $green = round(($pixel_o['green'] * $opacity + $pixel_b['green'] * $alpha_b) / ($alpha_b + $opacity));
                                 $blue = round(($pixel_o['blue'] * $opacity + $pixel_b['blue'] * $alpha_b) / ($alpha_b + $opacity));
                                 $alpha = $opacity + $alpha_b;
                                 if ($alpha > 1) {
                                     $alpha = 1;
                                 }
                                 $alpha = round((1 - $alpha) * 127);
                                 $color = imagecolorallocatealpha($tmp, $red, $green, $blue, $alpha);
                                 imagesetpixel($tmp, $x, $y + $this->image_dst_y + $this->image_reflection_space, $color);
                             }
                         }
                         if ($transparency > 0) {
                             $transparency = $transparency - $this->image_reflection_opacity / $image_reflection_height;
                         }
                     }
                     // copy the resulting image into the destination image
                     $this->image_dst_y = $this->image_dst_y + $image_reflection_height + $this->image_reflection_space;
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // change opacity
                 if ($gd_version >= 2 && is_numeric($this->image_opacity) && $this->image_opacity < 100) {
                     $this->log .= '- change opacity<br />';
                     // create the new destination image
                     $tmp = $this->imagecreatenew($this->image_dst_x, $this->image_dst_y, true);
                     for ($y = 0; $y < $this->image_dst_y; $y++) {
                         for ($x = 0; $x < $this->image_dst_x; $x++) {
                             $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                             $alpha = $pixel['alpha'] + round((127 - $pixel['alpha']) * (100 - $this->image_opacity) / 100);
                             if ($alpha > 127) {
                                 $alpha = 127;
                             }
                             if ($alpha > 0) {
                                 $color = imagecolorallocatealpha($tmp, $pixel['red'], $pixel['green'], $pixel['blue'], $alpha);
                                 imagesetpixel($tmp, $x, $y, $color);
                             }
                         }
                     }
                     // copy the resulting image into the destination image
                     $image_dst = $this->imagetransfer($tmp, $image_dst);
                 }
                 // reduce the JPEG image to a set desired size
                 if (is_numeric($this->jpeg_size) && $this->jpeg_size > 0 && ($this->image_convert == 'jpeg' || $this->image_convert == 'jpg')) {
                     // inspired by: JPEGReducer class version 1, 25 November 2004, Author: Huda M ElMatsani, justhuda at netscape dot net
                     $this->log .= '- JPEG desired file size : ' . $this->jpeg_size . '<br />';
                     // calculate size of each image. 75%, 50%, and 25% quality
                     ob_start();
                     imagejpeg($image_dst, null, 75);
                     $buffer = ob_get_contents();
                     ob_end_clean();
                     $size75 = strlen($buffer);
                     ob_start();
                     imagejpeg($image_dst, null, 50);
                     $buffer = ob_get_contents();
                     ob_end_clean();
                     $size50 = strlen($buffer);
                     ob_start();
                     imagejpeg($image_dst, null, 25);
                     $buffer = ob_get_contents();
                     ob_end_clean();
                     $size25 = strlen($buffer);
                     // make sure we won't divide by 0
                     if ($size50 == $size25) {
                         $size50++;
                     }
                     if ($size75 == $size50 || $size75 == $size25) {
                         $size75++;
                     }
                     // calculate gradient of size reduction by quality
                     $mgrad1 = 25 / ($size50 - $size25);
                     $mgrad2 = 25 / ($size75 - $size50);
                     $mgrad3 = 50 / ($size75 - $size25);
                     $mgrad = ($mgrad1 + $mgrad2 + $mgrad3) / 3;
                     // result of approx. quality factor for expected size
                     $q_factor = round($mgrad * ($this->jpeg_size - $size50) + 50);
                     if ($q_factor < 1) {
                         $this->jpeg_quality = 1;
                     } elseif ($q_factor > 100) {
                         $this->jpeg_quality = 100;
                     } else {
                         $this->jpeg_quality = $q_factor;
                     }
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;JPEG quality factor set to ' . $this->jpeg_quality . '<br />';
                 }
                 // converts image from true color, and fix transparency if needed
                 $this->log .= '- converting...<br />';
                 $this->image_dst_type = $this->image_convert;
                 switch ($this->image_convert) {
                     case 'gif':
                         // if the image is true color, we convert it to a palette
                         if (imageistruecolor($image_dst)) {
                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;true color to palette<br />';
                             // creates a black and white mask
                             $mask = array(array());
                             for ($x = 0; $x < $this->image_dst_x; $x++) {
                                 for ($y = 0; $y < $this->image_dst_y; $y++) {
                                     $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                     $mask[$x][$y] = $pixel['alpha'];
                                 }
                             }
                             list($red, $green, $blue) = $this->getcolors($this->image_default_color);
                             // first, we merge the image with the background color, so we know which colors we will have
                             for ($x = 0; $x < $this->image_dst_x; $x++) {
                                 for ($y = 0; $y < $this->image_dst_y; $y++) {
                                     if ($mask[$x][$y] > 0) {
                                         // we have some transparency. we combine the color with the default color
                                         $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                         $alpha = $mask[$x][$y] / 127;
                                         $pixel['red'] = round($pixel['red'] * (1 - $alpha) + $red * $alpha);
                                         $pixel['green'] = round($pixel['green'] * (1 - $alpha) + $green * $alpha);
                                         $pixel['blue'] = round($pixel['blue'] * (1 - $alpha) + $blue * $alpha);
                                         $color = imagecolorallocate($image_dst, $pixel['red'], $pixel['green'], $pixel['blue']);
                                         imagesetpixel($image_dst, $x, $y, $color);
                                     }
                                 }
                             }
                             // transforms the true color image into palette, with its merged default color
                             if (empty($this->image_background_color)) {
                                 imagetruecolortopalette($image_dst, true, 255);
                                 $transparency = imagecolorallocate($image_dst, 254, 1, 253);
                                 imagecolortransparent($image_dst, $transparency);
                                 // make the transparent areas transparent
                                 for ($x = 0; $x < $this->image_dst_x; $x++) {
                                     for ($y = 0; $y < $this->image_dst_y; $y++) {
                                         // we test wether we have enough opacity to justify keeping the color
                                         if ($mask[$x][$y] > 120) {
                                             imagesetpixel($image_dst, $x, $y, $transparency);
                                         }
                                     }
                                 }
                             }
                             unset($mask);
                         }
                         break;
                     case 'jpg':
                     case 'bmp':
                         // if the image doesn't support any transparency, then we merge it with the default color
                         $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;fills in transparency with default color<br />';
                         list($red, $green, $blue) = $this->getcolors($this->image_default_color);
                         $transparency = imagecolorallocate($image_dst, $red, $green, $blue);
                         // make the transaparent areas transparent
                         for ($x = 0; $x < $this->image_dst_x; $x++) {
                             for ($y = 0; $y < $this->image_dst_y; $y++) {
                                 // we test wether we have some transparency, in which case we will merge the colors
                                 if (imageistruecolor($image_dst)) {
                                     $rgba = imagecolorat($image_dst, $x, $y);
                                     $pixel = array('red' => $rgba >> 16 & 0xff, 'green' => $rgba >> 8 & 0xff, 'blue' => $rgba & 0xff, 'alpha' => ($rgba & 0x7f000000) >> 24);
                                 } else {
                                     $pixel = imagecolorsforindex($image_dst, imagecolorat($image_dst, $x, $y));
                                 }
                                 if ($pixel['alpha'] == 127) {
                                     // we have full transparency. we make the pixel transparent
                                     imagesetpixel($image_dst, $x, $y, $transparency);
                                 } else {
                                     if ($pixel['alpha'] > 0) {
                                         // we have some transparency. we combine the color with the default color
                                         $alpha = $pixel['alpha'] / 127;
                                         $pixel['red'] = round($pixel['red'] * (1 - $alpha) + $red * $alpha);
                                         $pixel['green'] = round($pixel['green'] * (1 - $alpha) + $green * $alpha);
                                         $pixel['blue'] = round($pixel['blue'] * (1 - $alpha) + $blue * $alpha);
                                         $color = imagecolorclosest($image_dst, $pixel['red'], $pixel['green'], $pixel['blue']);
                                         imagesetpixel($image_dst, $x, $y, $color);
                                     }
                                 }
                             }
                         }
                         break;
                     default:
                         break;
                 }
                 // interlace options
                 if ($this->image_interlace) {
                     imageinterlace($image_dst, true);
                 }
                 // outputs image
                 $this->log .= '- saving image...<br />';
                 switch ($this->image_convert) {
                     case 'jpeg':
                     case 'jpg':
                         if (!$return_mode) {
                             $result = @imagejpeg($image_dst, $this->file_dst_pathname, $this->jpeg_quality);
                         } else {
                             ob_start();
                             $result = @imagejpeg($image_dst, null, $this->jpeg_quality);
                             $return_content = ob_get_contents();
                             ob_end_clean();
                         }
                         if (!$result) {
                             $this->processed = false;
                             $this->error = $this->translate('file_create', array('JPEG'));
                         } else {
                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;JPEG image created<br />';
                         }
                         break;
                     case 'png':
                         imagealphablending($image_dst, false);
                         imagesavealpha($image_dst, true);
                         if (!$return_mode) {
                             if (is_numeric($this->png_compression) && version_compare(PHP_VERSION, '5.1.2') >= 0) {
                                 $result = @imagepng($image_dst, $this->file_dst_pathname, $this->png_compression);
                             } else {
                                 $result = @imagepng($image_dst, $this->file_dst_pathname);
                             }
                         } else {
                             ob_start();
                             if (is_numeric($this->png_compression) && version_compare(PHP_VERSION, '5.1.2') >= 0) {
                                 $result = @imagepng($image_dst, null, $this->png_compression);
                             } else {
                                 $result = @imagepng($image_dst);
                             }
                             $return_content = ob_get_contents();
                             ob_end_clean();
                         }
                         if (!$result) {
                             $this->processed = false;
                             $this->error = $this->translate('file_create', array('PNG'));
                         } else {
                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;PNG image created<br />';
                         }
                         break;
                     case 'gif':
                         if (!$return_mode) {
                             $result = @imagegif($image_dst, $this->file_dst_pathname);
                         } else {
                             ob_start();
                             $result = @imagegif($image_dst);
                             $return_content = ob_get_contents();
                             ob_end_clean();
                         }
                         if (!$result) {
                             $this->processed = false;
                             $this->error = $this->translate('file_create', array('GIF'));
                         } else {
                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;GIF image created<br />';
                         }
                         break;
                     case 'bmp':
                         if (!$return_mode) {
                             $result = $this->imagebmp($image_dst, $this->file_dst_pathname);
                         } else {
                             ob_start();
                             $result = $this->imagebmp($image_dst);
                             $return_content = ob_get_contents();
                             ob_end_clean();
                         }
                         if (!$result) {
                             $this->processed = false;
                             $this->error = $this->translate('file_create', array('BMP'));
                         } else {
                             $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;BMP image created<br />';
                         }
                         break;
                     default:
                         $this->processed = false;
                         $this->error = $this->translate('no_conversion_type');
                 }
                 if ($this->processed) {
                     if (is_resource($image_src)) {
                         imagedestroy($image_src);
                     }
                     if (is_resource($image_dst)) {
                         imagedestroy($image_dst);
                     }
                     $this->log .= '&nbsp;&nbsp;&nbsp;&nbsp;image objects destroyed<br />';
                 }
             }
         } else {
             $this->log .= '- no image processing wanted<br />';
             if (!$return_mode) {
                 // copy the file to its final destination. we don't use move_uploaded_file here
                 // if we happen to have open_basedir restrictions, it is a temp file that we copy, not the original uploaded file
                 if (!copy($this->file_src_pathname, $this->file_dst_pathname)) {
                     $this->processed = false;
                     $this->error = $this->translate('copy_failed');
                 }
             } else {
                 // returns the file, so that its content can be received by the caller
                 $return_content = @file_get_contents($this->file_src_pathname);
                 if ($return_content === FALSE) {
                     $this->processed = false;
                     $this->error = $this->translate('reading_failed');
                 }
             }
         }
     }
     if ($this->processed) {
         $this->log .= '- <b>process OK</b><br />';
     } else {
         $this->log .= '- <b>error</b>: ' . $this->error . '<br />';
     }
     // we reinit all the vars
     $this->init();
     // we may return the image content
     if ($return_mode) {
         return $return_content;
     }
 }
Пример #10
0
 public function createFrom($type = '', $source = '', $x = '', $y = '', $width = '', $height = '')
 {
     if (!is_string($type) || !is_string($source)) {
         return Error::set(lang('Error', 'stringParameter', '1.(type) & 2.(source)'));
     }
     $type = strtolower($type);
     switch ($type) {
         case 'gd2':
             $return = imagecreatefromgd2($source);
             break;
         case 'gd':
             $return = imagecreatefromgd($source);
             break;
         case 'gif':
             $return = imagecreatefromgif($source);
             break;
         case 'jpeg':
             $return = imagecreatefromjpeg($source);
             break;
         case 'png':
             $return = imagecreatefrompng($source);
             break;
         case 'string':
             $return = imagecreatefromstring($source);
             break;
         case 'wbmp':
             $return = imagecreatefromwbmp($source);
             break;
         case 'webp':
             $return = imagecreatefromwebp($source);
             break;
         case 'xbm':
             $return = imagecreatefromxbm($source);
             break;
         case 'xpm':
             $return = imagecreatefromxpm($source);
             break;
         case 'gd2p':
             $return = imagecreatefromgd2part($source, $x, $y, $width, $height);
     }
     return $return;
 }
Пример #11
0
<?php

chdir(dirname(__FILE__));
require_once './RIFF.php';
function webp_read_metadata($filename)
{
    return WebP::createFromFile($filename)->getMetadata();
}
$im = imagecreatefrompng('Lenna.png');
imagewebp($im, 'Lenna.webp', WEBP_DEFAULT_QUALITY, $difference);
var_dump($difference);
$webp = WebP::createFromFile('Lenna.webp');
$webp->setComment('Lenna');
$webp->setCopyright('PLAYBOY');
$webp->dumpToFile('Lenna2.webp');
print_r(webp_read_metadata('Lenna2.webp'));
$im = imagecreatefromwebp('Lenna2.webp');
imagejpeg($im, 'Lenna.jpg');
Пример #12
0
 protected function getImageResource($file, $type)
 {
     switch ($type) {
         case IMAGETYPE_GIF:
             $src_img = imagecreatefromgif($file);
             break;
         case IMAGETYPE_JPEG:
             $src_img = imagecreatefromjpeg($file);
             break;
         case IMAGETYPE_PNG:
             $src_img = imagecreatefrompng($file);
             break;
         case IMAGETYPE_WBMP:
             $src_img = imagecreatefromwebp($file);
     }
     return $src_img;
 }
Пример #13
0
function canvas_fetch_src($url_token)
{
    if ($url_token && ($url = Crush::$process->tokens->get($url_token))) {
        $file = $url->getAbsolutePath();
        // Testing the image availability and getting info.
        if ($info = @getimagesize($file)) {
            $image = null;
            // If image is available copy it.
            switch ($info['mime']) {
                case 'image/png':
                    $image = imagecreatefrompng($file);
                    break;
                case 'image/jpg':
                case 'image/jpeg':
                    $image = imagecreatefromjpeg($file);
                    break;
                case 'image/gif':
                    $image = imagecreatefromgif($file);
                    break;
                case 'image/webp':
                    $image = imagecreatefromwebp($file);
                    break;
            }
            if ($image) {
                return (object) array('file' => $file, 'info' => $info, 'width' => $info[0], 'height' => $info[1], 'image' => $image);
            }
        }
    }
    return false;
}
Пример #14
0
 /**
  * Resizes an image file
  * 
  * @param string $sourceFilename The image file to resize
  * @param string $destinationFilename The filename where the result image will be saved
  * @param array $options Resize options. You can resize the file by providing "width", "height" or both.
  * @throws \InvalidArgumentException
  * @throws \Exception
  * @return void No value is returned
  */
 public function resize($sourceFilename, $destinationFilename, $options = [])
 {
     if (!is_string($sourceFilename)) {
         throw new \InvalidArgumentException('The sourceFilename argument must be of type string');
     }
     $sourceFilename = realpath($sourceFilename);
     if ($sourceFilename === false) {
         throw new \InvalidArgumentException('The sourceFilename specified does not exist');
     }
     if (!is_string($destinationFilename)) {
         throw new \InvalidArgumentException('The destinationFilename argument must be of type string');
     }
     if (!is_array($options)) {
         throw new \InvalidArgumentException('The options argument must be of type array');
     }
     if (isset($options['width']) && (!is_int($options['width']) || $options['width'] < 1 || $options['width'] > 100000)) {
         throw new \InvalidArgumentException('The width value must be higher than 0 and lower than 100001');
     }
     if (isset($options['height']) && (!is_int($options['height']) || $options['height'] < 1 || $options['height'] > 100000)) {
         throw new \InvalidArgumentException('The height value must be higher than 0 and lower than 100001');
     }
     $outputType = null;
     $sourcePathInfo = pathinfo($sourceFilename);
     $destinationPathInfo = pathinfo($destinationFilename);
     if (isset($destinationPathInfo['extension'])) {
         $extension = $destinationPathInfo['extension'];
         if ($extension === 'png') {
             $outputType = 'png';
         } elseif ($extension === 'gif') {
             $outputType = 'gif';
         } elseif ($extension === 'jpg' || $extension === 'jpeg') {
             $outputType = 'jpg';
         } elseif ($extension === 'webp') {
             $outputType = 'webp';
         }
     }
     if ($outputType !== 'png' && $outputType !== 'gif' && $outputType !== 'jpg' && $outputType !== 'webp') {
         throw new \InvalidArgumentException('The output format is not valid');
     }
     try {
         if (isset($sourcePathInfo['extension']) && $sourcePathInfo['extension'] === 'webp') {
             $sourceImageSize = $this->getSize($sourceFilename);
             $sourceImageWidth = $sourceImageSize[0];
             $sourceImageHeight = $sourceImageSize[1];
             $sourceImageMimeType = 'image/webp';
         } else {
             $sourceImageInfo = getimagesize($sourceFilename);
             if (!is_array($sourceImageInfo)) {
                 throw new \InvalidArgumentException('Cannot get source image size');
             }
             $sourceImageWidth = $sourceImageInfo[0];
             $sourceImageHeight = $sourceImageInfo[1];
             $sourceImageMimeType = $sourceImageInfo['mime'];
         }
     } catch (\Exception $e) {
         throw new \InvalidArgumentException('Unknown error (' . $e->getMessage() . ')');
     }
     $width = isset($options['width']) ? $options['width'] : null;
     $height = isset($options['height']) ? $options['height'] : null;
     if ($width === null && $height === null) {
         $width = $sourceImageWidth;
         $height = $sourceImageHeight;
     } elseif ($width === null && $height !== null) {
         $width = (int) floor($sourceImageWidth / $sourceImageHeight * $height);
     } elseif ($height === null && $width !== null) {
         $height = (int) floor($sourceImageHeight / $sourceImageWidth * $width);
     }
     if ($sourceImageWidth === $width && $sourceImageHeight === $height) {
         copy($sourceFilename, $destinationFilename);
     } else {
         $sourceImage = null;
         if ($sourceImageMimeType === 'image/jpeg' && function_exists('imagecreatefromjpeg')) {
             $sourceImage = imagecreatefromjpeg($sourceFilename);
         } elseif ($sourceImageMimeType === 'image/png' && function_exists('imagecreatefrompng')) {
             $sourceImage = imagecreatefrompng($sourceFilename);
         } elseif ($sourceImageMimeType === 'image/gif' && function_exists('imagecreatefromgif')) {
             $sourceImage = imagecreatefromgif($sourceFilename);
         } elseif ($sourceImageMimeType === 'image/webp' && function_exists('imagecreatefromwebp')) {
             $sourceImage = imagecreatefromwebp($sourceFilename);
         }
         if (!$sourceImage) {
             throw new \InvalidArgumentException('Cannot read the source image');
         }
         $result = false;
         try {
             $resultImage = imagecreatetruecolor($width, $height);
             imagealphablending($resultImage, false);
             imagesavealpha($resultImage, true);
             imagefill($resultImage, 0, 0, imagecolorallocatealpha($resultImage, 0, 0, 0, 127));
             $widthRatio = $sourceImageWidth / $width;
             $heightRatio = $sourceImageHeight / $height;
             $resizedImageHeight = $height;
             $resizedImageWidth = $width;
             if ($widthRatio > $heightRatio) {
                 $resizedImageWidth = ceil($sourceImageWidth / $heightRatio);
             } else {
                 $resizedImageHeight = ceil($sourceImageHeight / $widthRatio);
             }
             $destinationX = -($resizedImageWidth - $width) / 2;
             $destinationY = -($resizedImageHeight - $height) / 2;
             if (imagecopyresampled($resultImage, $sourceImage, floor($destinationX), floor($destinationY), 0, 0, $resizedImageWidth, $resizedImageHeight, $sourceImageWidth, $sourceImageHeight)) {
                 if ($outputType == 'jpg') {
                     $result = imagejpeg($resultImage, $destinationFilename, 100);
                 } elseif ($outputType == 'png') {
                     $result = imagepng($resultImage, $destinationFilename, 9);
                 } elseif ($outputType == 'gif') {
                     $result = imagegif($resultImage, $destinationFilename);
                 } elseif ($outputType == 'webp') {
                     $result = imagewebp($resultImage, $destinationFilename);
                 }
             }
             imagedestroy($resultImage);
         } catch (\Exception $e) {
         }
         imagedestroy($sourceImage);
         if (!$result) {
             throw new \Exception('');
         }
     }
 }
Пример #15
0
 /**
  * See if we can create WEBP images.
  *
  * @throws Exception on missing support
  */
 private function imageCreateFromWEBP()
 {
     if ($this->gd->hasJPEGSupport() || $this->gd->hasPNGSupport()) {
         if (function_exists('imagecreatefromwebp')) {
             return imagecreatefromwebp($this->getImageFile());
         }
     }
     throw new \Exception('Missing WEBP support');
 }
Пример #16
0
<?php

$filename = dirname(__FILE__) . '/imagecreatefromwebp.webp';
if (!file_exists($filename)) {
    die("{$filename} does not exist. This test case needs a webp-image.");
}
$im = imagecreatefromwebp($filename);
// Convert it to a high quality png file
imagepng($im, "{$filename}.png", 9);
imagedestroy($im);
$fp = fopen("{$filename}.png", 'r');
// We want to be sure that there really is a png file
// with a reasonable file size.
echo floor(filesize($filename) / 100) * 100, "\n";
$data = fread($fp, 4);
// remove non-ASCII chars
echo preg_replace('/[[:^print:]]/', '?', $data);
unlink("{$filename}.png");
 public function download_image($image_url)
 {
     if (self::DEBUG) {
         error_log('$image_url is ' . $image_url . "\n", 3, 'f:/debug.txt');
     }
     $encoding = $this->get_header($image_url, 'Content-Encoding');
     $file = '';
     $this->get_image_size($image_url, $encoding);
     if (!empty($this->width) && $this->width < $this->minimum_picture_size['width'] || !empty($this->height) && $this->height < $this->minimum_picture_size['height']) {
         return self::TOO_SMALL;
     }
     if (self::DEBUG) {
         error_log('$image_url is ' . $image_url . "\n", 3, 'f:/debug.txt');
     }
     if (function_exists('file_get_contents')) {
         $arrContextOptions = array("ssl" => array("verify_peer" => false, "verify_peer_name" => false));
         if ($this->proxy_enabled == "yes") {
             $arrContextOptions['http'] = array('timout' => $this->proxy_timeout, 'proxy' => $this->proxy_address, 'request_fulluri' => True);
         }
         $context = stream_context_create($arrContextOptions);
         $file = @file_get_contents($image_url, null, $context);
         if ($encoding == 'gzip' && function_exists('gzdecode')) {
             $file = gzdecode($file);
         }
     }
     if (self::DEBUG) {
         error_log('file_get_contents is ' . $file . "\n", 3, 'f:/debug.txt');
     }
     if (!$file && function_exists('curl_init')) {
         $ch = curl_init();
         curl_setopt($ch, CURLOPT_URL, $image_url);
         if ($this->proxy_enabled == "yes") {
             curl_setopt($ch, CURLOPT_TIMEOUT, $this->proxy_timeout);
             curl_setopt($ch, CURLOPT_PROXY, $this->proxy_address);
         }
         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
         curl_setopt($ch, CURLOPT_HEADER, 0);
         $file = curl_exec($ch);
         if ($encoding == 'gzip' && function_exists('gzdecode')) {
             $file = gzdecode($file);
         }
         if (self::DEBUG) {
             error_log('curl_init is ' . $file . "\n", 3, 'f:/debug.txt');
         }
     }
     if (in_array($this->type, $this->allowd_image_types)) {
         $img = @imagecreatefromstring($file);
         if (!$img && function_exists('fsockopen')) {
             $type = $this->get_header($image_url, 'Content-Type');
             if ($type && in_array($type, $this->allowed_image_types)) {
                 $type = substr($type, 6);
                 $img = call_user_func("imagecreatefrom{$type}", $image_url);
                 ob_start();
                 call_user_func("image{$type}", $img);
                 $file = ob_get_contents();
                 ob_end_clean();
                 imagedestroy($img);
                 if ($encoding == 'gzip' && function_exists('gzdecode')) {
                     $file = gzdecode($file);
                 }
             } else {
                 $file = '';
             }
             if (self::DEBUG) {
                 error_log('fsockopen is' . $file . "\n", 3, 'f:/debug.txt');
             }
         }
     }
     if (!empty($file) && $this->type == 'image/x-ms-bmp') {
         $this->temp = tempnam(sys_get_temp_dir(), 'QQWorld');
         $temp = fopen($this->temp, "w");
         fwrite($temp, $file);
         $img = imagecreatefrombmp($this->temp);
         if ($img) {
             ob_start();
             ImageJpeg($img, null);
             $file = ob_get_contents();
             ob_end_clean();
             $this->type = 'image/jpeg';
             fclose($temp);
             imagedestroy($img);
         } else {
             $file = '';
         }
         unlink($this->temp);
     }
     if (!empty($file) && $this->type == 'image/webp' && function_exists('imagecreatefromwebp')) {
         $img = imagecreatefromwebp($image_url);
         if ($img) {
             ob_start();
             ImageJpeg($img, null);
             $file = ob_get_contents();
             ob_end_clean();
             list($this->width, $this->height) = getimagesizefromstring($file);
             $this->type = 'image/jpeg';
             imagedestroy($img);
         } else {
             $file = '';
         }
     }
     return $file;
 }
Пример #18
0
 public function createFrom(string $type, string $source, array $settings = NULL)
 {
     $type = strtolower($type);
     switch ($type) {
         case 'gd2':
             $return = imagecreatefromgd2($source);
             break;
         case 'gd':
             $return = imagecreatefromgd($source);
             break;
         case 'gif':
             $return = imagecreatefromgif($source);
             break;
         case 'jpeg':
             $return = imagecreatefromjpeg($source);
             break;
         case 'png':
             $return = imagecreatefrompng($source);
             break;
         case 'string':
             $return = imagecreatefromstring($source);
             break;
         case 'wbmp':
             $return = imagecreatefromwbmp($source);
             break;
         case 'webp':
             $return = imagecreatefromwebp($source);
             break;
         case 'xbm':
             $return = imagecreatefromxbm($source);
             break;
         case 'xpm':
             $return = imagecreatefromxpm($source);
             break;
         case 'gd2p':
             $return = imagecreatefromgd2part($source, isset($settings['x']) ? $settings['x'] : NULL, isset($settings['y']) ? $settings['y'] : NULL, isset($settings['width']) ? $settings['width'] : NULL, isset($settings['height']) ? $settings['height'] : NULL);
     }
     return $return;
 }
Пример #19
0
 public function load($uri)
 {
     return @imagecreatefromwebp($uri);
 }
Пример #20
0
    public function resizeImage($output, $max_width = null, $max_height = null)
    {
        /***
         * Resize an image to parameters.
         *
         * @param string $output The path where the output will be
         *   saved.
         * @param int $max_width The maximum width of the resize, in
         *   pixels (aspect ratio will be maintained)
         * @param int $max_height The maximum height of the resize, in
         *   pixels (aspect ratio will be maintained)
         *
         * @return array An array containing:
         *  status: boolean
         *  error: Explanation (only if error)
         *  image_file: Original path (only if error)
         *  ouput: Path to resized image
         *  dimensions: Human-friendly new dimensions
         ***/
        if (!is_numeric($max_height)) {
            $max_height = 1000;
        }
        if (!is_numeric($max_width)) {
            $max_width = 2000;
        }
        if (function_exists(get_magic_quotes_gpc) && get_magic_quotes_gpc()) {
            $image = stripslashes($this->img);
        } else {
            $image = $this->img;
        }

        if (strrchr($image, '/')) {
            $filename = substr(strrchr($image, '/'), 1); # remove folder references
        } else {
            $filename = $image;
        }

        if (!file_exists($image)) {
            return array('status' => false,'error' => 'File does not exist','image_path' => $image);
        }

        $size = getimagesize($image);
        $width = $size[0];
        $height = $size[1];
        if ($width == 0) {
            return array('status' => false, 'error' => 'Unable to compute image dimensions','image_path' => $image);
        }
        # get the ratio needed
        $x_ratio = $max_width / $width;
        $y_ratio = $max_height / $height;

        # if image already meets criteria, load current values in
        # if not, use ratios to load new size info
        if (($width <= $max_width) && ($height <= $max_height)) {
            $tn_width = $width;
            $tn_height = $height;
        } elseif (($x_ratio * $height) < $max_height) {
            $tn_height = ceil($x_ratio * $height);
            $tn_width = $max_width;
        } else {
            $tn_width = ceil($y_ratio * $width);
            $tn_height = $max_height;
        }

        $resized = 'cache/'.$tn_width.'x'.$tn_height.'-'.$filename;
        $imageModified = @filemtime($image);
        $thumbModified = @filemtime($resized);

        # read image
        $ext = strtolower(substr(strrchr($image, '.'), 1)); # get the file extension
        switch ($ext) {
        case 'jpg':     # jpg
            $src = imagecreatefromjpeg($image) or self::notfound();
            break;
        case 'png':     # png
            $src = imagecreatefrompng($image) or self::notfound();
            break;
        case 'gif':     # gif
            $src = imagecreatefromgif($image) or self::notfound();
            break;
        case 'bmp':     # bmp
            $src = imagecreatefromwbmp($image) or self::notfound();
            break;
        case 'webp':     # webp
            $src = imagecreatefromwebp($image) or self::notfound();
            break;
        default:
            self::notfound();
        }

        # set up canvas
        $dst = imagecreatetruecolor($tn_width, $tn_height);

        imageantialias($dst, true);

        # copy resized image to new canvas
        imagecopyresampled($dst, $src, 0, 0, 0, 0, $tn_width, $tn_height, $width, $height);

        # send the header and new image
        if ($ext == 'jpg') {
            $status = imagejpeg($dst, $output, 75);
        } elseif ($ext == 'png') {
            $status = imagepng($dst, $output, 9);
        } elseif ($ext == 'gif') {
            $status = imagegif($dst, $output);
        } elseif ($ext == 'bmp') {
            $status = imagewbmp($dst, $output);
        } elseif ($ext == 'webp') {
            $status = imagewebp($dst, $output);
        } else {
            return array('status' => false,'error' => 'Illegal extension','image_path' => $image, 'extension' => $ext);
        }

        # clear out the resources
        imagedestroy($src);
        imagedestroy($dst);

        return array('status' => $status, 'output' => $output, 'output_size' => "$tn_width X $tn_height");
    }