709 lines
25 KiB
PHP
709 lines
25 KiB
PHP
<?php
|
|
|
|
|
|
namespace Nextend\Framework\Image;
|
|
|
|
|
|
use Exception;
|
|
use Nextend\Framework\Cache\CacheImage;
|
|
use Nextend\Framework\Filesystem\Filesystem;
|
|
use Nextend\Framework\Misc\Base64;
|
|
use Nextend\Framework\Parser\Color;
|
|
use Nextend\Framework\ResourceTranslator\ResourceTranslator;
|
|
use Nextend\Framework\Url\Url;
|
|
|
|
class ImageEdit {
|
|
|
|
public static function resizeImage($group, $imageUrlOrPath, $targetWidth, $targetHeight, $lazy = false, $mode = 'cover', $backgroundColor = false, $resizeRemote = false, $quality = 100, $optimize = false, $x = 50, $y = 50) {
|
|
|
|
if (strpos($imageUrlOrPath, Filesystem::getBasePath()) === 0) {
|
|
$imageUrl = Url::pathToUri($imageUrlOrPath);
|
|
} else {
|
|
$imageUrl = ResourceTranslator::toUrl(ResourceTranslator::pathToResource($imageUrlOrPath));
|
|
}
|
|
|
|
if (!extension_loaded('gd') || $targetWidth <= 0 || $targetHeight <= 0) {
|
|
return $imageUrl;
|
|
}
|
|
|
|
$quality = max(0, min(100, $quality));
|
|
$originalImageUrl = $imageUrl;
|
|
|
|
if (substr($imageUrl, 0, 2) == '//') {
|
|
$imageUrl = parse_url(Url::getFullUri(), PHP_URL_SCHEME) . ':' . $imageUrl;
|
|
}
|
|
|
|
$imageUrl = Url::relativetoabsolute($imageUrl);
|
|
$imagePath = Filesystem::absoluteURLToPath($imageUrl);
|
|
|
|
$cache = new CacheImage($group);
|
|
if ($lazy) {
|
|
$cache->setLazy(true);
|
|
}
|
|
|
|
if ($imagePath == $imageUrl) {
|
|
// The image is not local
|
|
if (!$resizeRemote) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
$pathInfo = pathinfo(parse_url($imageUrl, PHP_URL_PATH));
|
|
$extension = false;
|
|
if (isset($pathInfo['extension'])) {
|
|
$extension = self::validateGDExtension($pathInfo['extension']);
|
|
}
|
|
|
|
$extension = self::checkMetaExtension($originalImageUrl, $extension);
|
|
|
|
if (!$extension) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
if (strtolower($extension) === 'webp' && !function_exists('imagecreatefromwebp')) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
$resizedPath = $cache->makeCache($extension, array(
|
|
self::class,
|
|
'_resizeRemoteImage'
|
|
), array(
|
|
$extension,
|
|
$imageUrl,
|
|
$targetWidth,
|
|
$targetHeight,
|
|
$mode,
|
|
$backgroundColor,
|
|
$quality,
|
|
$optimize,
|
|
$x,
|
|
$y
|
|
));
|
|
|
|
if (substr($resizedPath, 0, 5) == 'http:' || substr($resizedPath, 0, 6) == 'https:') {
|
|
return $resizedPath;
|
|
}
|
|
|
|
if ($resizedPath === $originalImageUrl) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
return Filesystem::pathToAbsoluteURL($resizedPath);
|
|
|
|
} else {
|
|
$extension = false;
|
|
$imageType = @self::exif_imagetype($imagePath);
|
|
switch ($imageType) {
|
|
case IMAGETYPE_JPEG:
|
|
$extension = 'jpg';
|
|
break;
|
|
case IMAGETYPE_PNG:
|
|
if (self::isPNG8($imagePath)) {
|
|
// GD cannot resize palette PNG so we return the original image
|
|
return $originalImageUrl;
|
|
}
|
|
$extension = 'png';
|
|
break;
|
|
case IMAGETYPE_WEBP:
|
|
if (!function_exists('imagecreatefromwebp')) {
|
|
return $originalImageUrl;
|
|
}
|
|
$extension = 'webp';
|
|
break;
|
|
}
|
|
if (!$extension) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
return Filesystem::pathToAbsoluteURL($cache->makeCache($extension, array(
|
|
self::class,
|
|
'_resizeImage'
|
|
), array(
|
|
$extension,
|
|
$imagePath,
|
|
$targetWidth,
|
|
$targetHeight,
|
|
$mode,
|
|
$backgroundColor,
|
|
$quality,
|
|
$optimize,
|
|
$x,
|
|
$y
|
|
)));
|
|
}
|
|
}
|
|
|
|
public static function _resizeRemoteImage($targetFile, $extension, $imageUrl, $targetWidth, $targetHeight, $mode, $backgroundColor, $quality, $optimize, $x, $y) {
|
|
return self::_resizeImage($targetFile, $extension, $imageUrl, $targetWidth, $targetHeight, $mode, $backgroundColor, $quality, $optimize, $x, $y);
|
|
}
|
|
|
|
public static function _resizeImage($targetFile, $extension, $imagePath, $targetWidth, $targetHeight, $mode, $backgroundColor, $quality = 100, $optimize = false, $x = 50, $y = 50) {
|
|
$targetDir = dirname($targetFile);
|
|
|
|
$rotated = false;
|
|
|
|
if ($extension == 'png') {
|
|
$image = @imagecreatefrompng($imagePath);
|
|
} else if ($extension == 'jpg') {
|
|
$image = @imagecreatefromjpeg($imagePath);
|
|
if (function_exists("exif_read_data")) {
|
|
$exif = @exif_read_data($imagePath);
|
|
|
|
$rotated = self::getOrientation($exif, $image);
|
|
if ($rotated) {
|
|
imagedestroy($image);
|
|
$image = $rotated;
|
|
}
|
|
}
|
|
} else if ($extension == 'webp') {
|
|
//@TODO: should we need to care about rotation?
|
|
$image = @imagecreatefromwebp($imagePath);
|
|
}
|
|
|
|
if (isset($image) && $image) {
|
|
$originalWidth = imagesx($image);
|
|
$originalHeight = imagesy($image);
|
|
|
|
if ($optimize) {
|
|
if ($originalWidth <= $targetWidth || $originalHeight <= $targetHeight) {
|
|
if (!Filesystem::existsFolder($targetDir)) {
|
|
Filesystem::createFolder($targetDir);
|
|
}
|
|
if ($extension == 'png') {
|
|
imagesavealpha($image, true);
|
|
imagealphablending($image, false);
|
|
imagepng($image, $targetFile);
|
|
} else if ($extension == 'jpg') {
|
|
imagejpeg($image, $targetFile, $quality);
|
|
} else if ($extension == 'webp') {
|
|
imagesavealpha($image, true);
|
|
imagealphablending($image, false);
|
|
imagewebp($image, $targetFile, $quality);
|
|
}
|
|
imagedestroy($image);
|
|
|
|
return true;
|
|
}
|
|
|
|
if ($originalWidth / $targetWidth > $originalHeight / $targetHeight) {
|
|
$targetWidth = round($originalWidth / ($originalHeight / $targetHeight));
|
|
} else {
|
|
$targetHeight = round($originalHeight / ($originalWidth / $targetWidth));
|
|
}
|
|
}
|
|
if ($rotated || $originalWidth != $targetWidth || $originalHeight != $targetHeight) {
|
|
$newImage = imagecreatetruecolor($targetWidth, $targetHeight);
|
|
if ($extension == 'png' || $extension == 'webp') {
|
|
imagesavealpha($newImage, true);
|
|
imagealphablending($newImage, false);
|
|
$transparent = imagecolorallocatealpha($newImage, 255, 255, 255, 127);
|
|
imagefilledrectangle($image, 0, 0, $targetWidth, $targetHeight, $transparent);
|
|
} else if ($extension == 'jpg' && $backgroundColor) {
|
|
$rgb = Color::hex2rgb($backgroundColor);
|
|
$background = imagecolorallocate($newImage, $rgb[0], $rgb[1], $rgb[2]);
|
|
imagefilledrectangle($newImage, 0, 0, $targetWidth, $targetHeight, $background);
|
|
}
|
|
|
|
list($dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) = self::imageMode($targetWidth, $targetHeight, $originalWidth, $originalHeight, $mode, $x, $y);
|
|
imagecopyresampled($newImage, $image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h);
|
|
imagedestroy($image);
|
|
|
|
} else {
|
|
$newImage = $image;
|
|
}
|
|
|
|
if (!Filesystem::existsFolder($targetDir)) {
|
|
Filesystem::createFolder($targetDir);
|
|
}
|
|
if ($extension == 'png') {
|
|
imagepng($newImage, $targetFile);
|
|
} else if ($extension == 'jpg') {
|
|
imagejpeg($newImage, $targetFile, $quality);
|
|
} else if ($extension == 'webp') {
|
|
imagewebp($newImage, $targetFile, $quality);
|
|
}
|
|
imagedestroy($newImage);
|
|
|
|
return true;
|
|
}
|
|
|
|
throw new Exception('Unable to resize image: ' . $imagePath);
|
|
}
|
|
|
|
public static function scaleImage($group, $imageUrlOrPath, $scale = 1, $resizeRemote = false, $quality = 100) {
|
|
|
|
|
|
if (strpos($imageUrlOrPath, Filesystem::getBasePath()) === 0) {
|
|
$imageUrl = Url::pathToUri($imageUrlOrPath);
|
|
} else {
|
|
$imageUrl = ResourceTranslator::toUrl($imageUrlOrPath);
|
|
}
|
|
|
|
if (!extension_loaded('gd') || $scale <= 0) {
|
|
return $imageUrl;
|
|
}
|
|
|
|
$quality = max(0, min(100, $quality));
|
|
$originalImageUrl = $imageUrl;
|
|
|
|
if (substr($imageUrl, 0, 2) == '//') {
|
|
$imageUrl = parse_url(Url::getFullUri(), PHP_URL_SCHEME) . ':' . $imageUrl;
|
|
}
|
|
|
|
$imageUrl = Url::relativetoabsolute($imageUrl);
|
|
$imagePath = Filesystem::absoluteURLToPath($imageUrl);
|
|
|
|
$cache = new CacheImage($group);
|
|
if ($imagePath == $imageUrl) {
|
|
// The image is not local
|
|
if (!$resizeRemote) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
$pathInfo = pathinfo(parse_url($imageUrl, PHP_URL_PATH));
|
|
$extension = false;
|
|
if (isset($pathInfo['extension'])) {
|
|
$extension = self::validateGDExtension($pathInfo['extension']);
|
|
}
|
|
|
|
$extension = self::checkMetaExtension($imageUrl, $extension);
|
|
|
|
if (!$extension) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
if (strtolower($extension) === 'webp' && !function_exists('imagecreatefromwebp')) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
return ResourceTranslator::urlToResource(Filesystem::pathToAbsoluteURL($cache->makeCache($extension, array(
|
|
self::class,
|
|
'_scaleRemoteImage'
|
|
), array(
|
|
$extension,
|
|
$imageUrl,
|
|
$scale,
|
|
$quality
|
|
))));
|
|
|
|
} else {
|
|
$extension = false;
|
|
$imageType = @self::exif_imagetype($imagePath);
|
|
switch ($imageType) {
|
|
case IMAGETYPE_JPEG:
|
|
$extension = 'jpg';
|
|
break;
|
|
case IMAGETYPE_PNG:
|
|
if (self::isPNG8($imagePath)) {
|
|
// GD cannot resize palette PNG so we return the original image
|
|
return $originalImageUrl;
|
|
}
|
|
$extension = 'png';
|
|
break;
|
|
case IMAGETYPE_WEBP:
|
|
if (!function_exists('imagecreatefromwebp')) {
|
|
return $originalImageUrl;
|
|
}
|
|
$extension = 'webp';
|
|
break;
|
|
}
|
|
if (!$extension) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
return ResourceTranslator::urlToResource(Filesystem::pathToAbsoluteURL($cache->makeCache($extension, array(
|
|
self::class,
|
|
'_scaleImage'
|
|
), array(
|
|
$extension,
|
|
$imagePath,
|
|
$scale,
|
|
$quality
|
|
))));
|
|
}
|
|
}
|
|
|
|
public static function _scaleRemoteImage($targetFile, $extension, $imageUrl, $scale, $quality) {
|
|
return self::_scaleImage($targetFile, $extension, $imageUrl, $scale, $quality);
|
|
}
|
|
|
|
public static function _scaleImage($targetFile, $extension, $imagePath, $scale, $quality = 100) {
|
|
$targetDir = dirname($targetFile);
|
|
|
|
$image = false;
|
|
|
|
if ($extension == 'png') {
|
|
$image = @imagecreatefrompng($imagePath);
|
|
} else if ($extension == 'jpg') {
|
|
$image = @imagecreatefromjpeg($imagePath);
|
|
if (function_exists("exif_read_data")) {
|
|
$exif = @exif_read_data($imagePath);
|
|
|
|
$rotated = self::getOrientation($exif, $image);
|
|
if ($rotated) {
|
|
imagedestroy($image);
|
|
$image = $rotated;
|
|
}
|
|
}
|
|
} else if ($extension == 'webp') {
|
|
//@TODO: should we need to care about rotation?
|
|
$image = @imagecreatefromwebp($imagePath);
|
|
}
|
|
|
|
if ($image) {
|
|
$originalWidth = imagesx($image);
|
|
$originalHeight = imagesy($image);
|
|
$targetWidth = $originalWidth * $scale;
|
|
$targetHeight = $originalHeight * $scale;
|
|
if ((isset($rotated) && $rotated) || $originalWidth != $targetWidth || $originalHeight != $targetHeight) {
|
|
$newImage = imagecreatetruecolor($targetWidth, $targetHeight);
|
|
if ($extension == 'png' || $extension == 'webp') {
|
|
imagesavealpha($newImage, true);
|
|
imagealphablending($newImage, false);
|
|
$transparent = imagecolorallocatealpha($newImage, 255, 255, 255, 127);
|
|
imagefilledrectangle($image, 0, 0, $targetWidth, $targetHeight, $transparent);
|
|
}
|
|
|
|
list($dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) = self::imageMode($targetWidth, $targetHeight, $originalWidth, $originalHeight);
|
|
imagecopyresampled($newImage, $image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h);
|
|
imagedestroy($image);
|
|
|
|
} else {
|
|
$newImage = $image;
|
|
}
|
|
|
|
if (!Filesystem::existsFolder($targetDir)) {
|
|
Filesystem::createFolder($targetDir);
|
|
}
|
|
if ($extension == 'png') {
|
|
imagepng($newImage, $targetFile);
|
|
} else if ($extension == 'jpg') {
|
|
imagejpeg($newImage, $targetFile, $quality);
|
|
} else if ($extension == 'webp') {
|
|
imagewebp($newImage, $targetFile, $quality);
|
|
}
|
|
imagedestroy($newImage);
|
|
|
|
return true;
|
|
}
|
|
|
|
throw new Exception('Unable to scale image: ' . $imagePath);
|
|
}
|
|
|
|
private static function getOrientation($exif, $image) {
|
|
if ($exif && !empty($exif['Orientation'])) {
|
|
$rotated = false;
|
|
switch ($exif['Orientation']) {
|
|
case 3:
|
|
$rotated = imagerotate($image, 180, 0);
|
|
break;
|
|
|
|
case 6:
|
|
$rotated = imagerotate($image, -90, 0);
|
|
break;
|
|
|
|
case 8:
|
|
$rotated = imagerotate($image, 90, 0);
|
|
break;
|
|
}
|
|
|
|
return $rotated;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static function imageMode($width, $height, $originalWidth, $OriginalHeight, $mode = 'cover', $x = 50, $y = 50) {
|
|
$dst_x = 0;
|
|
$dst_y = 0;
|
|
$src_x = 0;
|
|
$src_y = 0;
|
|
$dst_w = $width;
|
|
$dst_h = $height;
|
|
$src_w = $originalWidth;
|
|
$src_h = $OriginalHeight;
|
|
$horizontalRatio = $width / $originalWidth;
|
|
$verticalRatio = $height / $OriginalHeight;
|
|
|
|
if ($horizontalRatio > $verticalRatio) {
|
|
$new_h = round($horizontalRatio * $OriginalHeight);
|
|
$dst_y = round(($height - $new_h) / 2 * $y / 50);
|
|
$dst_h = $new_h;
|
|
} else {
|
|
$new_w = round($verticalRatio * $originalWidth);
|
|
$dst_x = round(($width - $new_w) / 2 * $x / 50);
|
|
$dst_w = $new_w;
|
|
}
|
|
|
|
return array(
|
|
$dst_x,
|
|
$dst_y,
|
|
$src_x,
|
|
$src_y,
|
|
$dst_w,
|
|
$dst_h,
|
|
$src_w,
|
|
$src_h
|
|
);
|
|
}
|
|
|
|
private static function validateGDExtension($extension) {
|
|
static $validExtensions = array(
|
|
'png' => 'png',
|
|
'jpg' => 'jpg',
|
|
'jpeg' => 'jpg',
|
|
'gif' => 'gif',
|
|
'webp' => 'webp',
|
|
'svg' => 'svg'
|
|
);
|
|
$extension = strtolower($extension);
|
|
if (isset($validExtensions[$extension])) {
|
|
return $validExtensions[$extension];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static function validateExtension($extension) {
|
|
static $validExtensions = array(
|
|
'png' => 'png',
|
|
'jpg' => 'jpg',
|
|
'jpeg' => 'jpg',
|
|
'gif' => 'gif',
|
|
'webp' => 'webp',
|
|
'svg' => 'svg'
|
|
);
|
|
$extension = strtolower($extension);
|
|
if (isset($validExtensions[$extension])) {
|
|
return $validExtensions[$extension];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static function base64Transparent() {
|
|
return 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
|
|
}
|
|
|
|
public static function base64($imagePath, $image) {
|
|
$pathInfo = pathinfo(parse_url($imagePath, PHP_URL_PATH));
|
|
$extension = self::validateExtension($pathInfo['extension']);
|
|
if ($extension) {
|
|
return 'data:image/' . $extension . ';base64,' . Base64::encode(Filesystem::readFile($imagePath));
|
|
}
|
|
|
|
return ResourceTranslator::toUrl($image);
|
|
}
|
|
|
|
public static function exif_imagetype($filename) {
|
|
if (!function_exists('exif_imagetype')) {
|
|
if ((list($width, $height, $type, $attr) = getimagesize($filename)) !== false) {
|
|
return $type;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return exif_imagetype($filename);
|
|
}
|
|
|
|
public static function isPNG8($path) {
|
|
$fp = fopen($path, 'r');
|
|
fseek($fp, 25);
|
|
$data = fgets($fp, 2);
|
|
fclose($fp);
|
|
if (ord($data) == 3) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static function scaleImageWebp($group, $imageUrlOrPath, $options) {
|
|
|
|
$options = array_merge(array(
|
|
'mode' => 'scale',
|
|
'scale' => 1,
|
|
'quality' => 100,
|
|
'remote' => false
|
|
), $options);
|
|
|
|
if (strpos($imageUrlOrPath, Filesystem::getBasePath()) === 0) {
|
|
$imageUrl = Url::pathToUri($imageUrlOrPath);
|
|
} else {
|
|
$imageUrl = ResourceTranslator::toUrl($imageUrlOrPath);
|
|
}
|
|
|
|
if (!extension_loaded('gd') || $options['mode'] === 'scale' && $options['scale'] <= 0) {
|
|
return Filesystem::pathToAbsoluteURL($imageUrl);
|
|
}
|
|
|
|
$options['quality'] = max(0, min(100, $options['quality']));
|
|
$originalImageUrl = $imageUrl;
|
|
|
|
|
|
if (substr($imageUrl, 0, 2) == '//') {
|
|
$imageUrl = parse_url(Url::getFullUri(), PHP_URL_SCHEME) . ':' . $imageUrl;
|
|
}
|
|
|
|
$imageUrl = Url::relativetoabsolute($imageUrl);
|
|
$imagePath = Filesystem::absoluteURLToPath($imageUrl);
|
|
|
|
$cache = new CacheImage($group);
|
|
if ($imagePath == $imageUrl) {
|
|
// The image is not local
|
|
if (!$options['remote']) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
$pathInfo = pathinfo(parse_url($imageUrl, PHP_URL_PATH));
|
|
$extension = false;
|
|
if (isset($pathInfo['extension'])) {
|
|
$extension = self::validateGDExtension($pathInfo['extension']);
|
|
}
|
|
|
|
$extension = self::checkMetaExtension($imageUrl, $extension);
|
|
|
|
if (!$extension || (strtolower($extension) === 'webp' && !function_exists('imagecreatefromwebp')) || !ini_get('allow_url_fopen')) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
return ResourceTranslator::urlToResource(Filesystem::pathToAbsoluteURL($cache->makeCache('webp', array(
|
|
self::class,
|
|
'_scaleRemoteImageWebp'
|
|
), array(
|
|
$extension,
|
|
$imageUrl,
|
|
$options
|
|
))));
|
|
|
|
} else {
|
|
$extension = false;
|
|
$imageType = @self::exif_imagetype($imagePath);
|
|
switch ($imageType) {
|
|
case IMAGETYPE_JPEG:
|
|
$extension = 'jpg';
|
|
break;
|
|
case IMAGETYPE_PNG:
|
|
$extension = 'png';
|
|
break;
|
|
case IMAGETYPE_WEBP:
|
|
if (!function_exists('imagecreatefromwebp')) {
|
|
return $originalImageUrl;
|
|
}
|
|
$extension = 'webp';
|
|
break;
|
|
}
|
|
if (!$extension) {
|
|
return $originalImageUrl;
|
|
}
|
|
|
|
return ResourceTranslator::urlToResource(Filesystem::pathToAbsoluteURL($cache->makeCache('webp', array(
|
|
self::class,
|
|
'_scaleImageWebp'
|
|
), array(
|
|
$extension,
|
|
$imagePath,
|
|
$options
|
|
))));
|
|
}
|
|
}
|
|
|
|
public static function _scaleRemoteImageWebp($targetFile, $extension, $imageUrl, $options) {
|
|
return self::_scaleImageWebp($targetFile, $extension, $imageUrl, $options);
|
|
}
|
|
|
|
public static function _scaleImageWebp($targetFile, $extension, $imagePath, $options) {
|
|
|
|
$options = array_merge(array(
|
|
'focusX' => 50,
|
|
'focusY' => 50,
|
|
), $options);
|
|
|
|
$targetDir = dirname($targetFile);
|
|
|
|
$image = false;
|
|
|
|
if ($extension == 'png') {
|
|
$image = @imagecreatefrompng($imagePath);
|
|
if (!imageistruecolor($image)) {
|
|
imagepalettetotruecolor($image);
|
|
imagealphablending($image, true);
|
|
imagesavealpha($image, true);
|
|
}
|
|
} else if ($extension == 'jpg') {
|
|
$image = @imagecreatefromjpeg($imagePath);
|
|
if (function_exists("exif_read_data")) {
|
|
$exif = @exif_read_data($imagePath);
|
|
|
|
$rotated = self::getOrientation($exif, $image);
|
|
if ($rotated) {
|
|
imagedestroy($image);
|
|
$image = $rotated;
|
|
}
|
|
}
|
|
} else if ($extension == 'webp') {
|
|
//@TODO: should we need to care about rotation?
|
|
$image = @imagecreatefromwebp($imagePath);
|
|
if (!imageistruecolor($image)) {
|
|
imagepalettetotruecolor($image);
|
|
imagealphablending($image, true);
|
|
imagesavealpha($image, true);
|
|
}
|
|
}
|
|
|
|
if ($image) {
|
|
$originalWidth = imagesx($image);
|
|
$originalHeight = imagesy($image);
|
|
switch ($options['mode']) {
|
|
case 'scale':
|
|
$targetWidth = round($originalWidth * $options['scale']);
|
|
$targetHeight = round($originalHeight * $options['scale']);
|
|
break;
|
|
case 'resize':
|
|
$targetWidth = $options['width'];
|
|
$targetHeight = $options['height'];
|
|
break;
|
|
}
|
|
if ((isset($rotated) && $rotated) || $originalWidth != $targetWidth || $originalHeight != $targetHeight) {
|
|
$newImage = imagecreatetruecolor($targetWidth, $targetHeight);
|
|
if ($extension == 'png') {
|
|
imagesavealpha($newImage, true);
|
|
imagealphablending($newImage, false);
|
|
$transparent = imagecolorallocatealpha($newImage, 255, 255, 255, 127);
|
|
imagefilledrectangle($image, 0, 0, $targetWidth, $targetHeight, $transparent);
|
|
}
|
|
|
|
list($dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) = self::imageMode($targetWidth, $targetHeight, $originalWidth, $originalHeight, 'cover', $options['focusX'], $options['focusY']);
|
|
imagecopyresampled($newImage, $image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h);
|
|
imagedestroy($image);
|
|
|
|
} else {
|
|
$newImage = $image;
|
|
}
|
|
|
|
if (!Filesystem::existsFolder($targetDir)) {
|
|
Filesystem::createFolder($targetDir);
|
|
}
|
|
|
|
imagewebp($newImage, $targetFile, $options['quality']);
|
|
imagedestroy($newImage);
|
|
|
|
return true;
|
|
}
|
|
|
|
throw new Exception('Unable to scale image: ' . $imagePath);
|
|
}
|
|
|
|
public static function checkMetaExtension($imageUrl, $originalExtension) {
|
|
if (strpos($imageUrl, 'dst-jpg') !== false) {
|
|
return 'jpg';
|
|
} else if (strpos($imageUrl, 'dst-png') !== false) {
|
|
return 'png';
|
|
} else if (strpos($imageUrl, 'dst-webp') !== false) {
|
|
return 'webp';
|
|
} else {
|
|
// not Instagram or Facebook url
|
|
return $originalExtension;
|
|
}
|
|
}
|
|
} |