/**
* Rotates an image to $deg degree
* @param integer $deg: The amount to rotate
* @param string $bgcolor: The background color in html hexadecimal notation
* @return sfFilebasePluginImage $image: THe rotated image
*/
public function rotate($deg, $bgcolor)
{
$ret_val = $this->destination_resource->rotateImage(new ImagickPixel($bgcolor), $deg);
if ($ret_val !== true) {
throw new sfFilebasePluginException(sprintf('Failed to rotate image %s.', $this->source));
}
return $ret_val;
}
protected function _rotate($degrees)
{
if ($this->im->rotateImage(new ImagickPixel(), $degrees)) {
$this->width = $this->im->getImageWidth();
$this->height = $this->im->getImageHeight();
return true;
}
return false;
}
function gradientRight($width, $height)
{
$imagick = new Imagick();
$imagick->newPseudoImage($width, $height, 'gradient:white-black');
$imagick->rotateImage('none', 90);
return $imagick;
}
/**
* @param $angle
* @param bool $autoResize
* @param string $color
* @return Pimcore_Image_Adapter_Imagick
*/
public function rotate($angle)
{
$this->resource->rotateImage(new ImagickPixel('none'), $angle);
$this->setWidth($this->resource->getimagewidth());
$this->setHeight($this->resource->getimageheight());
$this->reinitializeImage();
return $this;
}
/**
* Rotate the image.
* @param int $degrees
*/
protected function _rotate($degrees)
{
if ($this->im->rotateImage(new \ImagickPixel('transparent'), $degrees)) {
$this->width = $this->im->getImageWidth();
$this->height = $this->im->getImageHeight();
$this->im->setImagePage($this->width, $this->height, 0, 0);
}
}
/**
* Rotate the image by a given degrees
*
* @param int $degrees
* @param int $background
* @param float $alpha
*
* @return static
*/
public function rotate($degrees, $background = 0xffffff, $alpha = 1.0)
{
$backgroundColor = sprintf('rgba(%u,%u,%u,%f)', $background >> 16 & 0xff, $background >> 8 & 0xff, $background & 0xff, $alpha);
$this->_image->rotateImage(new \ImagickPixel($backgroundColor), $degrees);
$this->_image->setImagePage($this->_width, $this->_height, 0, 0);
$this->_width = $this->_image->getImageWidth();
$this->_height = $this->_image->getImageHeight();
return $this;
}
public static function rotate(Imagick $image, $params)
{
if (isset($params[0])) {
$angle = $params[0];
if ($angle > 0 && $angle < 360) {
$image->rotateImage(new ImagickPixel('none'), $angle);
}
}
}
/**
* Rotate the current image.
*
* @param integer $angle The angle to rotate the image by,
* in the clockwise direction.
* @param integer $background The background color to fill any triangles.
*/
public function rotate($angle, $background = 'white')
{
try {
$this->_imagick->rotateImage($background, $angle);
} catch (ImagickException $e) {
throw new Horde_Image_Exception($e);
}
$this->clearGeometry();
}
public function rotate($angle)
{
// Rotate
try {
$return = $this->_resource->rotateImage(new ImagickPixel('none'), $angle);
} catch (ImagickException $e) {
throw new Engine_Image_Adapter_Exception(sprintf('Unable to rotate image: %s', $e->getMessage()), $e->getCode());
}
return $this;
}
public function rotate($degree, $color = 'FFFFFF')
{
$rgb = $this->html2rgb($color);
for ($r = 0; $r < count($this->image); $r++) {
$this->image->nextImage();
$this->image->rotateImage(new ImagickPixel('rgba(' . $rgb[0] . ',' . $rgb[1] . ',' . $rgb[2] . ',0)'), $degree);
}
$this->info['width'] = $this->image->getImageWidth();
$this->info['height'] = $this->image->getImageHeight();
}
/**
* @param $angle
* @return $this
*/
public function rotate($angle)
{
$this->preModify();
$this->resource->rotateImage(new \ImagickPixel('none'), $angle);
$this->setWidth($this->resource->getimagewidth());
$this->setHeight($this->resource->getimageheight());
$this->postModify();
$this->setIsAlphaPossible(true);
return $this;
}
public function rotate($newFile, $angle)
{
$imagick = new Imagick();
$imagick->readImage($this->_file);
$imagick->rotateImage(new ImagickPixel('#ffffff'), $angle);
//$imagick->rotateImage(new ImagickPixel('transparent'), $angle);
$imagick->writeImage($newFile);
$imagick->clear();
$imagick->destroy();
}
public function process(\Imagick $image)
{
$info = getimagesize($this->_file);
if ($info['mime'] != 'image/jpeg') {
return $image;
}
if (!($exif_data = exif_read_data($this->_file))) {
return $image;
}
if (isset($exif_data['Orientation'])) {
$ort = $exif_data['Orientation'];
if ($ort > 1) {
switch ($ort) {
case 2:
$image->flopImage();
break;
case 3:
$image->rotateImage(new \ImagickPixel(), 180);
break;
case 4:
$image->flipImage();
break;
case 5:
$image->flopImage();
$image->rotateImage(new \ImagickPixel(), 270);
break;
case 6:
$image->rotateImage(new \ImagickPixel(), 90);
break;
case 7:
$image->flopImage();
$image->rotateImage(new \ImagickPixel(), 90);
break;
case 8:
$image->rotateImage(new \ImagickPixel(), 270);
break;
}
}
}
return $image;
}
/**
* 入力された画像がExifであればエラーを記録し、JFIFに変換します。
* @param \Imagick $imagick JFIFかExif。
*/
protected function convertExifToJFIF(\Imagick $imagick)
{
if ($imagick->getImageProperties('exif:*')) {
$this->logger->error(sprintf(_('「%s」はExif形式です。'), $this->filename));
switch ($imagick->getImageOrientation()) {
case \Imagick::ORIENTATION_TOPRIGHT:
$imagick->flopImage();
break;
case \Imagick::ORIENTATION_BOTTOMRIGHT:
$imagick->rotateImage('none', 180);
break;
case \Imagick::ORIENTATION_BOTTOMLEFT:
$imagick->rotateImage('none', 180);
$imagick->flopImage();
break;
case \Imagick::ORIENTATION_LEFTTOP:
$imagick->rotateImage('none', 90);
$imagick->flopImage();
break;
case \Imagick::ORIENTATION_RIGHTTOP:
$imagick->rotateImage('none', 90);
break;
case \Imagick::ORIENTATION_RIGHTBOTTOM:
$imagick->rotateImage('none', 270);
$imagick->flopImage();
break;
case \Imagick::ORIENTATION_LEFTBOTTOM:
$imagick->rotateImage('none', 270);
break;
}
$imagick->stripImage();
}
}
public function rotate($angle, $bg_color = 0xffffff, $bg_opacity = 0)
{
if ($this->multiframe()) {
foreach ($this->image as $frame) {
$frame->rotateImage($this->get_color($bg_color, $bg_opacity), -$angle);
$frame->setImagePage($this->image->width, $this->image->height, 0, 0);
}
} else {
$this->image->rotateImage($this->get_color($bg_color, $bg_opacity), -$angle);
}
$this->update_size($this->image->getImageWidth(), $this->image->getImageHeight());
return $this;
}
/**
* Rotates current image counter-clockwise by $angle.
*
* @since 3.5.0
* @access public
*
* @param float $angle
* @return true|WP_Error
*/
public function rotate($angle)
{
/**
* $angle is 360-$angle because Imagick rotates clockwise
* (GD rotates counter-clockwise)
*/
try {
$this->image->rotateImage(new ImagickPixel('none'), 360 - $angle);
// Since this changes the dimensions of the image, update the size.
$result = $this->update_size();
if (is_wp_error($result)) {
return $result;
}
$this->image->setImagePage($this->size['width'], $this->size['height'], 0, 0);
} catch (Exception $e) {
return new WP_Error('image_rotate_error', $e->getMessage());
}
return true;
}
/**
* Rotates the current image
*
* @param float $angle Rotation angle in degree
* @param array $options Supported options:
* <ul>
* <li>'canvasColor' : array(r ,g, b), named color or #rrggbb</li>
* </ul>
*
* @return bool|PEAR_Error TRUE or a PEAR_Error object on error
* @access public
*/
function rotate($angle, $options = null)
{
if ($angle % 360 == 0) {
return true;
}
$color = $this->_getColor('canvasColor', $options, array(255, 255, 255));
if (is_array($color)) {
$color = $this->colorarray2colorhex($color);
}
$pixel = new ImagickPixel($color);
try {
$this->imagick->rotateImage($pixel, $angle);
} catch (ImagickException $e) {
return $this->raiseError('Cannot create a new imagick image for the rotation: ' . $e->getMessage(), IMAGE_TRANSFORM_ERROR_FAILED);
}
$info = $this->imagick->getImageGeometry();
$this->new_x = $info['width'];
$this->new_y = $info['height'];
return true;
}
private function rotate_imagick($imagePath, $orientation)
{
$imagick = new Imagick($imagePath);
$imagick->setImageOrientation(imagick::ORIENTATION_TOPLEFT);
$deg = 0;
switch ($orientation) {
case 3:
$deg = -180;
break;
case 6:
$deg = 90;
break;
case 8:
$deg = -90;
break;
}
$imagick->rotateImage(new ImagickPixel('#00000000'), $deg);
$imagick->writeImage($imagePath);
$imagick->clear();
$imagick->destroy();
}
function weldMaps2PNG_rotate($urls, $filename, $angle, $encode = true)
{
if (!$urls || $urls == "") {
$e = new mb_exception("weldMaps2PNG_rotate: no maprequests delivered");
}
$url = explode("___", $urls);
$obj1 = new stripRequest($url[0]);
$width = $obj1->get("width");
$height = $obj1->get("height");
//calculate rotated dimensions
$neededWidth = round(abs(sin(deg2rad($angle)) * $height) + abs(cos(deg2rad($angle)) * $width));
$neededHeight = round(abs(sin(deg2rad($angle)) * $width) + abs(cos(deg2rad($angle)) * $height));
//modify requests
for ($i = 0; $i < count($url); $i++) {
$obj = new stripRequest($url[$i]);
$obj->set("width", $neededWidth);
$obj->set("height", $neededHeight);
$map_extent = $obj->get("BBOX");
$coord = split(",", $map_extent);
$coord = $this->enlargeExtent($coord, $width, $height, $neededWidth, $neededHeight);
$obj->set("BBOX", implode(",", $coord));
$url[$i] = $obj->url;
}
//get image
$urls = implode("___", $url);
$this->weldMaps2PNG($urls, $filename, $encode);
//rotate image
$imagick = new Imagick();
$imagick->readImage($filename);
$imagick->rotateImage(new ImagickPixel(), $angle);
//get the new dimensions
$imgWidth = $imagick->getImageWidth();
$imgHeight = $imagick->getImageHeight();
//crop empty areas
$imagick->cropImage($width, $height, ($imgWidth - $width) / 2, ($imgHeight - $height) / 2);
//write modified image
$imagick->writeImage();
$image = imagecreatefrompng($filename);
imagepng($image, $filename);
}
/**
* @ref http://www.b-prep.com/blog/?p=1764
*
* @param \Imagick $image
* @return \Imagick
*/
private function fixImageOrientation($image)
{
$orientation = $image->getImageOrientation();
switch ($orientation) {
case \Imagick::ORIENTATION_UNDEFINED:
break;
case \Imagick::ORIENTATION_TOPLEFT:
break;
case \Imagick::ORIENTATION_TOPRIGHT:
$image->flopImage();
$image->setimageorientation(\Imagick::ORIENTATION_TOPLEFT);
break;
case \Imagick::ORIENTATION_BOTTOMRIGHT:
$image->rotateImage(new \ImagickPixel(), 180);
$image->setimageorientation(\Imagick::ORIENTATION_TOPLEFT);
break;
case \Imagick::ORIENTATION_BOTTOMLEFT:
$image->rotateImage(new \ImagickPixel(), 180);
$image->flopImage();
$image->setimageorientation(\Imagick::ORIENTATION_TOPLEFT);
break;
case \Imagick::ORIENTATION_LEFTTOP:
$image->rotateImage(new \ImagickPixel(), 90);
$image->flopImage();
$image->setimageorientation(\Imagick::ORIENTATION_TOPLEFT);
break;
case \Imagick::ORIENTATION_RIGHTTOP:
$image->rotateImage(new \ImagickPixel(), 90);
$image->setimageorientation(\Imagick::ORIENTATION_TOPLEFT);
break;
case \Imagick::ORIENTATION_RIGHTBOTTOM:
$image->rotateImage(new \ImagickPixel(), 270);
$image->flopImage();
$image->setimageorientation(\Imagick::ORIENTATION_TOPLEFT);
break;
case \Imagick::ORIENTATION_LEFTBOTTOM:
$image->rotateImage(new \ImagickPixel(), 270);
$image->setimageorientation(\Imagick::ORIENTATION_TOPLEFT);
break;
}
return $image;
}
/**
* Performs optimized gradient fill for non-opaque linear gradients
*
* @param Linear $fill
*/
private function applyFastLinear(Linear $fill)
{
$gradient = new \Imagick();
$size = $this->getSize();
$color = sprintf('gradient:%s-%s', (string) $fill->getStart(), (string) $fill->getEnd());
if ($fill instanceof Horizontal) {
$gradient->newPseudoImage($size->getHeight(), $size->getWidth(), $color);
$gradient->rotateImage(new \ImagickPixel(), 90);
} else {
$gradient->newPseudoImage($size->getWidth(), $size->getHeight(), $color);
}
$this->imagick->compositeImage($gradient, \Imagick::COMPOSITE_OVER, 0, 0);
$gradient->clear();
$gradient->destroy();
}
/**
* Fixes image orientation.
*
* @since 1.0.0
* @package GeoDirectory
* @param array $file The image file.
* @return mixed Image file.
*/
function geodir_exif($file)
{
//This line reads the EXIF data and passes it into an array
$file['file'] = $file['tmp_name'];
if ($file['type'] == "image/jpg" || $file['type'] == "image/jpeg" || $file['type'] == "image/pjpeg") {
} else {
return $file;
}
if (!function_exists('read_exif_data')) {
return $file;
}
$exif = read_exif_data($file['file']);
//We're only interested in the orientation
$exif_orient = isset($exif['Orientation']) ? $exif['Orientation'] : 0;
$rotateImage = 0;
//We convert the exif rotation to degrees for further use
if (6 == $exif_orient) {
$rotateImage = 90;
$imageOrientation = 1;
} elseif (3 == $exif_orient) {
$rotateImage = 180;
$imageOrientation = 1;
} elseif (8 == $exif_orient) {
$rotateImage = 270;
$imageOrientation = 1;
}
//if the image is rotated
if ($rotateImage) {
//WordPress 3.5+ have started using Imagick, if it is available since there is a noticeable difference in quality
//Why spoil beautiful images by rotating them with GD, if the user has Imagick
if (class_exists('Imagick')) {
$imagick = new Imagick();
$imagick->readImage($file['file']);
$imagick->rotateImage(new ImagickPixel(), $rotateImage);
$imagick->setImageOrientation($imageOrientation);
$imagick->writeImage($file['file']);
$imagick->clear();
$imagick->destroy();
} else {
//if no Imagick, fallback to GD
//GD needs negative degrees
$rotateImage = -$rotateImage;
switch ($file['type']) {
case 'image/jpeg':
$source = imagecreatefromjpeg($file['file']);
$rotate = imagerotate($source, $rotateImage, 0);
imagejpeg($rotate, $file['file']);
break;
case 'image/png':
$source = imagecreatefrompng($file['file']);
$rotate = imagerotate($source, $rotateImage, 0);
imagepng($rotate, $file['file']);
break;
case 'image/gif':
$source = imagecreatefromgif($file['file']);
$rotate = imagerotate($source, $rotateImage, 0);
imagegif($rotate, $file['file']);
break;
default:
break;
}
}
}
// The image orientation is fixed, pass it back for further processing
return $file;
}
/**
* 旋转图片
*/
public static function rotate_by_degree($file_path, $degree)
{
$image = new Imagick($file_path);
$image->rotateImage(new ImagickPixel(), $degree);
$image->writeImage($file_path);
}
public function adjustFile($path, $info)
{
# Check dependencies
self::dependencies(isset($path, $info));
# Call plugins
$this->plugins(__METHOD__, 0, func_get_args());
if (extension_loaded('imagick') && $this->settings['imagick'] === '1') {
$rotateImage = 0;
switch ($info['orientation']) {
case 3:
$rotateImage = 180;
$imageOrientation = 1;
break;
case 6:
$rotateImage = 90;
$imageOrientation = 1;
break;
case 8:
$rotateImage = 270;
$imageOrientation = 1;
break;
}
if ($rotateImage !== 0) {
$image = new Imagick();
$image->readImage($path);
$image->rotateImage(new ImagickPixel(), $rotateImage);
$image->setImageOrientation($imageOrientation);
$image->writeImage($path);
$image->clear();
$image->destroy();
}
} else {
$newWidth = $info['width'];
$newHeight = $info['height'];
$process = false;
$sourceImg = imagecreatefromjpeg($path);
switch ($info['orientation']) {
case 2:
# mirror
# not yet implemented
break;
case 3:
$process = true;
$sourceImg = imagerotate($sourceImg, -180, 0);
break;
case 4:
# rotate 180 and mirror
# not yet implemented
break;
case 5:
# rotate 90 and mirror
# not yet implemented
break;
case 6:
$process = true;
$sourceImg = imagerotate($sourceImg, -90, 0);
$newWidth = $info['height'];
$newHeight = $info['width'];
break;
case 7:
# rotate -90 and mirror
# not yet implemented
break;
case 8:
$process = true;
$sourceImg = imagerotate($sourceImg, 90, 0);
$newWidth = $info['height'];
$newHeight = $info['width'];
break;
}
# Need to adjust photo?
if ($process === true) {
# Recreate photo
$newSourceImg = imagecreatetruecolor($newWidth, $newHeight);
imagecopyresampled($newSourceImg, $sourceImg, 0, 0, 0, 0, $newWidth, $newHeight, $newWidth, $newHeight);
imagejpeg($newSourceImg, $path, 100);
# Free memory
imagedestroy($sourceImg);
imagedestroy($newSourceImg);
}
}
# Call plugins
$this->plugins(__METHOD__, 1, func_get_args());
return true;
}
/**
* Corrects orientation of an image
* @param \Imagick $im
*/
private function correctOrientation(\Imagick &$im)
{
switch ($im->getImageOrientation()) {
case \Imagick::ORIENTATION_TOPRIGHT:
$im->flipImage();
break;
case \Imagick::ORIENTATION_BOTTOMRIGHT:
$im->rotateImage(new \ImagickPixel("none"), 180);
break;
case \Imagick::ORIENTATION_BOTTOMLEFT:
$im->rotateImage(new \ImagickPixel("none"), 180);
$im->flipImage();
break;
case \Imagick::ORIENTATION_LEFTTOP:
$im->rotateImage(new \ImagickPixel("none"), 90);
$im->flipImage();
break;
case \Imagick::ORIENTATION_RIGHTTOP:
$im->rotateImage(new \ImagickPixel("none"), 90);
break;
case \Imagick::ORIENTATION_RIGHTBOTTOM:
$im->rotateImage(new \ImagickPixel("none"), -90);
$im->flipImage();
break;
case \Imagick::ORIENTATION_LEFTBOTTOM:
$im->rotateImage(new \ImagickPixel("none"), -90);
break;
default:
}
}
function image_rotation($im, $angle, $crop = false)
{
$fonction = array('image_rotation', func_get_args());
$image = _image_valeurs_trans($im, "rot-{$angle}-{$crop}", "png", $fonction);
if (!$image) {
return "";
}
$im = $image["fichier"];
$dest = $image["fichier_dest"];
$creer = $image["creer"];
if ($creer) {
$effectuer_gd = true;
if (method_exists('Imagick', 'rotateImage')) {
$imagick = new Imagick();
$imagick->readImage($im);
$imagick->rotateImage(new ImagickPixel('none'), $angle);
$imagick->writeImage($dest);
$effectuer_gd = false;
} else {
if ($GLOBALS['meta']['image_process'] == "convert") {
if (_CONVERT_COMMAND != '') {
@define('_CONVERT_COMMAND', 'convert');
@define('_ROTATE_COMMAND', _CONVERT_COMMAND . ' -background none -rotate %t %src %dest');
} else {
@define('_ROTATE_COMMAND', '');
}
if (_ROTATE_COMMAND !== '') {
$commande = str_replace(array('%t', '%src', '%dest'), array($angle, escapeshellcmd($im), escapeshellcmd($dest)), _ROTATE_COMMAND);
spip_log($commande);
exec($commande);
if (file_exists($dest)) {
$effectuer_gd = false;
}
}
} elseif (function_exists('imagick_rotate')) {
$handle = imagick_readimage($im);
if ($handle && imagick_isopaqueimage($handle)) {
imagick_setfillcolor($handle, 'transparent');
imagick_rotate($handle, $angle);
imagick_writeimage($handle, $dest);
$effectuer_gd = false;
}
}
}
if ($effectuer_gd) {
// Creation de l'image en deux temps
// de facon a conserver les GIF transparents
$im = $image["fonction_imagecreatefrom"]($im);
imagepalettetotruecolor($im);
$im = image_RotateBicubic($im, $angle, true);
_image_gd_output($im, $image);
imagedestroy($im);
}
}
list($src_y, $src_x) = taille_image($dest);
return _image_ecrire_tag($image, array('src' => $dest, 'width' => $src_x, 'height' => $src_y));
}
/**
* Rotates the image's
*
* @param int $angle
*
* @return Imagick
*/
public function rotate($angle)
{
$this->image->rotateImage(new \ImagickPixel('#00000000'), $angle);
$this->operations[] = 'rotate' . $angle;
return $this;
}
/**
* @param File $file
* @param array $params Rotate parameters.
* 'rotation' clockwise rotation in degrees, allowed are multiples of 90
* @since 1.21
* @return bool
*/
public function rotate($file, $params)
{
global $wgImageMagickConvertCommand;
$rotation = ($params['rotation'] + $this->getRotation($file)) % 360;
$scene = false;
$scaler = $this->getScalerType(null, false);
switch ($scaler) {
case 'im':
$cmd = wfEscapeShellArg($wgImageMagickConvertCommand) . " " . wfEscapeShellArg($this->escapeMagickInput($params['srcPath'], $scene)) . " -rotate " . wfEscapeShellArg("-{$rotation}") . " " . wfEscapeShellArg($this->escapeMagickOutput($params['dstPath']));
wfDebug(__METHOD__ . ": running ImageMagick: {$cmd}\n");
$retval = 0;
$err = wfShellExecWithStderr($cmd, $retval);
if ($retval !== 0) {
$this->logErrorForExternalProcess($retval, $err, $cmd);
return new MediaTransformError('thumbnail_error', 0, 0, $err);
}
return false;
case 'imext':
$im = new Imagick();
$im->readImage($params['srcPath']);
if (!$im->rotateImage(new ImagickPixel('white'), 360 - $rotation)) {
return new MediaTransformError('thumbnail_error', 0, 0, "Error rotating {$rotation} degrees");
}
$result = $im->writeImage($params['dstPath']);
if (!$result) {
return new MediaTransformError('thumbnail_error', 0, 0, "Unable to write image to {$params['dstPath']}");
}
return false;
default:
return new MediaTransformError('thumbnail_error', 0, 0, "{$scaler} rotation not implemented");
}
}
public function adjustFile($path, $info)
{
# Function rotates and flips a photo based on its EXIF orientation
# Excepts the following:
# (string) $path = Path to the photo-file
# (array) $info = ['orientation', 'width', 'height']
# Returns the following
# (array) $info = ['orientation', 'width', 'height'] = Success
# (boolean) false = Failure
# Check dependencies
self::dependencies(isset($path, $info));
# Call plugins
$this->plugins(__METHOD__, 0, func_get_args());
$swapSize = false;
if (extension_loaded('imagick') && $this->settings['imagick'] === '1') {
$rotateImage = 0;
switch ($info['orientation']) {
case 3:
$rotateImage = 180;
break;
case 6:
$rotateImage = 90;
$swapSize = true;
break;
case 8:
$rotateImage = 270;
$swapSize = true;
break;
default:
return false;
break;
}
if ($rotateImage !== 0) {
$image = new Imagick();
$image->readImage($path);
$image->rotateImage(new ImagickPixel(), $rotateImage);
$image->setImageOrientation(1);
$image->writeImage($path);
$image->clear();
$image->destroy();
}
} else {
$newWidth = $info['width'];
$newHeight = $info['height'];
$sourceImg = imagecreatefromjpeg($path);
switch ($info['orientation']) {
case 2:
# mirror
# not yet implemented
return false;
break;
case 3:
$process = true;
$sourceImg = imagerotate($sourceImg, -180, 0);
break;
case 4:
# rotate 180 and mirror
# not yet implemented
return false;
break;
case 5:
# rotate 90 and mirror
# not yet implemented
return false;
break;
case 6:
$process = true;
$sourceImg = imagerotate($sourceImg, -90, 0);
$newWidth = $info['height'];
$newHeight = $info['width'];
$swapSize = true;
break;
case 7:
# rotate -90 and mirror
# not yet implemented
return false;
break;
case 8:
$process = true;
$sourceImg = imagerotate($sourceImg, 90, 0);
$newWidth = $info['height'];
$newHeight = $info['width'];
$swapSize = true;
break;
default:
return false;
break;
}
# Recreate photo
$newSourceImg = imagecreatetruecolor($newWidth, $newHeight);
imagecopyresampled($newSourceImg, $sourceImg, 0, 0, 0, 0, $newWidth, $newHeight, $newWidth, $newHeight);
imagejpeg($newSourceImg, $path, 100);
# Free memory
imagedestroy($sourceImg);
imagedestroy($newSourceImg);
}
# Call plugins
$this->plugins(__METHOD__, 1, func_get_args());
# SwapSize should be true when the image has been rotated
# Return new dimensions in this case
if ($swapSize === true) {
$swapSize = $info['width'];
$info['width'] = $info['height'];
$info['height'] = $swapSize;
}
return $info;
}
function rotate($d)
{
$d = $d * -1;
$color_transparent = new ImagickPixel("transparent");
//透明色
if ($this->image_type == 'GIF') {
$dest = new Imagick();
foreach ($this->image as $frame) {
$page = $frame->getImagePage();
$tmp = new Imagick();
$tmp->newImage($page['width'], $page['height'], $color_transparent, 'gif');
$tmp->compositeImage($frame, Imagick::COMPOSITE_OVER, $page['x'], $page['y']);
$tmp->rotateImage($color_transparent, $d);
$dest->addImage($tmp);
$dest->setImagePage($tmp->getImageWidth(), $tmp->getImageHeight(), 0, 0);
$dest->setImageDelay($frame->getImageDelay());
$dest->setImageDispose($frame->getImageDispose());
}
$dest->coalesceImages();
$this->image->destroy();
$this->image = $dest;
} else {
$this->image->rotateImage($color_transparent, $d);
}
}
