private function renderDistanceEuclidian()
{
$canvas = new \Imagick();
$canvas->newPseudoImage(500, 300, "canvas:none");
$canvas->setImageFormat('png');
$shadow = clone $canvas;
$text = clone $canvas;
$this->drawText($text);
$this->drawText($shadow, true);
if (false) {
$highlight = $this->getSilhouette($text);
$kernel = \ImagickKernel::fromBuiltIn(\Imagick::KERNEL_EUCLIDEAN, "1");
$highlight->morphology(\Imagick::MORPHOLOGY_DISTANCE, 1, $kernel);
$highlight->autoLevelImage();
$highlight->evaluateimage(\Imagick::EVALUATE_MULTIPLY, 0.6);
$highlight->evaluateimage(\Imagick::EVALUATE_ADD, 0.2 * \Imagick::getQuantum());
$highlight->levelImage(0.2, 1.4, 0.6);
$text->compositeimage($highlight, \Imagick::COMPOSITE_MODULATE, 0, 0);
}
if (true) {
$edge = $this->getSilhouette($text);
$kernel = \ImagickKernel::fromBuiltIn(\Imagick::KERNEL_OCTAGON, "2");
$edge->morphology(\Imagick::MORPHOLOGY_EDGE_IN, 1, $kernel);
$edge->compositeImage($text, \Imagick::COMPOSITE_ATOP, 0, 0);
}
$canvas->compositeImage($shadow, \Imagick::COMPOSITE_COPY, 0, 0);
$canvas->compositeImage($text, \Imagick::COMPOSITE_ATOP, 0, 0);
header("Content-Type: image/png");
echo $canvas->getImageBlob();
}
/**
*
* @param mixed color
* @param float opacity
*/
public function fx($color = 'black', $opacity = 0.3)
{
$this->im->setImageFormat('png');
$reflection = $this->im->clone();
$reflection->flipImage();
$gradient = new Imagick();
$gradient->newPseudoImage($reflection->getImageWidth(), $reflection->getImageHeight(), "gradient:transparent-{$color}");
$reflection->compositeImage($gradient, imagick::COMPOSITE_OVER, 0, 0);
$reflection->setImageOpacity($opacity);
$canvas = new Imagick();
$canvas->newImage($this->im->getImageWidth(), $this->im->getImageHeight() * 2, $color, "png");
$canvas->compositeImage($this->im, imagick::COMPOSITE_OVER, 0, 0);
$canvas->compositeImage($reflection, imagick::COMPOSITE_OVER, 0, $this->im->getImageHeight());
return $canvas;
}
function gradientRight($width, $height)
{
$imagick = new Imagick();
$imagick->newPseudoImage($width, $height, 'gradient:white-black');
$imagick->rotateImage('none', 90);
return $imagick;
}
public function renderImage3()
{
$gradient = new \Imagick();
$gradient->newPseudoImage(1, 256, "gradient:white-black");
$newImage = $gradient->fxImage("floor(u*10+0.5)/10");
$newImage->setimageformat('jpg');
header("Content-Type: image/jpg");
echo $newImage;
}
public function example4()
{
$graphWidth = 256;
$imagick = new \Imagick();
$imagick->newPseudoImage($graphWidth, 1, 'gradient:black-white');
$arguments = array(9, -90);
$imagick->functionImage(\Imagick::FUNCTION_SINUSOID, $arguments);
$fx = "(1.0/(1.0+exp(10.0*(0.5-u)))-0.006693)*1.0092503";
$fxImage = $imagick->fxImage($fx);
fxAnalyzeImage($fxImage);
}
public function render()
{
//Example ImagickPixel::getColorCount
$imagick = new \Imagick();
$imagick->newPseudoImage(640, 480, "magick:logo");
$histogramElements = $imagick->getImageHistogram();
$lastColor = array_pop($histogramElements);
$color = $lastColor->getColor();
$output = sprintf("ColorCount last pixel = %d\nColor is R %d G %d B %d", $lastColor->getColorCount(), $color['r'], $color['g'], $color['b']);
return nl2br($output);
//Example end
}
public function draw(OsuSignature $signature)
{
if (empty($this->hexColour)) {
$this->hexColour = $signature->getHexColour();
}
$composite = new Imagick();
$composite->newPseudoImage($this->getWidth(), $this->getHeight(), "canvas:transparent");
// Background
$draw = new ImagickDraw();
$draw->setFillColor(new ImagickPixel("#555555"));
$draw->rectangle(0, 0, $this->getWidth(), $this->getHeight());
$composite->drawImage($draw);
// Main bar
$level = $signature->getUser()['level'];
$xp = $level - floor($level);
$draw = new ImagickDraw();
$draw->setFillColor(new ImagickPixel($this->hexColour));
$draw->rectangle(0, 0, $this->getWidth() * $xp, $this->getHeight());
$composite->drawImage($draw);
// Bar end glow
$draw = new ImagickDraw();
$draw->setFillColor(new ImagickPixel('#ffffff'));
$draw->setFillOpacity(0.35);
$draw->rectangle($this->getWidth() * $xp - $this->getHeight(), 0, $this->getWidth() * $xp, $this->getHeight());
$composite->drawImage($draw);
// Text draw & metrics
$textDraw = new ImagickDraw();
$textDraw->setFillColor(new ImagickPixel('#555555'));
$textDraw->setFontSize(12);
$textDraw->setFont(ComponentLabel::FONT_DIRECTORY . ComponentLabel::FONT_REGULAR);
$textDraw->setGravity(Imagick::GRAVITY_NORTHWEST);
$metrics = $composite->queryFontMetrics($textDraw, 'lv' . floor($level));
// Text white bg
$draw = new ImagickDraw();
$draw->setFillColor(new ImagickPixel('#ffffff'));
$draw->rectangle(($this->getWidth() - $metrics['textWidth']) / 2 - 2, 0, ($this->getWidth() + $metrics['textWidth']) / 2 + 1, $this->getHeight());
$composite->drawImage($draw);
// Rounding
$roundMask = new Imagick();
$roundMask->newPseudoImage($this->getWidth(), $this->getHeight(), "canvas:transparent");
$draw = new ImagickDraw();
$draw->setFillColor(new ImagickPixel("black"));
$draw->roundRectangle(0, 0, $this->getWidth() - 1, $this->getHeight() - 1, $this->rounding, $this->rounding);
$roundMask->drawImage($draw);
$roundMask->setImageFormat('png');
$composite->compositeImage($roundMask, Imagick::COMPOSITE_DSTIN, 0, 0, Imagick::CHANNEL_ALPHA);
$signature->getCanvas()->compositeImage($composite, Imagick::COMPOSITE_DEFAULT, $this->x, $this->y);
// Level text
$signature->getCanvas()->annotateImage($textDraw, $this->x + ($this->getWidth() - $metrics['textWidth']) / 2, $this->y + ($this->getHeight() - $metrics['textHeight']) / 2 - 2, 0, 'lv' . floor($level));
}
function renderCustomImage()
{
$size = 400;
$imagick1 = new \Imagick();
//$imagick1->newPseudoImage($size, $size, 'gradient:black-white');
$imagick1->setColorspace(\Imagick::COLORSPACE_GRAY);
//$imagick1->setColorspace(\Imagick::COLORSPACE_RGB);
//$imagick1->setColorspace(\Imagick::COLORSPACE_SRGB);
$imagick1->setColorspace(\Imagick::COLORSPACE_CMYK);
$imagick1->newPseudoImage($size, $size, 'gradient:gray(100%)-gray(0%)');
$imagick1->setFormat('png');
//analyzeImage($imagick1);
header("Content-Type: image/png");
echo $imagick1->getImageBlob();
}
public function renderCustomImage()
{
$size = 200;
$imagick1 = new \Imagick();
$imagick1->newPseudoImage($size, $size, 'gradient:black-white');
$arguments = array(9, -90);
$imagick1->functionImage(\Imagick::FUNCTION_SINUSOID, $arguments);
$imagick2 = new \Imagick();
$imagick2->newPseudoImage($size, $size, 'gradient:black-white');
$arguments = array(0.5, 0);
$imagick2->functionImage(\Imagick::FUNCTION_SINUSOID, $arguments);
$imagick1->compositeimage($imagick2, \Imagick::COMPOSITE_MULTIPLY, 0, 0);
$imagick1->setimageformat('png');
header("Content-Type: image/png");
echo $imagick1->getImageBlob();
}
function gameSummary(&$canvas, $o)
{
$maxHeight = 910;
$width = 980;
$height = $maxHeight;
$plays = new Imagick();
$plays->newPseudoImage($width, $height, 'xc:none');
$teams = array();
$teams['V'] = fetchTeam($o['vTeam']);
$teams['H'] = fetchTeam($o['hTeam']);
$bodyHeight = 200;
$path = "http://www.sidearmstats.com/rpi/mhockey/1.xml";
$path = "sidearm.xml";
$path = $o['liveStatsXML'];
$scores = getGameSummaryInfo($path);
$vOffset = 0;
$lastPeriod = 0;
$playIndex = 0;
foreach ($scores->score as $score) {
$playIndex++;
if ($vOffset + 150 > $maxHeight && $o["numPlays"] == "auto") {
break;
} else {
if ($o["numPlays"] != "auto" && $o["numPlays"] + $o["startIndex"] < $playIndex) {
break;
}
}
if ($o["startIndex"] + 1 > $playIndex) {
continue;
}
if ($vOffset > 0) {
$plays->compositeImage(fillRectangle(960, 2, '#FFF'), imagick::COMPOSITE_OVER, 0, $vOffset);
}
if ($score['prd'] + 0 != $lastPeriod) {
$lastPeriod = $score['prd'] + 0;
$plays->compositeImage(periodLabel($lastPeriod), imagick::COMPOSITE_OVER, 0, $vOffset);
$vOffset += 50;
$plays->compositeImage(fillRectangle(960, 2, '#FFF'), imagick::COMPOSITE_OVER, 0, $vOffset);
}
$plays->compositeImage(scoringPlay($score, $teams), imagick::COMPOSITE_OVER, 0, $vOffset);
$vOffset += 100;
//print_r($score);
}
addGeoToCanvas($canvas, array('type' => 'flexBox', 'w' => 1920, 'h' => 1080, 'x' => 0, 'y' => 0, 'bodyText' => '', 'boxHeight' => $vOffset, 'boxWidth' => 1000, 'boxOffset' => 'auto', 'boxPadding' => 10, 'titleColor' => $o['barColor'], 'titleHeight' => '70', 'titleText' => $o['titleText'], 'titleGravity' => 'center', 'logoHeight' => 100, 'logoLeft' => $teams['H']['logo'], 'logoRight' => $teams['V']['logo']));
$canvas->compositeImage($plays, imagick::COMPOSITE_OVER, (1920 - 980) / 2, 1080 - 50 - $vOffset - 10);
}
function a0nCRQ($msg, $padx, $pady, $bc, $fc, $tc)
{
$im = new Imagick();
$idraw = new ImagickDraw();
$idraw->setFontSize(30);
$idraw->setFont('MyriadPro-Regular.otf');
$idraw->setGravity(Imagick::GRAVITY_CENTER);
$metrics = $im->queryFontMetrics($idraw, $msg);
$im->newPseudoImage($metrics["textWidth"] + $padx * 2, $metrics["textHeight"] + $pady * 2, "xc:none");
$idraw->setFillColor($fc);
$idraw->setStrokeColor($bc);
$idraw->roundrectangle(0, 0, $metrics["textWidth"] + $padx * 2 - 1, $metrics["textHeight"] + $pady * 2 - 1, 10, 10);
$idraw->setFillColor($tc);
$idraw->setStrokeColor($tc);
$idraw->annotation(0, 0, $msg);
$im->drawImage($idraw);
return $im;
}
function renderFontEffect()
{
$canvas = new \Imagick();
$canvas->newPseudoImage(500, 300, "canvas:none");
$canvas->setImageFormat('png');
$shadow = clone $canvas;
$text = clone $canvas;
drawText($text);
drawText($shadow, true);
$edge = getSilhouette($text);
$kernel = \ImagickKernel::fromBuiltIn(\Imagick::KERNEL_OCTAGON, "2");
$edge->morphology(\Imagick::MORPHOLOGY_EDGE_IN, 1, $kernel);
$edge->compositeImage($text, \Imagick::COMPOSITE_ATOP, 0, 0);
$canvas->compositeImage($shadow, \Imagick::COMPOSITE_COPY, 0, 0);
$canvas->compositeImage($text, \Imagick::COMPOSITE_ATOP, 0, 0);
header("Content-Type: image/png");
echo $canvas->getImageBlob();
}
public function generateFavicon()
{
$faviconConfigList = $this->_getFaviconConfigList();
$this->_getStreamOutput()->writeln('Generating favicons');
$themeDirStructList = Functional\map(CM_Site_Abstract::getAll(), function (CM_Site_Abstract $site) {
$render = new CM_Frontend_Render(new CM_Frontend_Environment($site));
return ['render' => $render, 'themeDir' => new CM_File($render->getThemeDir(true))];
});
$themeDirStructList = Functional\unique($themeDirStructList, function (array $themeDirStruct) {
/** @var CM_File $themeDir */
$themeDir = $themeDirStruct['themeDir'];
return $themeDir->getPath();
});
//filter site aliases
foreach ($themeDirStructList as $themeDirStruct) {
/** @var CM_Frontend_Render $render */
$render = $themeDirStruct['render'];
/** @var CM_File $themeDir */
$themeDir = $themeDirStruct['themeDir'];
$svgFile = $themeDir->joinPath('resource', 'img', self::FAVICON_SVG_FILENAME);
if ($svgFile->exists()) {
foreach ($faviconConfigList as $outputFilename => $config) {
$backgroundWidth = (int) $config['width'];
$backgroundHeight = (int) $config['height'];
$backgroundColor = false === $config['transparent'] ? $render->getLessVariable(self::FAVICON_BACKGROUND_LESS_VARIABLE) : 'transparent';
$background = new Imagick();
$background->newPseudoImage($backgroundWidth, $backgroundHeight, 'canvas:' . $backgroundColor);
$backgroundImage = new CM_Image_Image($background);
$iconSize = (int) (min($backgroundWidth, $backgroundHeight) * (double) $config['iconSize']);
$iconImage = CM_Image_Image::createFromSVGWithSize($svgFile->read(), $iconSize, $iconSize);
$backgroundImage->compositeImage($iconImage, ($backgroundWidth - $iconSize) / 2, ($backgroundHeight - $iconSize) / 2);
$backgroundImage->setFormat(CM_Image_Image::FORMAT_PNG);
$targetFile = $themeDir->joinPath('resource', 'img', 'meta', $outputFilename);
$targetFile->ensureParentDirectory();
$targetFile->write($backgroundImage->getBlob());
$this->_getStreamOutput()->writeln('Generated ' . $targetFile->getPath());
}
}
}
}
<?php
$im = new Imagick();
$im->newPseudoImage(100, 100, "XC:red");
$im->setImageFormat("png");
echo $im->width . "x" . $im->height . "\n";
echo $im->format;
<?php
$im = new Imagick();
$im->newPseudoImage(100, 100, "XC:red");
var_dump($im->getImageGeometry());
$im->newPseudoImage(0, 0, "magick:logo");
var_dump($im->getImageGeometry());
$im->readImage("magick:logo");
var_dump($im->getImageGeometry());
$im->newPseudoImage(0, 0, "rose:");
var_dump($im->getImageGeometry());
try {
$im->newPseudoImage(0, 0, "png:");
var_dump($im->getImageGeometry());
} catch (Exception $e) {
echo "fail\n";
}
function renderKernel(ImagickKernel $imagickKernel)
{
$matrix = $imagickKernel->getMatrix();
$imageMargin = 20;
$tileSize = 20;
$tileSpace = 4;
$shadowSigma = 4;
$shadowDropX = 20;
$shadowDropY = 0;
$radius = $tileSize / 2 * 0.9;
$rows = count($matrix);
$columns = count($matrix[0]);
$imagickDraw = new \ImagickDraw();
$imagickDraw->setFillColor('#afafaf');
$imagickDraw->setStrokeColor('none');
$imagickDraw->translate($imageMargin, $imageMargin);
$imagickDraw->push();
ksort($matrix);
foreach ($matrix as $row) {
ksort($row);
$imagickDraw->push();
foreach ($row as $cell) {
if ($cell !== false) {
$color = intval(255 * $cell);
$colorString = sprintf("rgb(%f, %f, %f)", $color, $color, $color);
$imagickDraw->setFillColor($colorString);
$imagickDraw->rectangle(0, 0, $tileSize, $tileSize);
}
$imagickDraw->translate($tileSize + $tileSpace, 0);
}
$imagickDraw->pop();
$imagickDraw->translate(0, $tileSize + $tileSpace);
}
$imagickDraw->pop();
$width = $columns * $tileSize + ($columns - 1) * $tileSpace;
$height = $rows * $tileSize + ($rows - 1) * $tileSpace;
$imagickDraw->push();
$imagickDraw->translate($width / 2, $height / 2);
$imagickDraw->setFillColor('rgba(0, 0, 0, 0)');
$imagickDraw->setStrokeColor('white');
$imagickDraw->circle(0, 0, $radius - 1, 0);
$imagickDraw->setStrokeColor('black');
$imagickDraw->circle(0, 0, $radius, 0);
$imagickDraw->pop();
$canvasWidth = $width + 2 * $imageMargin;
$canvasHeight = $height + 2 * $imageMargin;
$kernel = new \Imagick();
$kernel->newPseudoImage($canvasWidth, $canvasHeight, 'canvas:none');
$kernel->setImageFormat('png');
$kernel->drawImage($imagickDraw);
/* create drop shadow on it's own layer */
$canvas = $kernel->clone();
$canvas->setImageBackgroundColor(new \ImagickPixel('rgb(0, 0, 0)'));
$canvas->shadowImage(100, $shadowSigma, $shadowDropX, $shadowDropY);
$canvas->setImagePage($canvasWidth, $canvasHeight, -5, -5);
$canvas->cropImage($canvasWidth, $canvasHeight, 0, 0);
/* composite original text_layer onto shadow_layer */
$canvas->compositeImage($kernel, \Imagick::COMPOSITE_OVER, 0, 0);
$canvas->setImageFormat('png');
return $canvas;
}
public function draw(OsuSignature $signature)
{
parent::draw($signature);
$avatar = $this->getAvatar($signature->getUser());
if ($avatar) {
$fitByWidth = $this->getWidth() / $avatar->getImageWidth() < $this->getHeight() / $avatar->getImageHeight() ? true : false;
if ($fitByWidth) {
$avatar->thumbnailImage($this->getWidth(), 0, false);
} else {
$avatar->thumbnailImage(0, $this->getHeight(), false);
}
$avatarXOffset = ($this->getWidth() - $avatar->getImageWidth()) / 2;
$avatarYOffset = ($this->getHeight() - $avatar->getImageHeight()) / 2;
/*$avatar->resizeImage(
$this->getWidth(),
$this->get Height(),
1
Imagick::FILTER_CATROM
);*/
$avatarRounding = isset($_GET['avatarrounding']) ? max((int) $_GET['avatarrounding'], 0) : $this->rounding;
$avatar->setImageAlphaChannel(Imagick::ALPHACHANNEL_SET);
$roundImage = new Imagick();
$roundImage->newPseudoImage($this->getWidth(), $this->getHeight(), 'canvas:transparent');
$roundMask = new ImagickDraw();
$roundMask->setFillColor(new ImagickPixel('black'));
$roundMask->roundRectangle(0, 0, $avatar->getImageWidth() - 1, $avatar->getImageHeight() - 1, $avatarRounding, $avatarRounding);
$roundImage->drawImage($roundMask);
$roundImage->setImageFormat('png');
$avatar->compositeImage($roundImage, Imagick::COMPOSITE_DSTIN, 0, 0, Imagick::CHANNEL_ALPHA);
$signature->getCanvas()->compositeImage($avatar, Imagick::COMPOSITE_DEFAULT, $this->x + $avatarXOffset, $this->y + $avatarYOffset);
}
}
function renderImagePolynomial()
{
//TODO - this doesn't appear to work correctly.
// First two coefficents are used to hole global polynomal information
// c0 = Order of the polynimial being created
// c1 = number_of_terms in one polynomial equation
//
// Rest of the coefficients map to the equations....
// v = c0 + c1*x + c2*y + c3*x*y + c4*x^2 + c5*y^2 + c6*x^3 + ...
// for each 'value' (number_values of them) given.
// As such total coefficients = 2 + number_terms * number_values
//
// Input Arguments are sets of control points...
// For Distort Images order [u,v, x,y] ...
// For Sparse Gradients order [x,y, r,g,b] ...
//c0 + c1*x + c2*y + c3*x*y
$points = [1, 1, 0, 0, 0.25, 0, -1, 1, 0, 250, 0, 0.25, -1, 5, 100, 500, 0, 0, -1, 5];
// $points = [
// 1,
// 2, 1, 2,
// 1, 1, 2,
//// 3,
//// 4, 5, 1, 2,
//// 3, 4, 5, 2,
//// 1, 3, 4, 5,
// ];
//
//
$imagick = new \Imagick();
//$imagick->newImage(500, 500, "white");
$imagick->newPseudoImage(500, 500, 'gradient:black-white');
$imagick->setImageFormat("png");
$imagick->sparseColorImage(\Imagick::SPARSECOLORMETHOD_POLYNOMIAL, $points);
header("Content-Type: image/png");
echo $imagick->getImageBlob();
}
require_once 'Imagick.php';
die;
/* Read the image */
$im = new Imagick("sample.jpg");
/* Thumbnail the image */
$im->thumbnailImage(200, null);
/* Create a border for the image */
$im->borderImage(new ImagickPixel("white"), 5, 5);
/* Clone the image and flip it */
$reflection = $im->clone();
$reflection->flipImage();
/* Create gradient. It will be overlayed on the reflection */
$gradient = new Imagick();
/* Gradient needs to be large enough for the image and the borders */
$gradient->newPseudoImage($reflection->getImageWidth() + 10, $reflection->getImageHeight() + 10, "gradient:transparent-black");
/* Composite the gradient on the reflection */
$reflection->compositeImage($gradient, imagick::COMPOSITE_OVER, 0, 0);
/* Add some opacity. Requires ImageMagick 6.2.9 or later */
$reflection->setImageOpacity(0.3);
/* Create an empty canvas */
$canvas = new Imagick();
/* Canvas needs to be large enough to hold the both images */
$width = $im->getImageWidth() + 40;
$height = $im->getImageHeight() * 2 + 30;
$canvas->newImage($width, $height, new ImagickPixel("black"));
$canvas->setImageFormat("png");
/* Composite the original image and the reflection on the canvas */
$canvas->compositeImage($im, imagick::COMPOSITE_OVER, 20, 10);
$canvas->compositeImage($reflection, imagick::COMPOSITE_OVER, 20, $im->getImageHeight() + 10);
/* Output the image*/
/**
* Reflection.
* @param integer $height
* @param integer $opacity
* @param boolean $fade_in
*/
protected function _reflection($height, $opacity, $fade_in)
{
$reflection = $this->im->clone();
$reflection->flipImage();
$reflection->cropImage($this->width, $height, 0, 0);
$reflection->setImagePage($this->width, $height, 0, 0);
$direction = array('transparent', 'black');
if ($fade_in) {
$direction = array_reverse($direction);
}
$fade = new \Imagick();
$fade->newPseudoImage($reflection->getImageWidth(), $reflection->getImageHeight(), vsprintf('gradient:%s-%s', $direction));
$reflection->compositeImage($fade, \Imagick::COMPOSITE_DSTOUT, 0, 0);
$reflection->evaluateImage(\Imagick::EVALUATE_MULTIPLY, $opacity / 100, \Imagick::CHANNEL_ALPHA);
$image = new \Imagick();
$image->newImage($this->width, $this->height + $height, new \ImagickPixel());
$image->setImageAlphaChannel(\Imagick::ALPHACHANNEL_SET);
$image->setColorspace($this->im->getColorspace());
if ($image->compositeImage($this->im, \Imagick::COMPOSITE_SRC, 0, 0) && $image->compositeImage($reflection, \Imagick::COMPOSITE_OVER, 0, $this->height)) {
$this->im = $image;
$this->width = $this->im->getImageWidth();
$this->height = $this->im->getImageHeight();
}
}
function __construct($chemin)
{
if (filter_var($chemin, FILTER_VALIDATE_URL)) {
//URL
$headers = @get_headers($chemin);
if (strpos($headers[0], '404') != false) {
//NOT FOUND
//throw new \Exception("Not Found Image");
$this->image = new \Imagick();
$this->image->newImage(600, 600, new \ImagickPixel('white'));
/* Création d'un nouvel objet imagick */
$im = new \Imagick();
/* Création d'une nouvelle image. Elle sera utilisée comme masque de remplissage */
$im->newPseudoImage(50, 100, "gradient:gray-black");
/* Création d'un nouvel objet imagickdraw */
$draw = new \ImagickDraw();
/* On commence un nouveau masque nommé "gradient" */
$draw->pushPattern('gradient', 0, 0, 50, 110);
/* Ajout du dégradé sur le masque */
$draw->composite(\Imagick::COMPOSITE_OVER, 0, 0, 50, 110, $im);
/* Fermeture du masque */
$draw->popPattern();
/* Utilisation du masque nommé "gradient" comme remplissage */
$draw->setFillPatternURL('#gradient');
/* Définition de la taille du texte à 52 */
$draw->setFontSize(92);
$draw->setFont(ROOT . DS . 'font/comic.ttf');
/* Ajout d'un texte */
$draw->annotation(20, 100, "Not Found !");
$this->image->drawImage($draw);
}
} else {
if (!file_exists($chemin)) {
//throw new \Exception("Not Found Image");
$this->image = new \Imagick();
$this->image->newImage(600, 600, new \ImagickPixel('white'));
/* Création d'un nouvel objet imagick */
$im = new \Imagick();
/* Création d'une nouvelle image. Elle sera utilisée comme masque de remplissage */
$im->newPseudoImage(50, 100, "gradient:gray-black");
/* Création d'un nouvel objet imagickdraw */
$draw = new \ImagickDraw();
/* On commence un nouveau masque nommé "gradient" */
$draw->pushPattern('gradient', 0, 0, 50, 110);
/* Ajout du dégradé sur le masque */
$draw->composite(\Imagick::COMPOSITE_OVER, 0, 0, 50, 110, $im);
/* Fermeture du masque */
$draw->popPattern();
/* Utilisation du masque nommé "gradient" comme remplissage */
$draw->setFillPatternURL('#gradient');
/* Définition de la taille du texte à 52 */
$draw->setFontSize(92);
$draw->setFont(ROOT . DS . 'font/comic.ttf');
/* Ajout d'un texte */
$draw->annotation(20, 100, "Not Found !");
$this->image->drawImage($draw);
}
}
$this->image = new \Imagick($chemin);
$imageprops = $this->image->getImageGeometry();
$this->width = $imageprops['width'];
$this->height = $imageprops['height'];
$this->image->setImageFormat("jpeg");
}
function showImage(\Imagick $imagick1)
{
$backGround = new \Imagick();
$backGround->newPseudoImage($imagick1->getImageWidth(), $imagick1->getImageHeight(), 'pattern:checkerboard');
$backGround->compositeimage($imagick1, \Imagick::COMPOSITE_ATOP, 0, 0);
$backGround->setImageFormat('png');
header("Content-Type: image/png");
echo $backGround->getImageBlob();
}
/**
* Create a vignette
*
* Heavily inspired by Dejan Marjanovics article http://code.tutsplus.com/tutorials/create-instagram-filters-with-php--net-24504
*
* @param $imagickInstance
* @param string $color1
* @param string $color2
* @param float $crop_factor
*/
private function _vignette($imagickInstance, $color1 = 'none', $color2 = 'black', $crop_factor = 1.5)
{
$vignetteWidth = floor($imagickInstance->getImageWidth() * $crop_factor);
$vignetteHeight = floor($imagickInstance->getImageHeight() * $crop_factor);
$radial = new \Imagick();
$radial->newPseudoImage($vignetteWidth, $vignetteHeight, "radial-gradient:{$color1}-{$color2}");
$radial->setImageFormat('png32');
$imagickInstance->compositeImage($radial, \imagick::COMPOSITE_MULTIPLY, -($vignetteWidth - $imagickInstance->getImageWidth()) / 2, -($vignetteHeight - $imagickInstance->getImageHeight()) / 2);
}
public function addTextBox($text, $x1, $y1, $x2, $y2)
{
$textbox = new \Imagick();
$textbox->setFont(self::$config['font']);
$textbox->setBackgroundColor('transparent');
$textbox->setGravity(imagick::GRAVITY_CENTER);
// 'label' sticks the string on one line, whereas 'caption' will make a paragraph.
// Unfortunately, will happily split two words onto two lines which looks a bit silly
// if ($text has two words) then...
if (count(explode(" ", trim($text))) == 2) {
$method = 'label';
} else {
$method = 'caption';
}
$textbox->newPseudoImage($x2 - $x1, $y2 - $y1, $method . ":" . $text);
$this->image->compositeImage($textbox, imagick::COMPOSITE_OVER, $x1, $y1);
return $this;
}
/**
*
* @return bool
*/
public function reflectionEffect()
{
$source = $this->_getTempEditorFullPath();
$im = new Imagick($source[0]);
/* Thumbnail the image */
$im->thumbnailImage(200, null);
/* Create a border for the image */
$im->borderImage(new ImagickPixel("white"), 1, 1);
/* Clone the image and flip it */
$reflection = $im->clone();
$reflection->flipImage();
/* Create gradient. It will be overlayd on the reflection */
$gradient = new Imagick();
/* Gradient needs to be large enough for the image and the borders */
$gradient->newPseudoImage($reflection->getImageWidth() + 5, round($reflection->getImageHeight() / 2), "gradient:transparent-white");
/* Composite the gradient on the reflection */
$reflection->compositeImage($gradient, imagick::COMPOSITE_OVER, 0, 0);
/* Add some opacity. Requires ImageMagick 6.2.9 or later */
$reflection->setImageOpacity(0.2);
/* Create an empty canvas */
$canvas = new Imagick();
/* Canvas needs to be large enough to hold the both images */
$width = $im->getImageWidth() + 40;
$height = $im->getImageHeight() * 1.5 + 10;
$canvas->newImage($width, $height, new ImagickPixel("white"));
$canvas->setImageFormat("png");
/* Composite the original image and the reflection on the canvas */
$canvas->compositeImage($im, imagick::COMPOSITE_OVER, 20, 10);
$canvas->compositeImage($reflection, imagick::COMPOSITE_OVER, 20, $im->getImageHeight() + 10);
$canvas->writeImage($source[1]);
$this->getRawEditorCache();
return true;
}
public function renderImageArcsin()
{
//Example Imagick::functionImage ArcSin
$imagick = new \Imagick();
$imagick->newPseudoImage(500, 500, 'gradient:black-white');
$arguments = array($this->control->getFirstTerm());
$secondTerm = $this->control->getSecondTerm();
$thirdTerm = $this->control->getThirdTerm();
$fourthTerm = $this->control->getFourthTerm();
if (strlen($secondTerm)) {
$arguments[] = $secondTerm;
if (strlen($thirdTerm)) {
$arguments[] = $thirdTerm;
if (strlen($fourthTerm)) {
$arguments[] = $fourthTerm;
}
}
}
$imagick->functionImage(\Imagick::FUNCTION_ARCSIN, $arguments);
$imagick->setimageformat('png');
analyzeImage($imagick, 512, 256);
//Example end
}
/**
* 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();
}
/**
* Adds a vignette to the image
* @param string $color the colour of the vignette
* @param int $composition an imagick constant defining the composition to use
* @param float $crop_factor defines the strenth of the vignette
* @return Filter
*/
public function vignette($color, $composition = \Imagick::COMPOSITE_DEFAULT, $crop_factor = 1.5)
{
$height = $this->imagick()->getImageHeight();
$width = $this->imagick()->getImageWidth();
$crop_x = floor($height * $crop_factor);
$crop_y = floor($width * $crop_factor);
$overlay = new \Imagick();
$overlay->newPseudoImage($crop_x, $crop_y, "radial-gradient:rgba(0,0,0,0)-{$color}");
$this->imagick()->compositeImage($overlay, $composition, ($width - $crop_x) / 2, ($height - $crop_y) / 2);
return $this;
}
protected function _do_reflection($height, $opacity, $fade_in)
{
// Clone the current image and flip it for reflection
$reflection = $this->im->clone();
$reflection->flipImage();
// Crop the reflection to the selected height
$reflection->cropImage($this->width, $height, 0, 0);
$reflection->setImagePage($this->width, $height, 0, 0);
// Select the fade direction
$direction = array('transparent', 'black');
if ($fade_in) {
// Change the direction of the fade
$direction = array_reverse($direction);
}
// Create a gradient for fading
$fade = new Imagick();
$fade->newPseudoImage($reflection->getImageWidth(), $reflection->getImageHeight(), vsprintf('gradient:%s-%s', $direction));
// Apply the fade alpha channel to the reflection
$reflection->compositeImage($fade, Imagick::COMPOSITE_DSTOUT, 0, 0);
// NOTE: Using setImageOpacity will destroy alpha channels!
$reflection->evaluateImage(Imagick::EVALUATE_MULTIPLY, $opacity / 100, Imagick::CHANNEL_ALPHA);
// Create a new container to hold the image and reflection
$image = new Imagick();
$image->newImage($this->width, $this->height + $height, new ImagickPixel());
// Force the image to have an alpha channel
$image->setImageAlphaChannel(Imagick::ALPHACHANNEL_SET);
// Force the background color to be transparent
// $image->setImageBackgroundColor(new ImagickPixel('transparent'));
// Match the colorspace between the two images before compositing
$image->setColorspace($this->im->getColorspace());
// Place the image and reflection into the container
if ($image->compositeImage($this->im, Imagick::COMPOSITE_SRC, 0, 0) and $image->compositeImage($reflection, Imagick::COMPOSITE_OVER, 0, $this->height)) {
// Replace the current image with the reflected image
$this->im = $image;
// Reset the width and height
$this->width = $this->im->getImageWidth();
$this->height = $this->im->getImageHeight();
return TRUE;
}
return FALSE;
}
private function getCharacterOutline()
{
//Example ImagickKernel::morphology
$imagick = new \Imagick(realpath("./images/character.png"));
$character = new \Imagick();
$character->newPseudoImage($imagick->getImageWidth(), $imagick->getImageHeight(), "canvas:white");
$canvas = new \Imagick();
$canvas->newPseudoImage($imagick->getImageWidth(), $imagick->getImageHeight(), "canvas:black");
$character->compositeimage($imagick, \Imagick::COMPOSITE_COPYOPACITY, 0, 0);
$canvas->compositeimage($character, \Imagick::COMPOSITE_ATOP, 0, 0);
$canvas->setFormat('png');
return $canvas;
//Example end
}
