vendor/gregwar/image/Gregwar/Image/Adapter/Common.php line 82

Open in your IDE?
  1. <?php
  3. namespace Gregwar\Image\Adapter;
  5. abstract class Common extends Adapter
  6. {
  7.     /**
  8.      * {@inheritdoc}
  9.      */
  10.     public function zoomCrop($width, $height, $background = 'transparent', $xPosLetter = 'center', $yPosLetter = 'center')
  11.     {
  12.         $originalWidth = $this->width();
  13.         $originalHeight = $this->height();
  15.         // Calculate the different ratios
  16.         $originalRatio = $originalWidth / $originalHeight;
  17.         $newRatio = $width / $height;
  19.         // Compare ratios
  20.         if ($originalRatio > $newRatio) {
  21.             // Original image is wider
  22.             $newHeight = $height;
  23.             $newWidth = (int) $height * $originalRatio;
  24.         } else {
  25.             // Equal width or smaller
  26.             $newHeight = (int) $width / $originalRatio;
  27.             $newWidth = $width;
  28.         }
  30.         // Perform resize
  31.         $this->resize($newWidth, $newHeight, $background, true);
  33.         // Define x position
  34.         switch ($xPosLetter) {
  35.             case 'L':
  36.             case 'left':
  37.                 $xPos = 0;
  38.                 break;
  39.             case 'R':
  40.             case 'right':
  41.                 $xPos = (int) $newWidth - $width;
  42.                 break;
  43.             case 'center':
  44.                 $xPos = (int) ($newWidth - $width) / 2;
  45.                 break;
  46.             default:
  47.                 $factorW = $newWidth / $originalWidth;
  48.                 $xPos = $xPosLetter * $factorW;
  50.                 // If the desired cropping position goes beyond the width then
  51.                 // set the crop to be within the correct bounds.
  52.                 if ($xPos + $width > $newWidth) {
  53.                     $xPos = (int) $newWidth - $width;
  54.                 }
  55.         }
  57.         // Define y position
  58.         switch ($yPosLetter) {
  59.             case 'T':
  60.             case 'top':
  61.                 $yPos = 0;
  62.                 break;
  63.             case 'B':
  64.             case 'bottom':
  65.                 $yPos = (int) $newHeight - $height;
  66.                 break;
  67.             case 'center':
  68.                 $yPos = (int) ($newHeight - $height) / 2;
  69.                 break;
  70.             default:
  71.                 $factorH = $newHeight / $originalHeight;
  72.                 $yPos = $yPosLetter * $factorH;
  74.                 // If the desired cropping position goes beyond the height then
  75.                 // set the crop to be within the correct bounds.
  76.                 if ($yPos + $height > $newHeight) {
  77.                     $yPos = (int) $newHeight - $height;
  78.                 }
  79.         }
  81.         // Crop image to reach desired size
  82.         $this->crop($xPos, $yPos, $width, $height);
  84.         return $this;
  85.     }
  87.     /**
  88.      * Resizes the image forcing the destination to have exactly the
  89.      * given width and the height.
  90.      *
  91.      * @param int $w  the width
  92.      * @param int $h  the height
  93.      * @param int $bg the background
  94.      */
  95.     public function forceResize($width = null, $height = null, $background = 'transparent')
  96.     {
  97.         return $this->resize($width, $height, $background, true);
  98.     }
  100.     /**
  101.      * {@inheritdoc}
  102.      */
  103.     public function scaleResize($width = null, $height = null, $background = 'transparent', $crop = false)
  104.     {
  105.         return $this->resize($width, $height, $background, false, true, $crop);
  106.     }
  108.     /**
  109.      * {@inheritdoc}
  110.      */
  111.     public function cropResize($width = null, $height = null, $background = 'transparent')
  112.     {
  113.         return $this->resize($width, $height, $background, false, false, true);
  114.     }
  116.     /**
  117.      * Read exif rotation from file and apply it.
  118.      */
  119.     public function fixOrientation()
  120.     {
  121.         if (!in_array(exif_imagetype($this->source->getInfos()), array(
  122.             IMAGETYPE_JPEG,
  123.             IMAGETYPE_TIFF_II,
  124.             IMAGETYPE_TIFF_MM,
  125.         ))) {
  126.             return $this;
  127.         }
  129.         if (!extension_loaded('exif')) {
  130.             throw new \RuntimeException('You need to EXIF PHP Extension to use this function');
  131.         }
  133.         $exif = @exif_read_data($this->source->getInfos());
  135.         if ($exif === false || !array_key_exists('Orientation', $exif)) {
  136.             return $this;
  137.         }
  139.         return $this->applyExifOrientation($exif['Orientation']);
  140.     }
  142.     /**
  143.      * Apply orientation using Exif orientation value.
  144.      */
  145.     public function applyExifOrientation($exif_orienation)
  146.     {
  147.         switch ($exif_orienation) {
  148.             case 1:
  149.                 break;
  151.             case 2:
  152.                 $this->flip(false, true);
  153.                 break;
  155.             case 3: // 180 rotate left
  156.                 $this->rotate(180);
  157.                 break;
  159.             case 4: // vertical flip
  160.                 $this->flip(true, false);
  161.                 break;
  163.             case 5: // vertical flip + 90 rotate right
  164.                 $this->flip(true, false);
  165.                 $this->rotate(-90);
  166.                 break;
  168.             case 6: // 90 rotate right
  169.                 $this->rotate(-90);
  170.                 break;
  172.             case 7: // horizontal flip + 90 rotate right
  173.                 $this->flip(false, true);
  174.                 $this->rotate(-90);
  175.                 break;
  177.             case 8: // 90 rotate left
  178.                 $this->rotate(90);
  179.                 break;
  180.         }
  182.         return $this;
  183.     }
  185.     /**
  186.      * Opens the image.
  187.      */
  188.     abstract protected function openGif($file);
  190.     abstract protected function openJpeg($file);
  192.     abstract protected function openPng($file);
  194.     abstract protected function openWebp($file);
  196.     /**
  197.      * Creates an image.
  198.      */
  199.     abstract protected function createImage($width, $height);
  201.     /**
  202.      * Creating an image using $data.
  203.      */
  204.     abstract protected function createImageFromData($data);
  206.     /**
  207.      * Loading image from $resource.
  208.      */
  209.     protected function loadResource($resource)
  210.     {
  211.         $this->resource = $resource;
  212.     }
  214.     protected function loadFile($file, $type)
  215.     {
  216.         if (!$this->supports($type)) {
  217.             throw new \RuntimeException('Type '.$type.' is not supported by GD');
  218.         }
  220.         if ($type == 'jpeg') {
  221.             $this->openJpeg($file);
  222.         }
  224.         if ($type == 'gif') {
  225.             $this->openGif($file);
  226.         }
  228.         if ($type == 'png') {
  229.             $this->openPng($file);
  230.         }
  232.         if ($type == 'webp') {
  233.             $this->openWebp($file);
  234.         }
  236.         if (false === $this->resource) {
  237.             throw new \UnexpectedValueException('Unable to open file ('.$file.')');
  238.         } else {
  239.             $this->convertToTrueColor();
  240.         }
  241.     }
  243.     /**
  244.      * {@inheritdoc}
  245.      */
  246.     public function init()
  247.     {
  248.         $source = $this->source;
  250.         if ($source instanceof \Gregwar\Image\Source\File) {
  251.             $this->loadFile($source->getFile(), $source->guessType());
  252.         } elseif ($source instanceof \Gregwar\Image\Source\Create) {
  253.             $this->createImage($source->getWidth(), $source->getHeight());
  254.         } elseif ($source instanceof \Gregwar\Image\Source\Data) {
  255.             $this->createImageFromData($source->getData());
  256.         } elseif ($source instanceof \Gregwar\Image\Source\Resource) {
  257.             $this->loadResource($source->getResource());
  258.         } else {
  259.             throw new \Exception('Unsupported image source type '.get_class($source));
  260.         }
  262.         return $this;
  263.     }
  264.     
  265.     /**
  266.      * {@inheritdoc}
  267.      */
  268.     public function deinit()
  269.     {
  270.         $this->resource = null;
  271.     }
  273.     /**
  274.      * {@inheritdoc}
  275.      */
  276.     public function resize($width = null, $height = null, $background = 'transparent', $force = false, $rescale = false, $crop = false)
  277.     {
  278.         $current_width = $this->width();
  279.         $current_height = $this->height();
  280.         $new_width = 0;
  281.         $new_height = 0;
  282.         $scale = 1.0;
  284.         if ($height === null && preg_match('#^(.+)%$#mUsi', $width, $matches)) {
  285.             $width = round($current_width * ((float) $matches[1] / 100.0));
  286.             $height = round($current_height * ((float) $matches[1] / 100.0));
  287.         }
  289.         if (!$rescale && (!$force || $crop)) {
  290.             if ($width != null && $current_width > $width) {
  291.                 $scale = $current_width / $width;
  292.             }
  294.             if ($height != null && $current_height > $height) {
  295.                 if ($current_height / $height > $scale) {
  296.                     $scale = $current_height / $height;
  297.                 }
  298.             }
  299.         } else {
  300.             if ($width != null) {
  301.                 $scale = $current_width / $width;
  302.                 $new_width = $width;
  303.             }
  305.             if ($height != null) {
  306.                 if ($width != null && $rescale) {
  307.                     $scale = max($scale, $current_height / $height);
  308.                 } else {
  309.                     $scale = $current_height / $height;
  310.                 }
  311.                 $new_height = $height;
  312.             }
  313.         }
  315.         if (!$force || $width == null || $rescale) {
  316.             $new_width = round($current_width / $scale);
  317.         }
  319.         if (!$force || $height == null || $rescale) {
  320.             $new_height = round($current_height / $scale);
  321.         }
  323.         if ($width == null || $crop) {
  324.             $width = $new_width;
  325.         }
  327.         if ($height == null || $crop) {
  328.             $height = $new_height;
  329.         }
  331.         $this->doResize($background, $width, $height, $new_width, $new_height);
  332.     }
  334.     /**
  335.      * Trim background color arround the image.
  336.      *
  337.      * @param int $bg the background
  338.      */
  339.     protected function _trimColor($background = 'transparent')
  340.     {
  341.         $width = $this->width();
  342.         $height = $this->height();
  344.         $b_top = 0;
  345.         $b_lft = 0;
  346.         $b_btm = $height - 1;
  347.         $b_rt = $width - 1;
  349.         //top
  350.         for (; $b_top < $height; ++$b_top) {
  351.             for ($x = 0; $x < $width; ++$x) {
  352.                 if ($this->getColor($x, $b_top) != $background) {
  353.                     break 2;
  354.                 }
  355.             }
  356.         }
  358.         // bottom
  359.         for (; $b_btm >= 0; --$b_btm) {
  360.             for ($x = 0; $x < $width; ++$x) {
  361.                 if ($this->getColor($x, $b_btm) != $background) {
  362.                     break 2;
  363.                 }
  364.             }
  365.         }
  367.         // left
  368.         for (; $b_lft < $width; ++$b_lft) {
  369.             for ($y = $b_top; $y <= $b_btm; ++$y) {
  370.                 if ($this->getColor($b_lft, $y) != $background) {
  371.                     break 2;
  372.                 }
  373.             }
  374.         }
  376.         // right
  377.         for (; $b_rt >= 0; --$b_rt) {
  378.             for ($y = $b_top; $y <= $b_btm; ++$y) {
  379.                 if ($this->getColor($b_rt, $y) != $background) {
  380.                     break 2;
  381.                 }
  382.             }
  383.         }
  385.         ++$b_btm;
  386.         ++$b_rt;
  388.         $this->crop($b_lft, $b_top, $b_rt - $b_lft, $b_btm - $b_top);
  389.     }
  391.     /**
  392.      * Resizes the image to an image having size of $target_width, $target_height, using
  393.      * $new_width and $new_height and padding with $bg color.
  394.      */
  395.     abstract protected function doResize($bg, $target_width, $target_height, $new_width, $new_height);
  397.     /**
  398.      * Gets the color of the $x, $y pixel.
  399.      */
  400.     abstract protected function getColor($x, $y);
  402.     /**
  403.      * {@inheritdoc}
  404.      */
  405.     public function enableProgressive()
  406.     {
  407.         throw new \Exception('The Adapter '.$this->getName().' does not support Progressive Image loading');
  408.     }
  410.     /**
  411.      * This does nothing, but can be used to tag a ressource for instance (having a final image hash
  412.      * for the cache different depending on the tag)
  413.      */
  414.     public function tag($tag)
  415.     {
  416.     }
  417. }