PHP Imagick::thumbnailImage方法代碼示例

 function mkbilder()
 {
     $this->err->write('mkbilder', 'IN');
     if (!class_exists("Imagick")) {
         $this->err->out("Imagick-Extention nicht installiert", true);
         return false;
     }
     $handle = new Imagick();
     if (!$handle->readImage("./tmp/tmp.file_org")) {
         return false;
     }
     $d = $handle->getImageGeometry();
     if ($d["width"] < $d["height"]) {
         $faktor = $d["height"] / $d["width"];
     } else {
         $faktor = $d["width"] / $d["height"];
     }
     $thumbheight = floor($this->thumbwidth * $faktor);
     $handle->thumbnailImage($this->thumbwidth, $thumbheight);
     $rc = $handle->writeImage("./tmp/tmp.file_thumb");
     $handle->readImage("./tmp/tmp.file_org");
     $popupheight = floor($this->popupwidth * $faktor);
     $handle->thumbnailImage($this->popupwidth, $popupheight);
     $rc = $handle->writeImage("./tmp/tmp.file_popup");
     $handle->readImage("./tmp/tmp.file_org");
     $infoheight = floor($this->infowidth * $faktor);
     $handle->thumbnailImage($this->infowidth, $infoheight);
     $rc = $handle->writeImage("./tmp/tmp.file_info");
     return $rc;
 }

 public function serverAction(Request $request)
 {
     $fileName = $request->get('fileName');
     $points = $request->get('transform');
     $sizes = $this->getSizes();
     $fileFullName = $sizes[0]['dir'] . $fileName;
     try {
         $image = new \Imagick($fileFullName);
     } catch (\ImagickException $e) {
         return new JsonResponse(array('success' => false, 'errorMessage' => 'На сервере не найден файл'));
     }
     $finalScale = $sizes[0]['width'] / $sizes[0]['mediumWidth'];
     for ($i = 0; $i <= 5; $i++) {
         $points[$i] *= $finalScale;
     }
     $image->distortImage(\Imagick::DISTORTION_AFFINEPROJECTION, $points, TRUE);
     $image->cropImage($sizes[0]['width'], $sizes[0]['height'], 0, 0);
     $hashFile = md5_file($fileFullName);
     $fileName = $hashFile . '.jpg';
     foreach ($sizes as $size) {
         $imgFullName = $size['dir'] . $fileName;
         $image->thumbnailImage($size['width'], $size['height'], TRUE);
         $image->writeimage($imgFullName);
         if (!file_exists($imgFullName)) {
             $image->writeimage($imgFullName);
         }
     }
     return new JsonResponse(array('success' => true, 'fileName' => $fileName));
 }

 /**
  * Generates a new jpg image with new sizes from an already existing file.
  * (This will also work on raw files, but it will be exceptionally
  * slower than extracting the preview).
  *
  * @param  	string	$sourceFilePath	the path to the original file
  * @param  	string	$targetFilePath	the path to the target file
  * @param  	int		$width			the max width
  * @param  	int		$height			the max height of the image
  * @param  	int		$quality		the quality of the new image (0-100)
  *
  * @throws \InvalidArgumentException
  *
  * @return void.
  */
 public static function generateImage($sourceFilePath, $targetFilePath, $width, $height, $quality = 60)
 {
     if (!self::checkFile($sourceFilePath)) {
         throw new \InvalidArgumentException('Incorrect filepath given');
     }
     $im = new \Imagick($sourceFilePath);
     $im->setImageFormat('jpg');
     $im->setImageCompressionQuality($quality);
     $im->stripImage();
     $im->thumbnailImage($width, $height, true);
     $im->writeImage($targetFilePath);
     $im->clear();
     $im->destroy();
 }

