PHP ImagineInterface::create方法代码示例

 /**
  * {@inheritdoc}
  */
 public function load(ImageInterface $image, array $options = array())
 {
     $background = $image->palette()->color(isset($options['color']) ? $options['color'] : '#fff', isset($options['transparency']) ? $options['transparency'] : null);
     $topLeft = new Point(0, 0);
     $size = $image->getSize();
     if (isset($options['size'])) {
         list($width, $height) = $options['size'];
         $position = isset($options['position']) ? $options['position'] : 'center';
         switch ($position) {
             case 'topleft':
                 $x = 0;
                 $y = 0;
                 break;
             case 'top':
                 $x = ($width - $image->getSize()->getWidth()) / 2;
                 $y = 0;
                 break;
             case 'topright':
                 $x = $width - $image->getSize()->getWidth();
                 $y = 0;
                 break;
             case 'left':
                 $x = 0;
                 $y = ($height - $image->getSize()->getHeight()) / 2;
                 break;
             case 'center':
                 $x = ($width - $image->getSize()->getWidth()) / 2;
                 $y = ($height - $image->getSize()->getHeight()) / 2;
                 break;
             case 'right':
                 $x = $width - $image->getSize()->getWidth();
                 $y = ($height - $image->getSize()->getHeight()) / 2;
                 break;
             case 'bottomleft':
                 $x = 0;
                 $y = $height - $image->getSize()->getHeight();
                 break;
             case 'bottom':
                 $x = ($width - $image->getSize()->getWidth()) / 2;
                 $y = $height - $image->getSize()->getHeight();
                 break;
             case 'bottomright':
                 $x = $width - $image->getSize()->getWidth();
                 $y = $height - $image->getSize()->getHeight();
                 break;
             default:
                 throw new \InvalidArgumentException("Unexpected position '{$position}'");
                 break;
         }
         $size = new Box($width, $height);
         $topLeft = new Point($x, $y);
     }
     $canvas = $this->imagine->create($size, $background);
     return $canvas->paste($image, $topLeft);
 }

 /**
  * {@inheritdoc}
  */
 public function generate($toFile = null)
 {
     $fontSize = max(min($this->dimension->getWidth() / strlen($this->text) * 1.15, $this->dimension->getHeight() * 0.5), 5);
     $palette = new RGB();
     $image = $this->imagine->create(new Box($this->dimension->getWidth(), $this->dimension->getHeight()), $palette->color($this->backgroundColor->getColor()));
     $font = ImagineFactory::createFontInstance($this->instanceType, __DIR__ . '/resource/mplus.ttf', $fontSize, $palette->color($this->stringColor->getColor()));
     $textProperties = $font->box($this->text);
     $image->draw()->text($this->text, $font, new Point(($this->dimension->getWidth() - $textProperties->getWidth()) / 2, ($this->dimension->getHeight() - $textProperties->getHeight()) / 2));
     if ($toFile !== null) {
         $image->save($toFile);
     }
     return new Result($image, $toFile);
 }

 /**
  * {@inheritdoc}
  */
 public function load(ImageInterface $image, array $options = array())
 {
     $background = new Color(isset($options['color']) ? $options['color'] : '#fff', isset($options['transparency']) ? $options['transparency'] : 0);
     $topLeft = new Point(0, 0);
     $size = $image->getSize();
     if (isset($options['size'])) {
         list($width, $height) = $options['size'];
         $size = new Box($width, $height);
         $topLeft = new Point(($width - $image->getSize()->getWidth()) / 2, ($height - $image->getSize()->getHeight()) / 2);
     }
     $canvas = $this->imagine->create($size, $background);
     return $canvas->paste($image, $topLeft);
 }

 /**
  * {@inheritDoc}
  */
 public function apply(ImageInterface $image)
 {
     if ($this->size) {
         list($width, $height) = $this->size;
         $size = new Box($width, $height);
         $topLeft = new Point(($width - $image->getSize()->getWidth()) / 2, ($height - $image->getSize()->getHeight()) / 2);
     } else {
         $topLeft = new Point(0, 0);
         $size = $image->getSize();
     }
     $background = $image->palette()->color($this->color);
     $canvas = $this->imagine->create($size, $background);
     return $canvas->paste($image, $topLeft);
 }

 protected function doRotate($x, $y, $angle)
 {
     list($currentImage, $point) = $this->getCurrentClip();
     $size = $currentImage->getSize();
     $y = $size->getHeight() - $y;
     $pointsToRotate = array(new Point(0, 0), new Point($size->getWidth(), 0), new Point($size->getWidth(), $size->getHeight()), new Point(0, $size->getHeight()));
     $xs = array();
     $ys = array();
     $rotatePoint = new Point($x, $y);
     foreach ($pointsToRotate as $pointToRotate) {
         $rotatedPoint = $this->rotatePoint($angle, $pointToRotate, $rotatePoint);
         $xs[] = $rotatedPoint->getX();
         $ys[] = $rotatedPoint->getY();
     }
     $firstPoint = new Point(min($xs), min($ys));
     $diagonalPoint = new Point(max($xs), max($ys));
     $middlePoint = new Point(($diagonalPoint->getX() - $firstPoint->getX()) / 2, ($diagonalPoint->getY() - $firstPoint->getY()) / 2);
     $width = $diagonalPoint->getX() - $firstPoint->getX();
     $height = $diagonalPoint->getY() - $firstPoint->getY();
     $image = $this->imagine->create($size);
     $angleInDegrees = rad2deg($angle);
     $clipPoint = new Point(0, 0);
     $rotatePoint = new Point(-$middlePoint->getX() + $x, -$middlePoint->getY() + $y);
     $this->state['clips'][] = array($image, $clipPoint, $angleInDegrees, $rotatePoint);
 }

 /**
  * Re-sizes the image. If $height is not specified, it will default to $width, creating a square.
  *
  * @param int      $targetWidth
  * @param int|null $targetHeight
  *
  * @return Image
  */
 public function resize($targetWidth, $targetHeight = null)
 {
     $this->normalizeDimensions($targetWidth, $targetHeight);
     if ($this->_isAnimatedGif) {
         $this->_image->layers()->coalesce();
         // Create a new image instance to avoid object references messing up our dimensions.
         $newSize = new \Imagine\Image\Box($targetWidth, $targetHeight);
         $gif = $this->_instance->create($newSize);
         $gif->layers()->remove(0);
         foreach ($this->_image->layers() as $layer) {
             $resizedLayer = $layer->resize($newSize, $this->_getResizeFilter());
             $gif->layers()->add($resizedLayer);
             // Let's update dateUpdated in case this is going to take awhile.
             if ($index = craft()->assetTransforms->getActiveTransformIndexModel()) {
                 craft()->assetTransforms->storeTransformIndexData($index);
             }
         }
         $this->_image = $gif;
     } else {
         if (craft()->images->isImagick()) {
             $this->_image->smartResize(new \Imagine\Image\Box($targetWidth, $targetHeight), (bool) craft()->config->get('preserveImageColorProfiles'), $this->_quality);
         } else {
             $this->_image->resize(new \Imagine\Image\Box($targetWidth, $targetHeight), $this->_getResizeFilter());
         }
     }
     return $this;
 }

	/**
	 * Re-sizes the image. If $height is not specified, it will default to $width, creating a square.
	 *
	 * @param int      $targetWidth
	 * @param int|null $targetHeight
	 *
	 * @return Image
	 */
	public function resize($targetWidth, $targetHeight = null)
	{
		$this->_normalizeDimensions($targetWidth, $targetHeight);

		if ($this->_isAnimatedGif)
		{

			// Create a new image instance to avoid object references messing up our dimensions.
			$newSize = new \Imagine\Image\Box($targetWidth, $targetHeight);
			$gif = $this->_instance->create($newSize);
			$gif->layers()->remove(0);

			foreach ($this->_image->layers() as $layer)
			{
				$resizedLayer = $layer->resize($newSize, $this->_getResizeFilter());
				$gif->layers()->add($resizedLayer);
			}

			$this->_image = $gif;
		}
		else
		{
			$this->_image->resize(new \Imagine\Image\Box($targetWidth, $targetHeight), $this->_getResizeFilter());
		}

		return $this;
	}

 /**
  * Generate the static map image and add blips to it if any are found
  *
  * @return ImageInterface The resulting image
  *
  * @return void
  */
 public function generate()
 {
     $box = Geo::calculateBox($this->size, $this->centerPoint);
     $this->resultImage = $this->imagine->create($box['base']);
     $jj = 0;
     $xStart = $box['tiles']['start']->getX();
     $xStop = $box['tiles']['stop']->getX();
     $yStart = $box['tiles']['start']->getY();
     $yStop = $box['tiles']['stop']->getY();
     for ($i = $yStart - 1; $i < $yStop; $i++) {
         $ii = 0;
         for ($j = $xStart - 1; $j < $xStop; $j++) {
             $this->addTile($this->tiles->getTile($j, $i), new Point($ii * Geo::TILE_SIZE, $jj * Geo::TILE_SIZE));
             $ii++;
         }
         $jj++;
     }
     $this->loader->run();
     $this->resultImage->crop($box['crop'], $this->size);
     foreach ($this->blips as $blip) {
         $this->drawBlip($blip);
     }
     $this->loader->run();
     return $this->resultImage;
 }

 /**
  * Creates an image object
  *
  * @param array|\Imagine\Image\ImageInterface $source
  * @throws \InvalidArgumentException On unsupported source type
  * @return \Imagine\Image\ImageInterface
  */
 public function create($source)
 {
     if ($source instanceof ImageInterface) {
         return $source;
     }
     if (isset($source['file'])) {
         return $this->imagine->open($source['file']);
     }
     if (isset($source['data'])) {
         return $this->imagine->load($source['data']);
     }
     if (isset($source['resource'])) {
         return $this->imagine->read($source['resource']);
     }
     if (isset($source['width']) && isset($source['height'])) {
         return $this->imagine->create(new Box($source['width'], $source['height']));
     }
     throw new InvalidArgumentException();
 }

 public function getImagineImage(ImagineInterface $imagine, FontCollection $fontCollection, $width, $height)
 {
     $fontPath = $fontCollection->getFontById($this->font)->getPath();
     if ($this->getAbsoluteSize() !== null) {
         $fontSize = $this->getAbsoluteSize();
     } elseif ($this->getRelativeSize() !== null) {
         $fontSize = (int) $this->getRelativeSize() / 100 * $height;
     } else {
         throw new \LogicException('Either relative or absolute watermark size must be set!');
     }
     if (true || !class_exists('ImagickDraw')) {
         // Fall back to ugly image.
         $palette = new \Imagine\Image\Palette\RGB();
         $font = $imagine->font($fontPath, $fontSize, $palette->color('#000'));
         $box = $font->box($this->getText());
         $watermarkImage = $imagine->create($box, $palette->color('#FFF'));
         $watermarkImage->draw()->text($this->text, $font, new \Imagine\Image\Point(0, 0));
     } else {
         // CURRENTLY DISABLED.
         // Use nicer Imagick implementation.
         // Untested!
         // @todo Test and implement it!
         $draw = new \ImagickDraw();
         $draw->setFont($fontPath);
         $draw->setFontSize($fontSize);
         $draw->setStrokeAntialias(true);
         //try with and without
         $draw->setTextAntialias(true);
         //try with and without
         $draw->setFillColor('#fff');
         $textOnly = new \Imagick();
         $textOnly->newImage(1400, 400, "transparent");
         //transparent canvas
         $textOnly->annotateImage($draw, 0, 0, 0, $this->text);
         //Create stroke
         $draw->setFillColor('#000');
         //same as stroke color
         $draw->setStrokeColor('#000');
         $draw->setStrokeWidth(8);
         $strokeImage = new \Imagick();
         $strokeImage->newImage(1400, 400, "transparent");
         $strokeImage->annotateImage($draw, 0, 0, 0, $this->text);
         //Composite text over stroke
         $strokeImage->compositeImage($textOnly, \Imagick::COMPOSITE_OVER, 0, 0, \Imagick::CHANNEL_ALPHA);
         $strokeImage->trimImage(0);
         //cut transparent border
         $watermarkImage = $imagine->load($strokeImage->getImageBlob());
         //$strokeImage->resizeImage(300,0, \Imagick::FILTER_CATROM, 0.9, false); //resize to final size
     }
     return $watermarkImage;
 }

 public function apply(ImageInterface &$image, ImagineInterface $imagine)
 {
     $box = $image->getSize();
     // x and y is the center of the crop
     $x = Helper::percentValue($this->_x, $boxw = $box->getWidth());
     $y = Helper::percentValue($this->_y, $boxh = $box->getHeight());
     $w = Helper::percentValue($this->_width, $boxw);
     $h = Helper::percentValue($this->_height, $boxh);
     if ($this->_ratio) {
         switch ($this->_ratio) {
             case self::COVER:
                 Helper::scaleSize($w, $h, $box);
                 $w = $h = min($w, $h);
                 break;
             case self::CONTAIN:
                 Helper::scaleSize($w, $h, $box);
                 $max = max($w, $h);
                 $img = $imagine->create(new Box($max, $max), new Color(0, 100));
                 $img->paste($image, new Point(($max - $boxw) * 0.5, ($max - $boxh) * 0.5));
                 $image = $img;
                 return;
             default:
                 // custom ratio
                 $this->fitByRatio($w, $h, $w && $h ? $w / $h : 0);
                 if (!$w || !$h) {
                     throw new \RuntimeException('Invalid ratio supplied');
                 }
                 break;
         }
     } else {
         Helper::scaleSize($w, $h, $box);
     }
     $halfw = $w / 2;
     $halfh = $h / 2;
     if ($x + $halfw > $boxw) {
         $x = $boxw - $halfw;
     }
     if ($y + $halfh > $boxh) {
         $y = $boxh - $halfh;
     }
     if ($x < $halfw) {
         $x = $halfw;
     }
     if ($y < $halfh) {
         $y = $halfh;
     }
     $image->crop(new Point($x - $w / 2, $y - $h / 2), new Box($w, $h));
 }

 /**
  * Re-sizes the image. If $height is not specified, it will default to $width, creating a square.
  *
  * @param int      $targetWidth
  * @param int|null $targetHeight
  *
  * @return Image
  */
 public function resize($targetWidth, $targetHeight = null)
 {
     $this->normalizeDimensions($targetWidth, $targetHeight);
     if ($this->_isAnimatedGif) {
         // Create a new image instance to avoid object references messing up our dimensions.
         $newSize = new \Imagine\Image\Box($targetWidth, $targetHeight);
         $gif = $this->_instance->create($newSize);
         $gif->layers()->remove(0);
         foreach ($this->_image->layers() as $layer) {
             $resizedLayer = $layer->resize($newSize, $this->_getResizeFilter());
             $gif->layers()->add($resizedLayer);
         }
         $this->_image = $gif;
     } else {
         if (craft()->images->isImagick()) {
             $this->_image->smartResize(new \Imagine\Image\Box($targetWidth, $targetHeight), (bool) craft()->config->get('preserveImageColorProfiles'), $this->_quality);
         } else {
             $this->_image->resize(new \Imagine\Image\Box($targetWidth, $targetHeight), $this->_getResizeFilter());
         }
     }
     return $this;
 }

 /**
  * Process image resizing, with borders or cropping. If $dest_width and $dest_height
  * are both null, no resize is performed.
  *
  * @param  ImagineInterface $imagine     the Imagine instance
  * @param  ImageInterface   $image       the image to process
  * @param  int              $dest_width  the required width
  * @param  int              $dest_height the required height
  * @param  int              $resize_mode the resize mode (crop / bands / keep image ratio)p
  * @param  string           $bg_color    the bg_color used for bands
  * @param  bool             $allow_zoom  if true, image may be zoomed to matchrequired size. If false, image is not zoomed.
  * @return ImageInterface   the resized image.
  */
 protected function applyResize(ImagineInterface $imagine, ImageInterface $image, $dest_width, $dest_height, $resize_mode, $bg_color, $allow_zoom = false)
 {
     if (!(is_null($dest_width) && is_null($dest_height))) {
         $width_orig = $image->getSize()->getWidth();
         $height_orig = $image->getSize()->getHeight();
         $ratio = $width_orig / $height_orig;
         if (is_null($dest_width)) {
             $dest_width = $dest_height * $ratio;
         }
         if (is_null($dest_height)) {
             $dest_height = $dest_width / $ratio;
         }
         if (is_null($resize_mode)) {
             $resize_mode = self::KEEP_IMAGE_RATIO;
         }
         $width_diff = $dest_width / $width_orig;
         $height_diff = $dest_height / $height_orig;
         $delta_x = $delta_y = $border_width = $border_height = 0;
         if ($width_diff > 1 && $height_diff > 1) {
             $resize_width = $width_orig;
             $resize_height = $height_orig;
             // When cropping, be sure to always generate an image which is
             //  no smaller than the required size, zooming it if required.
             if ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
                 if ($allow_zoom) {
                     if ($width_diff > $height_diff) {
                         $resize_width = $dest_width;
                         $resize_height = intval($height_orig * $dest_width / $width_orig);
                         $delta_y = ($resize_height - $dest_height) / 2;
                     } else {
                         $resize_height = $dest_height;
                         $resize_width = intval($width_orig * $resize_height / $height_orig);
                         $delta_x = ($resize_width - $dest_width) / 2;
                     }
                 } else {
                     // No zoom : final image may be smaller than the required size.
                     $dest_width = $resize_width;
                     $dest_height = $resize_height;
                 }
             }
         } elseif ($width_diff > $height_diff) {
             // Image height > image width
             $resize_height = $dest_height;
             $resize_width = intval($width_orig * $resize_height / $height_orig);
             if ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
                 $resize_width = $dest_width;
                 $resize_height = intval($height_orig * $dest_width / $width_orig);
                 $delta_y = ($resize_height - $dest_height) / 2;
             } elseif ($resize_mode != self::EXACT_RATIO_WITH_BORDERS) {
                 $dest_width = $resize_width;
             }
         } else {
             // Image width > image height
             $resize_width = $dest_width;
             $resize_height = intval($height_orig * $dest_width / $width_orig);
             if ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
                 $resize_height = $dest_height;
                 $resize_width = intval($width_orig * $resize_height / $height_orig);
                 $delta_x = ($resize_width - $dest_width) / 2;
             } elseif ($resize_mode != self::EXACT_RATIO_WITH_BORDERS) {
                 $dest_height = $resize_height;
             }
         }
         $image->resize(new Box($resize_width, $resize_height));
         if ($resize_mode == self::EXACT_RATIO_WITH_BORDERS) {
             $border_width = intval(($dest_width - $resize_width) / 2);
             $border_height = intval(($dest_height - $resize_height) / 2);
             $canvas = new Box($dest_width, $dest_height);
             return $imagine->create($canvas, $bg_color)->paste($image, new Point($border_width, $border_height));
         } elseif ($resize_mode == self::EXACT_RATIO_WITH_CROP) {
             $image->crop(new Point($delta_x, $delta_y), new Box($dest_width, $dest_height));
         }
     }
     return $image;
 }

 /**
  * @param string $inFilename
  * @param Image  $spec
  * @param string $outFilename
  */
 public function convert($inFilename, Specification $spec, $outFilename)
 {
     $image = $this->imagine->open($inFilename);
     $options = array();
     if ($spec->getFormat()) {
         $options['format'] = $spec->getFormat();
     }
     if ($spec->getQuality()) {
         if (!empty($options['format']) && $options['format'] === 'png') {
             $options['png_compression_level'] = floor($spec->getQuality() / 10);
             $options['png_compression_filter'] = $spec->getQuality() % 10;
         } elseif (!empty($options['format']) && $options['format'] === 'jpg') {
             $options['jpeg_quality'] = $spec->getQuality();
         }
     }
     if ($spec->getColorspace()) {
         $image->strip();
         switch ($spec->getColorspace()) {
             case 'cmyk':
                 $image->usePalette(new CMYK());
                 break;
             case 'grayscale':
                 $image->usePalette(new Grayscale());
                 break;
             default:
                 $image->usePalette(new RGB());
         }
     }
     if ($spec->getScale()) {
         if ($spec->getScale() === 'up') {
             // only scale up
         } elseif ($spec->getScale() === 'down') {
             // only scale down
         }
     }
     $method = $spec->getResizeMode();
     if ($method === Image::RESIZE_METHOD_WIDTH) {
         $specSize = $image->getSize()->widen($spec->getWidth());
         $image->resize($specSize);
     } elseif ($method === Image::RESIZE_METHOD_HEIGHT) {
         $specSize = $image->getSize()->heighten($spec->getHeight());
         $image->resize($specSize);
     } elseif ($method === Image::RESIZE_METHOD_EXACT) {
         $specSize = new Box($spec->getWidth(), $spec->getHeight());
         $image->resize($specSize);
     } elseif ($method === Image::RESIZE_METHOD_FIT) {
         $specSize = new Box($spec->getWidth(), $spec->getHeight());
         $image = $image->thumbnail($specSize, ImageInterface::THUMBNAIL_INSET);
     } elseif ($method === Image::RESIZE_METHOD_EXACT_FIT) {
         $specSize = new Box($spec->getWidth(), $spec->getHeight());
         $layer = $image->thumbnail($specSize, ImageInterface::THUMBNAIL_INSET);
         $layerSize = $layer->getSize();
         $palette = new RGB();
         if ($spec->getBackgroundColor()) {
             $color = $palette->color($spec->getBackgroundColor(), 100);
         } else {
             $color = $palette->color('#fff', 0);
         }
         $image = $this->imagine->create($specSize, $color);
         $image->paste($layer, new Point(floor(($specSize->getWidth() - $layerSize->getWidth()) / 2), floor(($specSize->getHeight() - $layerSize->getHeight()) / 2)));
     } elseif ($method === Image::RESIZE_METHOD_CROP) {
         $specSize = new Box($spec->getWidth(), $spec->getHeight());
         $imageSize = $image->getSize();
         if (!$specSize->contains($imageSize)) {
             $ratios = array($specSize->getWidth() / $imageSize->getWidth(), $specSize->getHeight() / $imageSize->getHeight());
             $ratio = max($ratios);
             if (!$imageSize->contains($specSize)) {
                 $imageSize = new Box(min($imageSize->getWidth(), $specSize->getWidth()), min($imageSize->getHeight(), $specSize->getHeight()));
             } else {
                 $imageSize = $imageSize->scale($ratio);
                 $image->resize($imageSize);
             }
             if ($spec->getCenterX() && $spec->getCenterY()) {
                 $point = new Point($spec->getCenterX(), $spec->getCenterY());
             } else {
                 $point = new Point(max(0, round(($imageSize->getWidth() - $specSize->getWidth()) / 2)), max(0, round(($imageSize->getHeight() - $specSize->getHeight()) / 2)));
             }
             $image->crop($point, $specSize);
         }
     }
     $image->save($outFilename, $options);
 }

 /**
  * (non-PHPdoc)
  * @see Imagine\Filter\FilterInterface::apply()
  */
 public function apply(ImageInterface $image)
 {
     $canvas = $this->imagine->create($this->size, $this->background);
     $canvas->paste($image, $this->placement);
     return $canvas;
 }