/**
* @param $parameters
* @param \Imagine\Image\BoxInterface $size
*
* @return array
*/
protected function getHeightWidth($parameters, $size)
{
$newWidth = $parameters['x'];
$newHeight = $parameters['y'];
// retina x2
if ($parameters['retina']) {
$newWidth = $parameters['x'] * 2;
$newHeight = $parameters['x'] * 2;
}
// calculate height when not set
if (!$newHeight) {
$newHeight = $size->getHeight() / $size->getWidth() * $newWidth;
}
// calculate width when not set
if (!$newWidth) {
$newWidth = $size->getWidth() / $size->getHeight() * $newHeight;
}
// if image is smaller keep ratio
// e.g. when a square image is requested (200x200) and the original image is smaller (150x100)
// it still returns a squared image (100x100)
if ($parameters['forceRatio']) {
if ($newWidth > $size->getWidth()) {
list($newHeight, $newWidth) = $this->getSizeInSameRatio($newHeight, $newWidth, $size->getWidth());
}
if ($newHeight > $size->getHeight()) {
list($newWidth, $newHeight) = $this->getSizeInSameRatio($newWidth, $newHeight, $size->getHeight());
}
}
return [$newWidth, $newHeight];
}
public function create(BoxInterface $size, ColorInterface $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
if ($color === null) {
$palette = self::$rgb;
$color = '#ffffff';
$alpha = 0;
} else {
$palette = $color->getPalette();
$alpha = $color->getAlpha() / 100;
}
try {
$pixel = new \GmagickPixel((string) $color);
$pixel->setcolorvalue(\Gmagick::COLOR_OPACITY, $alpha);
// does nothing as of Gmagick 1.1.7RC2. Background will be fully opaque.
$magick = new \Gmagick();
$magick->newimage($width, $height, $pixel->getcolor(false));
$magick->setimagecolorspace(\Gmagick::COLORSPACE_TRANSPARENT);
$magick->setimagebackgroundcolor($pixel);
return new RImage($magick, $palette, self::$emptyBag, array($width, $height));
} catch (\Exception $e) {
throw new \Imagine\Exception\RuntimeException("Gmagick: could not create empty image. {$e->getMessage()}", $e->getCode(), $e);
}
}
/**
* (non-PHPdoc)
* @see Imagine\Image\ImagineInterface::create()
*/
public function create(BoxInterface $size, Color $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
$color = null !== $color ? $color : new Color('fff');
try {
$pixel = new \ImagickPixel((string) $color);
$pixel->setColorValue(
\Imagick::COLOR_OPACITY,
number_format(abs(round($color->getAlpha() / 100, 1)), 1)
);
$imagick = new \Imagick();
$imagick->newImage($width, $height, $pixel);
$imagick->setImageMatte(true);
$imagick->setImageBackgroundColor($pixel);
$pixel->clear();
$pixel->destroy();
return new Image($imagick);
} catch (\ImagickException $e) {
throw new RuntimeException(
'Could not create empty image', $e->getCode(), $e
);
}
}
/**
* {@inheritdoc}
*/
public function apply(ImageInterface $image)
{
$currentSize = $image->getSize();
$ratioCurrent = $currentSize->getHeight() / $currentSize->getWidth();
$ratioNew = $this->size->getHeight() / $this->size->getWidth();
// ratio inverse of original and thumb image
$ratioInverseNew = 1 / $ratioNew;
// image has to crop
if ($ratioCurrent != $ratioNew) {
if ($this->size->getWidth() > $this->size->getHeight()) {
$cropHeight = $currentSize->getWidth() * $ratioNew;
$cropWidth = $currentSize->getWidth();
if ($cropHeight > $currentSize->getHeight()) {
$correction = 1 / ($cropHeight / $currentSize->getHeight());
$cropWidth *= $correction;
$cropHeight *= $correction;
}
} else {
$cropWidth = $currentSize->getHeight() * $ratioInverseNew;
$cropHeight = $currentSize->getHeight();
if ($cropWidth > $currentSize->getWidth()) {
$correction = 1 / ($cropWidth / $currentSize->getWidth());
$cropWidth *= $correction;
$cropHeight *= $correction;
}
}
$cropSize = new Box($cropWidth, $cropHeight);
$startPoint = $this->gravity->getStartPoint($cropSize);
$image = $image->crop($startPoint, $cropSize);
}
return $image->resize($this->size);
}
/**
* (non-PHPdoc)
* @see Imagine\Image\ImagineInterface::create()
*/
public function create(BoxInterface $size, Color $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
$resource = imagecreatetruecolor($width, $height);
if (false === $resource) {
throw new RuntimeException('Create operation failed');
}
$color = $color ? $color : new Color('fff');
if (false === imagealphablending($resource, false) || false === imagesavealpha($resource, true)) {
throw new RuntimeException('Could not set alphablending, savealpha and antialias values');
}
if (function_exists('imageantialias')) {
imageantialias($resource, true);
}
$index = imagecolorallocatealpha($resource, $color->getRed(), $color->getGreen(), $color->getBlue(), round(127 * $color->getAlpha() / 100));
if (false === $index) {
throw new RuntimeException('Unable to allocate color');
}
if (false === imagefill($resource, 0, 0, $index)) {
throw new RuntimeException('Could not set background color fill');
}
if ($color->getAlpha() >= 95) {
imagecolortransparent($resource, $index);
}
return new Image($resource, $this);
}
/**
* {@inheritdoc}
*/
public function create(BoxInterface $size, ColorInterface $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
$resource = imagecreatetruecolor($width, $height);
if (false === $resource) {
throw new RuntimeException('Create operation failed');
}
$palette = null !== $color ? $color->getPalette() : new RGB();
$color = $color ? $color : $palette->color('fff');
if (!$color instanceof RGBColor) {
throw new InvalidArgumentException('GD driver only supports RGB colors');
}
$index = imagecolorallocatealpha($resource, $color->getRed(), $color->getGreen(), $color->getBlue(), round(127 * $color->getAlpha() / 100));
if (false === $index) {
throw new RuntimeException('Unable to allocate color');
}
if (false === imagefill($resource, 0, 0, $index)) {
throw new RuntimeException('Could not set background color fill');
}
if ($color->getAlpha() >= 95) {
imagecolortransparent($resource, $index);
}
return $this->wrap($resource, $palette);
}
/**
* {@inheritdoc}
*/
public function create(BoxInterface $size, ColorInterface $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
$palette = null !== $color ? $color->getPalette() : new RGB();
$color = null !== $color ? $color : $palette->color('fff');
try {
$gmagick = new \Gmagick();
// Gmagick does not support creation of CMYK GmagickPixel
// see https://bugs.php.net/bug.php?id=64466
if ($color instanceof CMYKColor) {
$switchPalette = $palette;
$palette = new RGB();
$pixel = new \GmagickPixel($palette->color((string) $color));
} else {
$switchPalette = null;
$pixel = new \GmagickPixel((string) $color);
}
if ($color->getPalette()->supportsAlpha() && $color->getAlpha() < 100) {
throw new NotSupportedException('alpha transparency is not supported');
}
$gmagick->newimage($width, $height, $pixel->getcolor(false));
$gmagick->setimagecolorspace(\Gmagick::COLORSPACE_TRANSPARENT);
$gmagick->setimagebackgroundcolor($pixel);
$image = new Image($gmagick, $palette, new MetadataBag());
if ($switchPalette) {
$image->usePalette($switchPalette);
}
return $image;
} catch (\GmagickException $e) {
throw new RuntimeException('Could not create empty image', $e->getCode(), $e);
}
}
/**
* Modifies $width or $height (if one of them is empty) based on $box ratio.
* @param number|null $width Desired width
* @param number|null $height Desired height
* @param \Imagine\Image\BoxInterface $box Original box for a reference
*/
public static function scaleSize(&$width, &$height, \Imagine\Image\BoxInterface $box)
{
if (!$width || !$height) {
$r = $box->getWidth() / $box->getHeight();
if ($width) {
$height = floor($width / $r);
} else {
$width = floor($height * $r);
}
}
}
/**
* @param BoxInterface $imageSize
* @param array $settings
* @return array|mixed
*/
private function calculateRatio(BoxInterface $imageSize, array $settings)
{
$ratio = array();
if ($settings['height']) {
$ratio[] = $settings['height'] / $imageSize->getHeight();
}
if ($settings['width']) {
$ratio[] = $settings['width'] / $imageSize->getWidth();
}
$ratio = max($ratio);
return $ratio;
}
public function crop(PointInterface $start, BoxInterface $size)
{
if ($this->image === null) {
$this->load();
}
$width = $size->getWidth();
$height = $size->getHeight();
try {
$this->image->getGmagick()->cropimage($width, $height, $start->getX(), $start->getY());
} catch (\GmagickException $e) {
throw new \Imagine\Exception\RuntimeException("Gmagick: Crop operation failed. {$e->getMessage()}", $e->getCode(), $e);
}
$this->size = array($width, $height);
return $this;
}
/**
* @covers \Imagine\Filter\Advanced\Grayscale::apply
*
* @dataProvider getDataSet
*
* @param \Imagine\Image\BoxInterface $size
* @param \Imagine\Image\Color $color
* @param \Imagine\Image\Color $filteredColor
*/
public function testGrayscaling(BoxInterface $size, Color $color, Color $filteredColor)
{
$image = $this->getImage();
$imageWidth = $size->getWidth();
$imageHeight = $size->getHeight();
$size = $this->getMock('Imagine\\Image\\BoxInterface');
$size->expects($this->exactly($imageWidth + 1))->method('getWidth')->will($this->returnValue($imageWidth));
$size->expects($this->exactly($imageWidth * ($imageHeight + 1)))->method('getHeight')->will($this->returnValue($imageHeight));
$image->expects($this->any())->method('getSize')->will($this->returnValue($size));
$image->expects($this->exactly($imageWidth * $imageHeight))->method('getColorAt')->will($this->returnValue($color));
$draw = $this->getDrawer();
$draw->expects($this->exactly($imageWidth * $imageHeight))->method('dot')->with($this->isInstanceOf('Imagine\\Image\\Point'), $this->equalTo($filteredColor));
$image->expects($this->exactly($imageWidth * $imageHeight))->method('draw')->will($this->returnValue($draw));
$filter = new Grayscale();
$this->assertSame($image, $filter->apply($image));
}
/**
* {@inheritdoc}
*/
public function create(BoxInterface $size, ColorInterface $color = null)
{
if (null !== $color) {
throw new InvalidArgumentException('Imagine SVG does not support colors');
}
$document = new \DOMDocument();
$svg = $document->createElementNS('http://www.w3.org/2000/svg', 'svg');
$svg->setAttribute('version', '1.1');
if ($size->getWidth()) {
$svg->setAttribute('width', $size->getWidth());
}
if ($size->getHeight()) {
$svg->setAttribute('height', $size->getHeight());
}
$document->appendChild($svg);
return new Image($document, new MetadataBag());
}
/**
* (non-PHPdoc)
* @see Imagine\Image\ImagineInterface::create()
*/
public function create(BoxInterface $size, Color $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
$color = null !== $color ? $color : new Color('fff');
$gmagick = new \Gmagick();
$pixel = new \GmagickPixel((string) $color);
if ($color->getAlpha() > 0) {
// TODO: implement support for transparent background
throw new RuntimeException('alpha transparency not implemented');
}
$gmagick->newimage($width, $height, $pixel->getcolor(false));
$gmagick->setimagecolorspace(\Gmagick::COLORSPACE_TRANSPARENT);
// this is needed to propagate transparency
$gmagick->setimagebackgroundcolor($pixel);
return new Image($gmagick);
}
public function crop(PointInterface $start, BoxInterface $size)
{
if ($this->image === null) {
$this->load();
}
$width = $size->getWidth();
$height = $size->getHeight();
$magick = $this->image->getImagick();
try {
$magick->cropImage($width, $height, $start->getX(), $start->getY());
$magick->setImagePage(0, 0, 0, 0);
// Reset canvas for gif format
} catch (\ImagickException $e) {
throw new \Imagine\Exception\RuntimeException('Imagick: Crop operation failed', $e->getCode(), $e);
}
$this->size = array($width, $height);
return $this;
}
/**
* Calculates coordinates of top left corner of layer that should be positioned on canvas using given
* vertical and horizontal positions.
*
* @param BoxInterface $canvas_size Size of canvas
* @param BoxInterface $layer_size Size of layer
* @param string $horizontal_position left|center|right
* @param string $vertical_position top|center|bottom
* @param BoxInterface|null $padding Optional padding between canvas and layer sides.
*
* @return Point
*/
public static function positionLayerOnCanvas(BoxInterface $canvas_size, BoxInterface $layer_size, $horizontal_position, $vertical_position, BoxInterface $padding = null)
{
$dest_x = $dest_y = 0;
$original_width = $canvas_size->getWidth();
$original_height = $canvas_size->getHeight();
if ($padding instanceof BoxInterface) {
$delta_x = $padding->getWidth();
$delta_y = $padding->getHeight();
} else {
$delta_x = 0;
$delta_y = 0;
}
$new_wt_width = $layer_size->getWidth();
$new_wt_height = $layer_size->getHeight();
if ($new_wt_width + $delta_x > $original_width) {
$new_wt_height = $new_wt_height * ($original_width - $delta_x) / $new_wt_width;
$new_wt_width = $original_width - $delta_x;
}
if ($new_wt_height > $original_height) {
$new_wt_width = $new_wt_width * ($original_height - $delta_y) / $new_wt_height;
$new_wt_height = $original_height - $delta_y;
}
if ($vertical_position == 'top') {
$dest_y = $delta_y;
} elseif ($vertical_position == 'center') {
$dest_y = (int) (($original_height - $new_wt_height) / 2);
} elseif ($vertical_position == 'bottom') {
$dest_y = $original_height - $new_wt_height - $delta_y;
}
if ($horizontal_position == 'left') {
$dest_x = $delta_x;
} elseif ($horizontal_position == 'center') {
$dest_x = (int) (($original_width - $new_wt_width) / 2);
} elseif ($horizontal_position == 'right') {
$dest_x = $original_width - $new_wt_width - $delta_x;
}
if ($dest_x < 1) {
$dest_x = 0;
}
if ($dest_y < 1) {
$dest_y = 0;
}
return new Point($dest_x, $dest_y);
}
public function create(BoxInterface $size, ColorInterface $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
$color = self::getColor($color);
try {
$pixel = new \ImagickPixel($color['color']);
$pixel->setColorValue(\Imagick::COLOR_OPACITY, $color['alpha']);
$magick = new \Imagick();
$magick->newImage($width, $height, $pixel);
$magick->setImageMatte(true);
$magick->setImageBackgroundColor($pixel);
$pixel->clear();
$pixel->destroy();
return new RImage($magick, $color['palette'], self::$emptyBag, array($width, $height));
} catch (\Exception $e) {
throw new \Imagine\Exception\RuntimeException("Imagick: Could not create empty image {$e->getMessage()}", $e->getCode(), $e);
}
}
/**
* @param array | BoxInterface $data
*
* @throws \Zf2FileUploader\Filter\Thumbnail\Exception\InvalidArgumentException
* @return PathFilter
*/
public function getPathFilter($data)
{
if ($data instanceof BoxInterface) {
$width = $data->getWidth();
$height = $data->getHeight();
} else {
if (func_num_args() > 1) {
list($width, $height) = func_get_args();
} else {
if (is_array($data) && array_key_exists('width', $data) && array_key_exists('height', $data) || preg_match('/^(?P<width>[0-9]+)x(?P<height>[0-9]+)$/', $data, $data)) {
$width = $data['width'];
$height = $data['height'];
} else {
throw new Exception\InvalidArgumentException("Could not retrieve width and height from data");
}
}
}
return new PathFilter($width, $height);
}
/**
* {@inheritdoc}
*/
public function isEqualTo($coordinates)
{
if ($coordinates instanceof BoxInterface) {
$coordinates = new static($coordinates, new Point(0, 0), $coordinates);
}
if (!$coordinates instanceof ResizeCoordinatesInterface) {
throw new \InvalidArgumentException(sprintf('$coordinates must be an instance of ResizeCoordinatesInterface or BoxInterface, "%s" given', get_class($coordinates)));
}
/* @var ResizeCoordinatesInterface $coordinates */
return $this->cropStart->getX() === $coordinates->getCropStart()->getX() && $this->cropStart->getY() === $coordinates->getCropStart()->getY() && $this->cropSize->getWidth() === $coordinates->getCropSize()->getWidth() && $this->cropSize->getHeight() === $coordinates->getCropSize()->getHeight() && $this->size->getWidth() === $coordinates->getSize()->getWidth() && $this->size->getHeight() === $coordinates->getSize()->getHeight();
}
/**
* resizes image using a focal point
* @param ImageInterface $image an Imagine image
* @param BoxInterface $size size of resized imaga
* @param FocalPoint $focal focal point to use for size
* @param string $filter Imagine filter to use
* @return ImageInterface resized image
*/
public function resize(ImageInterface $image, BoxInterface $size, FocalPointInterface $focal, $filter = ImageInterface::FILTER_UNDEFINED)
{
$origSize = $image->getSize();
$origWidth = $origSize->getWidth();
$origHeight = $origSize->getHeight();
$width = $size->getWidth();
$height = $size->getHeight();
$ratioHeight = $origHeight / $height;
$ratioWidth = $origWidth / $width;
if ($ratioHeight < $ratioWidth) {
list($cropX1, $cropX2) = $this->calculateCrop($origWidth, $width, $focal->getX(), $ratioHeight);
$cropY1 = 0;
$cropY2 = $origHeight;
} else {
list($cropY1, $cropY2) = $this->calculateCrop($origHeight, $height, -$focal->getY(), $ratioWidth);
$cropX1 = 0;
$cropX2 = $origWidth;
}
$image->crop(new Point($cropX1, $cropY1), new Box($cropX2 - $cropX1, $cropY2 - $cropY1))->resize(new Box($width, $height, $filter));
return $image;
}
/**
* {@inheritdoc}
*/
public function thumbnail(BoxInterface $size, $mode = ImageInterface::THUMBNAIL_INSET, $filter = ImageInterface::FILTER_UNDEFINED)
{
if ($mode !== ImageInterface::THUMBNAIL_INSET && $mode !== ImageInterface::THUMBNAIL_OUTBOUND) {
throw new InvalidArgumentException('Invalid mode specified');
}
$imageSize = $this->getSize();
$ratios = array($size->getWidth() / $imageSize->getWidth(), $size->getHeight() / $imageSize->getHeight());
$thumbnail = $this->copy();
$thumbnail->usePalette($this->palette());
$thumbnail->strip();
// if target width is larger than image width
// AND target height is longer than image height
if ($size->contains($imageSize)) {
return $thumbnail;
}
if ($mode === ImageInterface::THUMBNAIL_INSET) {
$ratio = min($ratios);
} else {
$ratio = max($ratios);
}
if ($mode === ImageInterface::THUMBNAIL_OUTBOUND) {
if (!$imageSize->contains($size)) {
$size = new Box(min($imageSize->getWidth(), $size->getWidth()), min($imageSize->getHeight(), $size->getHeight()));
} else {
$imageSize = $thumbnail->getSize()->scale($ratio);
$thumbnail->resize($imageSize, $filter);
}
$thumbnail->crop(new Point(max(0, round(($imageSize->getWidth() - $size->getWidth()) / 2)), max(0, round(($imageSize->getHeight() - $size->getHeight()) / 2))), $size);
} else {
if (!$imageSize->contains($size)) {
$imageSize = $imageSize->scale($ratio);
$thumbnail->resize($imageSize, $filter);
} else {
$imageSize = $thumbnail->getSize()->scale($ratio);
$thumbnail->resize($imageSize, $filter);
}
}
return $thumbnail;
}
/**
* {@inheritdoc}
*/
public function create(BoxInterface $size, ColorInterface $color = null)
{
$width = $size->getWidth();
$height = $size->getHeight();
$palette = null !== $color ? $color->getPalette() : new RGB();
$color = null !== $color ? $color : $palette->color('fff');
try {
$pixel = new \ImagickPixel((string) $color);
$pixel->setColorValue(Imagick::COLOR_ALPHA, $color->getAlpha() / 100);
$imagick = new Imagick();
$imagick->newImage($width, $height, $pixel);
$imagick->setImageMatte(true);
$imagick->setImageBackgroundColor($pixel);
if (version_compare('6.3.1', $this->getVersion($imagick)) < 0) {
$imagick->setImageOpacity($pixel->getColorValue(Imagick::COLOR_ALPHA));
}
$pixel->clear();
$pixel->destroy();
return new Image($imagick, $palette, new MetadataBag());
} catch (\ImagickException $e) {
throw new RuntimeException('Could not create empty image', $e->getCode(), $e);
}
}
/**
* {@inheritdoc}
*/
public function in(BoxInterface $box)
{
return $this->x < $box->getWidth() && $this->y < $box->getHeight();
}
/**
* {@inheritdoc}
*
* @return ImageInterface
*/
public function resize(BoxInterface $size, $filter = ImageInterface::FILTER_UNDEFINED)
{
try {
$this->imagick->resizeImage($size->getWidth(), $size->getHeight(), $this->getFilter($filter), 1);
} catch (\ImagickException $e) {
throw new RuntimeException('Resize operation failed', $e->getCode(), $e);
}
return $this;
}
/**
* Internal
*
* Generates a GD image
*
* @param BoxInterface $size
* @param string the operation initiating the creation
*
* @return resource
*
* @throws RuntimeException
*
*/
private function createImage(BoxInterface $size, $operation)
{
$resource = imagecreatetruecolor($size->getWidth(), $size->getHeight());
if (false === $resource) {
throw new RuntimeException('Image ' . $operation . ' failed');
}
if (false === imagealphablending($resource, false) || false === imagesavealpha($resource, true)) {
throw new RuntimeException('Image ' . $operation . ' failed');
}
if (function_exists('imageantialias')) {
imageantialias($resource, true);
}
$transparent = imagecolorallocatealpha($resource, 255, 255, 255, 127);
imagefill($resource, 0, 0, $transparent);
imagecolortransparent($resource, $transparent);
return $resource;
}
/**
* {@inheritdoc}
*/
public function pieSlice(PointInterface $center, BoxInterface $size, $start, $end, ColorInterface $color, $fill = false, $thickness = 1)
{
$width = $size->getWidth();
$height = $size->getHeight();
$x1 = round($center->getX() + $width / 2 * cos(deg2rad($start)));
$y1 = round($center->getY() + $height / 2 * sin(deg2rad($start)));
$x2 = round($center->getX() + $width / 2 * cos(deg2rad($end)));
$y2 = round($center->getY() + $height / 2 * sin(deg2rad($end)));
if ($fill) {
$this->chord($center, $size, $start, $end, $color, true, $thickness);
$this->polygon(array($center, new Point($x1, $y1), new Point($x2, $y2)), $color, true, $thickness);
} else {
$this->arc($center, $size, $start, $end, $color, $thickness);
$this->line($center, new Point($x1, $y1), $color, $thickness);
$this->line($center, new Point($x2, $y2), $color, $thickness);
}
return $this;
}
/**
* {@inheritdoc}
*/
public function getStartPoint(BoxInterface $box)
{
return new Point($this->getX() - $box->getWidth() / 2, $this->getY() - $box->getHeight() / 2);
}
/**
* @param BoxInterface $originalSize
* @return string
*/
protected function getTestImage(BoxInterface $originalSize)
{
ob_start();
imagejpeg(imagecreatetruecolor($originalSize->getWidth(), $originalSize->getHeight()));
return ob_get_clean();
}
/**
*
* @param \Imagine\Image\BoxInterface $image
* @param \Imagine\Image\BoxInterface $boxToCenter
* @param integer $offsetY
* @return \Imagine\Image\PointInterface
*/
public function getStartingPointForCenteredBox(BoxInterface $image, BoxInterface $boxToCenter, $offsetY = 0)
{
$x = ($image->getWidth() - $boxToCenter->getWidth()) / 2;
return new Point($x, $offsetY);
}
/**
* {@inheritdoc}
*/
public function resize(BoxInterface $size, $filter = ImageInterface::FILTER_UNDEFINED)
{
static $supportedFilters = array(ImageInterface::FILTER_UNDEFINED => \Gmagick::FILTER_UNDEFINED, ImageInterface::FILTER_BESSEL => \Gmagick::FILTER_BESSEL, ImageInterface::FILTER_BLACKMAN => \Gmagick::FILTER_BLACKMAN, ImageInterface::FILTER_BOX => \Gmagick::FILTER_BOX, ImageInterface::FILTER_CATROM => \Gmagick::FILTER_CATROM, ImageInterface::FILTER_CUBIC => \Gmagick::FILTER_CUBIC, ImageInterface::FILTER_GAUSSIAN => \Gmagick::FILTER_GAUSSIAN, ImageInterface::FILTER_HANNING => \Gmagick::FILTER_HANNING, ImageInterface::FILTER_HAMMING => \Gmagick::FILTER_HAMMING, ImageInterface::FILTER_HERMITE => \Gmagick::FILTER_HERMITE, ImageInterface::FILTER_LANCZOS => \Gmagick::FILTER_LANCZOS, ImageInterface::FILTER_MITCHELL => \Gmagick::FILTER_MITCHELL, ImageInterface::FILTER_POINT => \Gmagick::FILTER_POINT, ImageInterface::FILTER_QUADRATIC => \Gmagick::FILTER_QUADRATIC, ImageInterface::FILTER_SINC => \Gmagick::FILTER_SINC, ImageInterface::FILTER_TRIANGLE => \Gmagick::FILTER_TRIANGLE);
if (!array_key_exists($filter, $supportedFilters)) {
throw new InvalidArgumentException('Unsupported filter type');
}
try {
$this->gmagick->resizeimage($size->getWidth(), $size->getHeight(), $supportedFilters[$filter], 1);
} catch (\GmagickException $e) {
throw new RuntimeException('Resize operation failed', $e->getCode(), $e);
}
return $this;
}
/**
* {@inheritdoc}
*/
public function thumbnail(BoxInterface $size, $mode = ImageInterface::THUMBNAIL_INSET)
{
if ($mode !== ImageInterface::THUMBNAIL_INSET && $mode !== ImageInterface::THUMBNAIL_OUTBOUND) {
throw new InvalidArgumentException('Invalid mode specified');
}
$width = $size->getWidth();
$height = $size->getHeight();
$thumbnail = $this->copy();
try {
if ($mode === ImageInterface::THUMBNAIL_INSET) {
$thumbnail->imagick->thumbnailImage($width, $height, true);
} elseif ($mode === ImageInterface::THUMBNAIL_OUTBOUND) {
$thumbnail->imagick->cropThumbnailImage($width, $height);
}
} catch (\ImagickException $e) {
throw new RuntimeException('Thumbnail operation failed', $e->getCode(), $e);
}
return $thumbnail;
}