function multiply($firstPicture, $twoPicture, $x, $y)
{
    $img = new Imagick($firstPicture);
    $img->thumbnailImage(140, 140);
    $shadow = $img->clone();
    $shadow->setImageBackgroundColor(new ImagickPixel('black'));
    //color shadow
    $shadow->shadowImage(80, 3, 5, 5);
    //create shadow
    $shadow->compositeImage($img, Imagick::COMPOSITE_OVER, 0, 0);
    header("Content-Type: image/jpeg");
    $img2 = new Imagick($twoPicture);
    $img2->compositeImage($shadow, $shadow->getImageCompose(), $x, $y);
    echo $img2;
}

 /**
  * @param $file
  * @return string
  */
 public function thumbnail($file)
 {
     $format = '';
     $name = md5((new \DateTime())->format('c'));
     foreach ($this->sizes as $size) {
         $image = new \Imagick($file);
         $imageRatio = $image->getImageWidth() / $image->getImageHeight();
         $width = $size['width'];
         $height = $size['height'];
         $customRation = $width / $height;
         if ($customRation < $imageRatio) {
             $widthThumb = 0;
             $heightThumb = $height;
         } else {
             $widthThumb = $width;
             $heightThumb = 0;
         }
         $image->thumbnailImage($widthThumb, $heightThumb);
         $image->cropImage($width, $height, ($image->getImageWidth() - $width) / 2, ($image->getImageHeight() - $height) / 2);
         $image->setCompressionQuality(100);
         $format = strtolower($image->getImageFormat());
         $pp = $this->cachePath . '/' . $size['name'] . "_{$name}." . $format;
         $image->writeImage($pp);
     }
     return "_{$name}." . $format;
 }

 /**
  * @param ImageInterface $image
  * @param Size $size
  * @param bool $allow_enlarge
  */
 public function resize(ImageInterface $image, Size $sizeDest, $allow_enlarge = false)
 {
     $widthDest = 0;
     $heightDest = 0;
     $imagick = new \Imagick($image->getPath());
     $srcWidth = $image->getImageSize()->getHeight();
     $srcHeight = $image->getImageSize()->getWidth();
     if ($srcWidth > $srcHeight) {
         $widthDest = $sizeDest->getWidth();
     } else {
         if ($srcHeight > $srcWidth) {
             $heightDest = $sizeDest->getHeight();
         } else {
             $widthDest = $sizeDest->getWidth();
             $heightDest = $sizeDest->getHeight();
         }
     }
     $imagick->thumbnailImage($widthDest, $heightDest);
     $addToName = "_resized_" . $imagick->getImageWidth() . "x" . $imagick->getImageHeight();
     list($name, $extension) = explode(".", $image->getOriginalName());
     list($path, $extension) = explode(".", $image->getPath());
     $newPath = $path . $addToName . '.' . $extension;
     $newName = $name . $addToName . '.' . $extension;
     $newImageSize = new Size($imagick->getImageWidth(), $imagick->getImageHeight());
     $imagick->writeImage($newPath);
     return $this->ImagickToImage($imagick, $image, $newPath, $newName, $newImageSize);
 }

 /**
  * Creates a thumbnail with imagick.
  *
  * @param  File    $fileObject           FileObject to add properties
  * @param  string  $httpPathToMediaDir   Http path to file
  * @param  string  $pathToMediaDirectory Local path to file
  * @param  string  $fileName             Name of the image
  * @param  string  $fileExtension        Fileextension
  * @param  integer $width                Width of thumbnail, if omitted, size will be proportional to height
  * @param  integer $height               Height of thumbnail, if omitted, size will be proportional to width
  *
  * @throws ThumbnailCreationFailedException              If imagick is not supported
  * @throws InvalidArgumentException      If both, height and width are omitted or file format is not supported
  */
 private static function createThumbnailWithImagick(File &$fileObject, $httpPathToMediaDir, $pathToMediaDirectory, $fileName, $fileExtension, $width = null, $height = null)
 {
     if (!extension_loaded('imagick')) {
         throw new ExtensionNotLoadedException('Imagick is not loaded on this system');
     }
     if ($width === null && $height === null) {
         throw new InvalidArgumentException('Either width or height must be provided');
     }
     // create thumbnails with imagick
     $imagick = new \Imagick();
     if (!in_array($fileExtension, $imagick->queryFormats("*"))) {
         throw new ThumbnailCreationFailedException('No thumbnail could be created for the file format');
     }
     // read image into imagick
     $imagick->readImage(sprintf('%s/%s.%s', $pathToMediaDirectory, $fileName, $fileExtension));
     // set size
     $imagick->thumbnailImage($width, $height);
     // null values allowed
     // write image
     $imagick->writeImage(sprintf('%s/%sx%s-thumbnail-%s.%s', $pathToMediaDirectory, $imagick->getImageWidth(), $imagick->getImageHeight(), $fileName, $fileExtension));
     $fileObject->setThumbnailLink(sprintf('%s/%sx%s-thumbnail-%s.%s', $httpPathToMediaDir, $imagick->getImageWidth(), $imagick->getImageHeight(), $fileName, $fileExtension));
     $fileObject->setLocalThumbnailPath(sprintf('%s/%sx%s-thumbnail-%s.%s', $pathToMediaDirectory, $imagick->getImageWidth(), $imagick->getImageHeight(), $fileName, $fileExtension));
     // free up associated resources
     $imagick->destroy();
 }

 /**
  * @param Thumbnail $thumbnail
  * @return void
  * @throws Exception\NoThumbnailAvailableException
  */
 public function refresh(Thumbnail $thumbnail)
 {
     try {
         $filenameWithoutExtension = pathinfo($thumbnail->getOriginalAsset()->getResource()->getFilename(), PATHINFO_FILENAME);
         $temporaryLocalCopyFilename = $thumbnail->getOriginalAsset()->getResource()->createTemporaryLocalCopy();
         $documentFile = sprintf(in_array($thumbnail->getOriginalAsset()->getResource()->getFileExtension(), $this->getOption('paginableDocuments')) ? '%s[0]' : '%s', $temporaryLocalCopyFilename);
         $width = $thumbnail->getConfigurationValue('width') ?: $thumbnail->getConfigurationValue('maximumWidth');
         $height = $thumbnail->getConfigurationValue('height') ?: $thumbnail->getConfigurationValue('maximumHeight');
         $im = new \Imagick();
         $im->setResolution($this->getOption('resolution'), $this->getOption('resolution'));
         $im->readImage($documentFile);
         $im->setImageFormat('png');
         $im->setImageBackgroundColor('white');
         $im->setImageCompose(\Imagick::COMPOSITE_OVER);
         $im->setImageAlphaChannel(\Imagick::ALPHACHANNEL_RESET);
         $im->thumbnailImage($width, $height, true);
         $im->flattenImages();
         // Replace flattenImages in imagick 3.3.0
         // @see https://pecl.php.net/package/imagick/3.3.0RC2
         // $im->mergeImageLayers(\Imagick::LAYERMETHOD_MERGE);
         $resource = $this->resourceManager->importResourceFromContent($im->getImageBlob(), $filenameWithoutExtension . '.png');
         $im->destroy();
         $thumbnail->setResource($resource);
         $thumbnail->setWidth($width);
         $thumbnail->setHeight($height);
     } catch (\Exception $exception) {
         $filename = $thumbnail->getOriginalAsset()->getResource()->getFilename();
         $sha1 = $thumbnail->getOriginalAsset()->getResource()->getSha1();
         $message = sprintf('Unable to generate thumbnail for the given document (filename: %s, SHA1: %s)', $filename, $sha1);
         throw new Exception\NoThumbnailAvailableException($message, 1433109652, $exception);
     }
 }

 protected function save($path)
 {
     $pathinfo = pathinfo($path);
     if (!file_exists($pathinfo['dirname'])) {
         mkdir($pathinfo['dirname'], 0777, true);
     }
     try {
         $image = new \Imagick($this->source);
         $image->thumbnailImage($this->width, $this->height, true);
         if ($this->color) {
             $thumb = $image;
             $image = new \Imagick();
             $image->newImage($this->width, $this->height, $this->color, $pathinfo['extension']);
             $size = $thumb->getImageGeometry();
             $x = ($this->width - $size['width']) / 2;
             $y = ($this->height - $size['height']) / 2;
             $image->compositeImage($thumb, \imagick::COMPOSITE_OVER, $x, $y);
             $thumb->destroy();
         }
         $image->writeImage($path);
         $image->destroy();
     } catch (\Exception $e) {
     }
     return $this;
 }

 function imagick_thumbnail($image, $timage, $ext, $thumbnail_name, $imginfo)
 {
     try {
         $imagick = new Imagick();
         $fullpath = "./" . $this->thumbnail_path . "/" . $timage[0] . "/" . $thumbnail_name;
         if ($ext == "gif") {
             $imagick->readImage($image . '[0]');
         } else {
             $imagick->readImage($image);
         }
         $info = $imagick->getImageGeometry();
         $this->info[0] = $info['width'];
         $this->info[1] = $info['height'];
         $imagick->thumbnailImage($this->dimension, $this->dimension, true);
         if ($ext == "png" || $ext == "gif") {
             $white = new Imagick();
             $white->newImage($this->dimension, $this->dimension, "white");
             $white->compositeimage($image, Imagick::COMPOSITE_OVER, 0, 0);
             $white->writeImage($fullpath);
             $white->clear();
         } else {
             $imagick->writeImage($fullpath);
         }
         $imagick->clear();
     } catch (Exception $e) {
         echo "Unable to load image." . $e->getMessage();
         return false;
     }
     return true;
 }

