vendor/gregwar/image/Gregwar/Image/Adapter/GD.php line 90

Open in your IDE?
  1. <?php
  3. namespace Gregwar\Image\Adapter;
  5. use Gregwar\Image\Image;
  6. use Gregwar\Image\ImageColor;
  8. class GD extends Common
  9. {
  10.     public static $gdTypes = array(
  11.         'jpeg'  => \IMG_JPG,
  12.         'gif'   => \IMG_GIF,
  13.         'png'   => \IMG_PNG,
  14.         'webp'  => \IMG_WEBP
  15.     );
  17.     protected function loadResource($resource)
  18.     {
  19.         parent::loadResource($resource);
  20.         imagesavealpha($this->resource, true);
  21.     }
  23.     /**
  24.      * Gets the width and the height for writing some text.
  25.      */
  26.     public static function TTFBox($font, $text, $size, $angle = 0)
  27.     {
  28.         $box = imagettfbbox($size, $angle, $font, $text);
  30.         return array(
  31.             'width'  => abs($box[2] - $box[0]),
  32.             'height' => abs($box[3] - $box[5]),
  33.         );
  34.     }
  36.     public function __construct()
  37.     {
  38.         parent::__construct();
  40.         if (!(extension_loaded('gd') && function_exists('gd_info'))) {
  41.             throw new \RuntimeException('You need to install GD PHP Extension to use this library');
  42.         }
  43.     }
  45.     /**
  46.      * {@inheritdoc}
  47.      */
  48.     public function getName()
  49.     {
  50.         return 'GD';
  51.     }
  53.     /**
  54.      * {@inheritdoc}
  55.      */
  56.     public function fillBackground($background = 0xffffff)
  57.     {
  58.         $w = $this->width();
  59.         $h = $this->height();
  60.         $n = imagecreatetruecolor($w, $h);
  61.         imagefill($n, 0, 0, ImageColor::gdAllocate($this->resource, $background));
  62.         imagecopyresampled($n, $this->resource, 0, 0, 0, 0, $w, $h, $w, $h);
  63.         imagedestroy($this->resource);
  64.         $this->resource = $n;
  66.         return $this;
  67.     }
  69.     /**
  70.      * Do the image resize.
  71.      *
  72.      * @return $this
  73.      */
  74.     protected function doResize($bg, $target_width, $target_height, $new_width, $new_height)
  75.     {
  76.         $width = $this->width();
  77.         $height = $this->height();
  78.         $n = imagecreatetruecolor($target_width, $target_height);
  80.         if ($bg != 'transparent') {
  81.             imagefill($n, 0, 0, ImageColor::gdAllocate($this->resource, $bg));
  82.         } else {
  83.             imagealphablending($n, false);
  84.             $color = ImageColor::gdAllocate($this->resource, 'transparent');
  86.             imagefill($n, 0, 0, $color);
  87.             imagesavealpha($n, true);
  88.         }
  90.         imagecopyresampled($n, $this->resource, ($target_width - $new_width) / 2, ($target_height - $new_height) / 2, 0, 0, $new_width, $new_height, $width, $height);
  91.         imagedestroy($this->resource);
  93.         $this->resource = $n;
  95.         return $this;
  96.     }
  98.     /**
  99.      * {@inheritdoc}
  100.      */
  101.     public function crop($x, $y, $width, $height)
  102.     {
  103.         $destination = imagecreatetruecolor($width, $height);
  104.         imagealphablending($destination, false);
  105.         imagesavealpha($destination, true);
  106.         imagecopy($destination, $this->resource, 0, 0, $x, $y, $this->width(), $this->height());
  107.         imagedestroy($this->resource);
  108.         $this->resource = $destination;
  110.         return $this;
  111.     }
  113.     /**
  114.      * {@inheritdoc}
  115.      */
  116.     public function negate()
  117.     {
  118.         imagefilter($this->resource, IMG_FILTER_NEGATE);
  120.         return $this;
  121.     }
  123.     /**
  124.      * {@inheritdoc}
  125.      */
  126.     public function brightness($brightness)
  127.     {
  128.         imagefilter($this->resource, IMG_FILTER_BRIGHTNESS, $brightness);
  130.         return $this;
  131.     }
  133.     /**
  134.      * {@inheritdoc}
  135.      */
  136.     public function contrast($contrast)
  137.     {
  138.         imagefilter($this->resource, IMG_FILTER_CONTRAST, $contrast);
  140.         return $this;
  141.     }
  143.     /**
  144.      * {@inheritdoc}
  145.      */
  146.     public function grayscale()
  147.     {
  148.         imagefilter($this->resource, IMG_FILTER_GRAYSCALE);
  150.         return $this;
  151.     }
  153.     /**
  154.      * {@inheritdoc}
  155.      */
  156.     public function emboss()
  157.     {
  158.         imagefilter($this->resource, IMG_FILTER_EMBOSS);
  160.         return $this;
  161.     }
  163.     /**
  164.      * {@inheritdoc}
  165.      */
  166.     public function smooth($p)
  167.     {
  168.         imagefilter($this->resource, IMG_FILTER_SMOOTH, $p);
  170.         return $this;
  171.     }
  173.     /**
  174.      * {@inheritdoc}
  175.      */
  176.     public function sharp()
  177.     {
  178.         imagefilter($this->resource, IMG_FILTER_MEAN_REMOVAL);
  180.         return $this;
  181.     }
  183.     /**
  184.      * {@inheritdoc}
  185.      */
  186.     public function edge()
  187.     {
  188.         imagefilter($this->resource, IMG_FILTER_EDGEDETECT);
  190.         return $this;
  191.     }
  193.     /**
  194.      * {@inheritdoc}
  195.      */
  196.     public function colorize($red, $green, $blue)
  197.     {
  198.         imagefilter($this->resource, IMG_FILTER_COLORIZE, $red, $green, $blue);
  200.         return $this;
  201.     }
  203.     /**
  204.      * {@inheritdoc}
  205.      */
  206.     public function sepia()
  207.     {
  208.         imagefilter($this->resource, IMG_FILTER_GRAYSCALE);
  209.         imagefilter($this->resource, IMG_FILTER_COLORIZE, 100, 50, 0);
  211.         return $this;
  212.     }
  214.     /**
  215.      * {@inheritdoc}
  216.      */
  217.     public function gaussianBlur($blurFactor = 1)
  218.     {
  219.         $blurFactor = round($blurFactor); // blurFactor has to be an integer
  221.         $originalWidth = $this->width();
  222.         $originalHeight = $this->height();
  224.         $smallestWidth = ceil($originalWidth * pow(0.5, $blurFactor));
  225.         $smallestHeight = ceil($originalHeight * pow(0.5, $blurFactor));
  227.         // for the first run, the previous image is the original input
  228.         $prevImage = $this->resource;
  229.         $prevWidth = $originalWidth;
  230.         $prevHeight = $originalHeight;
  232.         // scale way down and gradually scale back up, blurring all the way
  233.         for ($i = 0; $i < $blurFactor; ++$i) {
  234.             // determine dimensions of next image
  235.             $nextWidth = $smallestWidth * pow(2, $i);
  236.             $nextHeight = $smallestHeight * pow(2, $i);
  238.             // resize previous image to next size
  239.             $nextImage = imagecreatetruecolor($nextWidth, $nextHeight);
  240.             imagecopyresized($nextImage, $prevImage, 0, 0, 0, 0,
  241.                 $nextWidth, $nextHeight, $prevWidth, $prevHeight);
  243.             // apply blur filter
  244.             imagefilter($nextImage, IMG_FILTER_GAUSSIAN_BLUR);
  246.             // now the new image becomes the previous image for the next step
  247.             $prevImage = $nextImage;
  248.             $prevWidth = $nextWidth;
  249.             $prevHeight = $nextHeight;
  250.         }
  252.         // scale back to original size and blur one more time
  253.         imagecopyresized($this->resource, $nextImage,
  254.             0, 0, 0, 0, $originalWidth, $originalHeight, $nextWidth, $nextHeight);
  255.         imagefilter($this->resource, IMG_FILTER_GAUSSIAN_BLUR);
  257.         // clean up
  258.         imagedestroy($prevImage);
  260.         return $this;
  261.     }
  263.     /**
  264.      * {@inheritdoc}
  265.      */
  266.     public function merge(Image $other, $x = 0, $y = 0, $width = null, $height = null)
  267.     {
  268.         $other = clone $other;
  269.         $other->init();
  270.         $other->applyOperations();
  272.         imagealphablending($this->resource, true);
  274.         if (null == $width) {
  275.             $width = $other->width();
  276.         }
  278.         if (null == $height) {
  279.             $height = $other->height();
  280.         }
  282.         imagecopyresampled($this->resource, $other->getAdapter()->getResource(), $x, $y, 0, 0, $width, $height, $width, $height);
  284.         return $this;
  285.     }
  287.     /**
  288.      * {@inheritdoc}
  289.      */
  290.     public function rotate($angle, $background = 0xffffff)
  291.     {
  292.         $this->resource = imagerotate($this->resource, $angle, ImageColor::gdAllocate($this->resource, $background));
  293.         imagealphablending($this->resource, true);
  294.         imagesavealpha($this->resource, true);
  296.         return $this;
  297.     }
  299.     /**
  300.      * {@inheritdoc}
  301.      */
  302.     public function fill($color = 0xffffff, $x = 0, $y = 0)
  303.     {
  304.         imagealphablending($this->resource, false);
  305.         imagefill($this->resource, $x, $y, ImageColor::gdAllocate($this->resource, $color));
  307.         return $this;
  308.     }
  310.     /**
  311.      * {@inheritdoc}
  312.      */
  313.     public function write($font, $text, $x = 0, $y = 0, $size = 12, $angle = 0, $color = 0x000000, $align = 'left')
  314.     {
  315.         imagealphablending($this->resource, true);
  317.         if ($align != 'left') {
  318.             $sim_size = self::TTFBox($font, $text, $size, $angle);
  320.             if ($align == 'center') {
  321.                 $x -= $sim_size['width'] / 2;
  322.             }
  324.             if ($align == 'right') {
  325.                 $x -= $sim_size['width'];
  326.             }
  327.         }
  329.         imagettftext($this->resource, $size, $angle, $x, $y, ImageColor::gdAllocate($this->resource, $color), $font, $text);
  331.         return $this;
  332.     }
  334.     /**
  335.      * {@inheritdoc}
  336.      */
  337.     public function rectangle($x1, $y1, $x2, $y2, $color, $filled = false)
  338.     {
  339.         if ($filled) {
  340.             imagefilledrectangle($this->resource, $x1, $y1, $x2, $y2, ImageColor::gdAllocate($this->resource, $color));
  341.         } else {
  342.             imagerectangle($this->resource, $x1, $y1, $x2, $y2, ImageColor::gdAllocate($this->resource, $color));
  343.         }
  345.         return $this;
  346.     }
  348.     /**
  349.      * {@inheritdoc}
  350.      */
  351.     public function roundedRectangle($x1, $y1, $x2, $y2, $radius, $color, $filled = false)
  352.     {
  353.         if ($color) {
  354.             $color = ImageColor::gdAllocate($this->resource, $color);
  355.         }
  357.         if ($filled == true) {
  358.             imagefilledrectangle($this->resource, $x1 + $radius, $y1, $x2 - $radius, $y2, $color);
  359.             imagefilledrectangle($this->resource, $x1, $y1 + $radius, $x1 + $radius - 1, $y2 - $radius, $color);
  360.             imagefilledrectangle($this->resource, $x2 - $radius + 1, $y1 + $radius, $x2, $y2 - $radius, $color);
  362.             imagefilledarc($this->resource, $x1 + $radius, $y1 + $radius, $radius * 2, $radius * 2, 180, 270, $color, IMG_ARC_PIE);
  363.             imagefilledarc($this->resource, $x2 - $radius, $y1 + $radius, $radius * 2, $radius * 2, 270, 360, $color, IMG_ARC_PIE);
  364.             imagefilledarc($this->resource, $x1 + $radius, $y2 - $radius, $radius * 2, $radius * 2, 90, 180, $color, IMG_ARC_PIE);
  365.             imagefilledarc($this->resource, $x2 - $radius, $y2 - $radius, $radius * 2, $radius * 2, 360, 90, $color, IMG_ARC_PIE);
  366.         } else {
  367.             imageline($this->resource, $x1 + $radius, $y1, $x2 - $radius, $y1, $color);
  368.             imageline($this->resource, $x1 + $radius, $y2, $x2 - $radius, $y2, $color);
  369.             imageline($this->resource, $x1, $y1 + $radius, $x1, $y2 - $radius, $color);
  370.             imageline($this->resource, $x2, $y1 + $radius, $x2, $y2 - $radius, $color);
  372.             imagearc($this->resource, $x1 + $radius, $y1 + $radius, $radius * 2, $radius * 2, 180, 270, $color);
  373.             imagearc($this->resource, $x2 - $radius, $y1 + $radius, $radius * 2, $radius * 2, 270, 360, $color);
  374.             imagearc($this->resource, $x1 + $radius, $y2 - $radius, $radius * 2, $radius * 2, 90, 180, $color);
  375.             imagearc($this->resource, $x2 - $radius, $y2 - $radius, $radius * 2, $radius * 2, 360, 90, $color);
  376.         }
  378.         return $this;
  379.     }
  381.     /**
  382.      * {@inheritdoc}
  383.      */
  384.     public function line($x1, $y1, $x2, $y2, $color = 0x000000)
  385.     {
  386.         imageline($this->resource, $x1, $y1, $x2, $y2, ImageColor::gdAllocate($this->resource, $color));
  388.         return $this;
  389.     }
  391.     /**
  392.      * {@inheritdoc}
  393.      */
  394.     public function ellipse($cx, $cy, $width, $height, $color = 0x000000, $filled = false)
  395.     {
  396.         if ($filled) {
  397.             imagefilledellipse($this->resource, $cx, $cy, $width, $height, ImageColor::gdAllocate($this->resource, $color));
  398.         } else {
  399.             imageellipse($this->resource, $cx, $cy, $width, $height, ImageColor::gdAllocate($this->resource, $color));
  400.         }
  402.         return $this;
  403.     }
  405.     /**
  406.      * {@inheritdoc}
  407.      */
  408.     public function circle($cx, $cy, $r, $color = 0x000000, $filled = false)
  409.     {
  410.         return $this->ellipse($cx, $cy, $r, $r, ImageColor::gdAllocate($this->resource, $color), $filled);
  411.     }
  413.     /**
  414.      * {@inheritdoc}
  415.      */
  416.     public function polygon(array $points, $color, $filled = false)
  417.     {
  418.         if ($filled) {
  419.             imagefilledpolygon($this->resource, $points, count($points) / 2, ImageColor::gdAllocate($this->resource, $color));
  420.         } else {
  421.             imagepolygon($this->resource, $points, count($points) / 2, ImageColor::gdAllocate($this->resource, $color));
  422.         }
  424.         return $this;
  425.     }
  427.     /**
  428.      *  {@inheritdoc}
  429.      */
  430.     public function flip($flipVertical, $flipHorizontal)
  431.     {
  432.         if (!$flipVertical && !$flipHorizontal) {
  433.             return $this;
  434.         }
  436.         if (function_exists('imageflip')) {
  437.             if ($flipVertical && $flipHorizontal) {
  438.                 $flipMode = \IMG_FLIP_BOTH;
  439.             } elseif ($flipVertical && !$flipHorizontal) {
  440.                 $flipMode = \IMG_FLIP_VERTICAL;
  441.             } elseif (!$flipVertical && $flipHorizontal) {
  442.                 $flipMode = \IMG_FLIP_HORIZONTAL;
  443.             }
  445.             imageflip($this->resource, $flipMode);
  446.         } else {
  447.             $width = $this->width();
  448.             $height = $this->height();
  450.             $src_x      = 0;
  451.             $src_y      = 0;
  452.             $src_width  = $width;
  453.             $src_height = $height;
  455.             if ($flipVertical) {
  456.                 $src_y      = $height - 1;
  457.                 $src_height = -$height;
  458.             }
  460.             if ($flipHorizontal) {
  461.                 $src_x      = $width - 1;
  462.                 $src_width  = -$width;
  463.             }
  465.             $imgdest = imagecreatetruecolor($width, $height);
  466.             imagealphablending($imgdest, false);
  467.             imagesavealpha($imgdest, true);
  469.             if (imagecopyresampled($imgdest, $this->resource, 0, 0, $src_x, $src_y, $width, $height, $src_width, $src_height)) {
  470.                 imagedestroy($this->resource);
  471.                 $this->resource = $imgdest;
  472.             }
  473.         }
  475.         return $this;
  476.     }
  478.     /**
  479.      * {@inheritdoc}
  480.      */
  481.     public function width()
  482.     {
  483.         if (null === $this->resource) {
  484.             $this->init();
  485.         }
  487.         return imagesx($this->resource);
  488.     }
  490.     /**
  491.      * {@inheritdoc}
  492.      */
  493.     public function height()
  494.     {
  495.         if (null === $this->resource) {
  496.             $this->init();
  497.         }
  499.         return imagesy($this->resource);
  500.     }
  502.     protected function createImage($width, $height)
  503.     {
  504.         $this->resource = imagecreatetruecolor($width, $height);
  505.     }
  507.     protected function createImageFromData($data)
  508.     {
  509.         $this->resource = @imagecreatefromstring($data);
  510.     }
  512.     /**
  513.      * Converts the image to true color.
  514.      */
  515.     protected function convertToTrueColor()
  516.     {
  517.         if (!imageistruecolor($this->resource)) {
  518.             if (function_exists('imagepalettetotruecolor')) {
  519.                 // Available in PHP 5.5
  520.                 imagepalettetotruecolor($this->resource);
  521.             } else {
  522.                 $transparentIndex = imagecolortransparent($this->resource);
  524.                 $w = $this->width();
  525.                 $h = $this->height();
  527.                 $img = imagecreatetruecolor($w, $h);
  528.                 imagecopy($img, $this->resource, 0, 0, 0, 0, $w, $h);
  530.                 if ($transparentIndex != -1) {
  531.                     $width = $this->width();
  532.                     $height = $this->height();
  534.                     imagealphablending($img, false);
  535.                     imagesavealpha($img, true);
  537.                     for ($x = 0; $x < $width; ++$x) {
  538.                         for ($y = 0; $y < $height; ++$y) {
  539.                             if (imagecolorat($this->resource, $x, $y) == $transparentIndex) {
  540.                                 imagesetpixel($img, $x, $y, 127 << 24);
  541.                             }
  542.                         }
  543.                     }
  544.                 }
  546.                 $this->resource = $img;
  547.             }
  548.         }
  550.         imagesavealpha($this->resource, true);
  551.     }
  553.     /**
  554.      * {@inheritdoc}
  555.      */
  556.     public function saveGif($file)
  557.     {
  558.         $transColor = imagecolorallocatealpha($this->resource, 255, 255, 255, 127);
  559.         imagecolortransparent($this->resource, $transColor);
  560.         imagegif($this->resource, $file);
  562.         return $this;
  563.     }
  565.     /**
  566.      * {@inheritdoc}
  567.      */
  568.     public function savePng($file)
  569.     {
  570.         imagepng($this->resource, $file);
  572.         return $this;
  573.     }
  574.     
  575.     /**
  576.      * {@inheritdoc}
  577.      */
  578.     public function saveWebp($file, $quality)
  579.     {
  580.         imagewebp($this->resource, $file, $quality);
  582.         return $this;
  583.     }
  585.     /**
  586.      * {@inheritdoc}
  587.      */
  588.     public function saveJpeg($file, $quality)
  589.     {
  590.         imagejpeg($this->resource, $file, $quality);
  592.         return $this;
  593.     }
  595.     /**
  596.      * Try to open the file using jpeg.
  597.      */
  598.     protected function openJpeg($file)
  599.     {
  600.         if (file_exists($file) && filesize($file)) {
  601.             $this->resource = @imagecreatefromjpeg($file);
  602.         } else {
  603.             $this->resource = false;
  604.         }
  605.     }
  607.     /**
  608.      * Try to open the file using gif.
  609.      */
  610.     protected function openGif($file)
  611.     {
  612.         if (file_exists($file) && filesize($file)) {
  613.             $this->resource = @imagecreatefromgif($file);
  614.         } else {
  615.             $this->resource = false;
  616.         }
  617.     }
  619.     /**
  620.      * Try to open the file using PNG.
  621.      */
  622.     protected function openPng($file)
  623.     {
  624.         if (file_exists($file) && filesize($file)) {
  625.             $this->resource = @imagecreatefrompng($file);
  626.         } else {
  627.             $this->resource = false;
  628.         }
  629.     }
  631.     /**
  632.      * Try to open the file using WEBP.
  633.      */
  634.     protected function openWebp($file)
  635.     {
  636.         if (file_exists($file) && filesize($file)) {
  637.             $this->resource = @imagecreatefromwebp($file);
  638.         } else {
  639.             $this->resource = false;
  640.         }
  641.     }
  643.     /**
  644.      * Does this adapter supports type ?
  645.      */
  646.     protected function supports($type)
  647.     {
  648.         return imagetypes() & self::$gdTypes[$type];
  649.     }
  651.     protected function getColor($x, $y)
  652.     {
  653.         return imagecolorat($this->resource, $x, $y);
  654.     }
  656.     /**
  657.      * {@inheritdoc}
  658.      */
  659.     public function enableProgressive()
  660.     {
  661.         imageinterlace($this->resource, 1);
  663.         return $this;
  664.     }
  665. }