function upload_image($arr_image, $location, $compression = null, $width = 245, $height = 170)
{
    $image_location = "";
    $allowedExts = array("gif", "jpeg", "jpg", "png", "JPG", "JPEG", "GIF", "PNG", "pdf", "PDF");
    $temp = explode(".", $arr_image["file"]["name"]);
    $extension = end($temp);
    if (($arr_image["file"]["type"] == "image/gif" || $arr_image["file"]["type"] == "image/jpeg" || $arr_image["file"]["type"] == "image/jpg" || $arr_image["file"]["type"] == "image/pjpeg" || $arr_image["file"]["type"] == "image/x-png" || $arr_image["file"]["type"] == "image/png") && $arr_image["file"]["size"] < 1024 * 1000 * 10 && in_array($extension, $allowedExts)) {
        if ($arr_image["file"]["error"] > 0) {
            echo "Return Code: " . $arr_image["file"]["error"] . "<br>";
        } else {
            $compression_type = Imagick::COMPRESSION_JPEG;
            $image_location = $location . "." . $extension;
            if (move_uploaded_file($arr_image["file"]["tmp_name"], $image_location)) {
                //echo "Image Uploaded to : ".$image_location;
            } else {
                //echo "Image not uploaded";
            }
            if (is_null($compression)) {
                $im = new Imagick($image_location);
                $im->setImageFormat('jpg');
                $im->setImageCompression($compression_type);
                $im->setImageCompressionQuality(95);
                $im->stripImage();
                $im->thumbnailImage($width, $height);
                $image_location = $location . ".jpg";
                $im->writeImage($image_location);
            }
        }
    }
    return $image_location;
}

function resize_image($file, $out_file, $width, $height = 0)
{
    if (extension_loaded('imagick')) {
        $img = new Imagick($file);
        $img->thumbnailImage($width, $height);
        $img->writeImage($out_file);
    }
    if (extension_loaded('gd')) {
        $ext = image_type($file);
        if ($ext == 'jpg' || $ext == 'jpeg') {
            $src_img = imagecreatefromjpeg($file);
        } else {
            $src_img = imagecreatefrompng($file);
        }
        $old_x = imageSX($src_img);
        $old_y = imageSY($src_img);
        if ($height == 0) {
            $height = $old_y * $width / $old_x;
        }
        $dst_img = ImageCreateTrueColor($width, $height);
        imagecopyresampled($dst_img, $src_img, 0, 0, 0, 0, $width, $height, $old_x, $old_y);
        $ext = image_type($out_file);
        if ($ext == 'jpg' || $ext == 'jpeg') {
            imagejpeg($dst_img, $out_file);
        } else {
            imagepng($dst_img, $out_file);
        }
        imagedestroy($dst_img);
        imagedestroy($src_img);
    }
    return null;
}

 function _resize_image($image_path, $max_width = 100, $max_height = 100)
 {
     $imagick = new \Imagick(realpath($image_path));
     $imagick->thumbnailImage($max_width, $max_height, true);
     $blob = $imagick->getImageBlob();
     $imagick->clear();
     return $blob;
 }

    /**
     * Homothetic resizement
     *
     * @param \Imagick image
     * @param integer $maxwidth
     * @param integer $maxheight
     */
    public function homothetic(\Imagick $image, $width, $height)
    {
        list($width, $height) = $this->scaleImage($image->getImageWidth(), $image->getImageHeight(), $width, $height);

        $image->thumbnailImage($width, $height);

        $image->unsharpMaskImage(0 , 0.5 , 1 , 0.05);
    }

 protected function buildFitOut($params)
 {
     $newWidth = $params[0];
     $newHeight = $params[1];
     $originalWidth = $this->_image->getImageWidth();
     $originalHeight = $this->_image->getImageHeight();
     $this->_image->setGravity(!empty($params[2]) ? $params[2] : \Imagick::GRAVITY_CENTER);
     $tmpWidth = $newWidth;
     $tmpHeight = $originalHeight * ($newWidth / $originalWidth);
     if ($tmpHeight < $newHeight) {
         $tmpHeight = $newHeight;
         $tmpWidth = $originalWidth * ($newHeight / $originalHeight);
     }
     $this->_image->thumbnailImage($tmpWidth, $tmpHeight);
     $offset = self::detectGravityXY($this->_image->getGravity(), $tmpWidth, $tmpHeight, $params[0], $params[1]);
     $this->_image->cropImage($newWidth, $newHeight, $offset[0], $offset[1]);
 }