ImageFactory.php

<?php

namespace AigerTeam\ImageTools;

use AigerTeam\ImageTools\Exceptions\FileException;
use AigerTeam\ImageTools\Exceptions\ImageFileException;

/**
 * Class ImageFactory
 *
 * Image factory. Creates images by various ways.
 *
 * @version 1.0.7
 * @author Finesse
 * @package AigerTeam\ImageTools
 */
class ImageFactory
{
 /**
 * @param int $memoryLimit Amount of bytes to which memory limit should be extended. Too small amount may cause 
 * "not enough memory" error while handling images.
 */
 public function __construct( $memoryLimit = 134217728 )
 {
 @ini_set( 'gd.jpeg_ignore_warning', true );

 try {
 $this->extendMemoryLimit( $memoryLimit );
 } catch ( \Exception $e ) {}
 }

 /**
 * Creates blank image.
 *
 * @param int $width Image width (px)
 * @param int $height Image height (px)
 * @param float[]|null $fill Fill color (array with keys `r`, `g`, `b` and optional `a`). If null is provided image 
 * will be fully transparent.
 * @return Image
 * @throws \Exception
 *
 * @since 1.0.0
 */
	public function blank( $width, $height, Array $fill = null )
 {
 $bitmap = @imagecreatetruecolor( $width, $height );

 if ( !$bitmap )
 throw new \Exception( 'Can\'t create blank image. Perhaps not enough RAM.' );

 $color = Image::allocateColor( $bitmap, $fill );
 $colorParts = imagecolorsforindex( $bitmap, $color );
 $isTransparent = !empty( $colorParts[ 'alpha' ] );

 @imagealphablending( $bitmap, false );
 @imagefill( $bitmap, 0, 0, $color );

		return new Image( $bitmap, $isTransparent );
	}

 /**
 * Reads image from file.
 *
 * @param string $file Path to the image file in the filesystem.
 * @return Image
 * @throws ImageFileException If image can't be retrieved from the file
 * @throws FileException If file can't be read
 * @throws \Exception In case of other error
 *
 * @since 1.0.0
 */
	public function openFile( $file )
 {
 // Clear file info cache
 @clearstatcache( true, $file );

 // Does file exist?
 if ( !file_exists( $file ) || !is_file( $file ))
 throw new FileException( 'Given file doesn\'t exist or not a file.', $file );

 // Is it readable?
 if ( !is_readable( $file ))
 throw new FileException( 'Given file isn\'t readable.', $file );

 // Is it image?
		$size = getimagesize( $file );
		if ( $size === false )
 throw new ImageFileException( 'Given file isn\'t an image.', $file );

 // Retrieve image type
		$format = strtolower( substr( $size['mime'], strpos( $size['mime'], '/' ) + 1 ) );
		if ($format === 'x-ms-bmp')
			$format = 'wbmp';

 // Does function that opens this type exist?
		$func = 'imagecreatefrom' . $format;
		if ( !function_exists( $func ) )
 throw new ImageFileException( 'Unknown image type.', $file );

 // Open image file
 $bitmap = @$func( $file );
		if ( !$bitmap )
 throw new ImageFileException( 'Can\'t open image file. Perhaps not enough RAM.', $file );

 // Create image object
 $image = new Image( $bitmap, in_array( $format, Array( 'png', 'gif' ) ) );

 // Rotate non-default oriended JPEG
		if (
 function_exists( 'exif_read_data' ) &&
 is_array( $exif = @exif_read_data( $file, 0, true )) &&
 isset( $exif[ 'IFD0' ][ 'Orientation' ])
 ) {
			switch( $exif[ 'IFD0' ][ 'Orientation' ]) {
				case 8: $image = $image->rotate( 90 ); break;
				case 3: $image = $image->rotate( 180 ); break;
				case 6: $image = $image->rotate( -90 ); break;
			}
		}

		return $image;
	}

 /**
 * Craetes image from screenshot.
 *
 * Works only on windows (due to http://php.net/manual/en/function.imagegrabscreen.php#refsect1-function.imagegrabscreen-notes).
 *
 * @return Image
 * @throws \Exception
 *
 * @since 1.0.5
 */
 public function screenshot()
 {
 if ( !function_exists( 'imagegrabscreen' ) )
 throw new \Exception( 'Current PHP assembly can\'t take screenshots.' );

 $bitmap = @imagegrabscreen();
 if ( !$bitmap )
 throw new \Exception( 'Can\'t take screenshot due to an unknown reason.' );

 return new Image( $bitmap );
 }

 /**
 * Extend system memory limit to the given value (if current limit is lower).
 *
 * @param int $minSize Amount of bytes
 */
 protected function extendMemoryLimit( $minSize )
 {
 $curSize = ini_get( 'memory_limit' );

 if ( !is_numeric( $curSize ) ) {
 $base = substr( $curSize, 0, -1 );
 $power = strtolower( substr( $curSize, -1 ) );

 switch ( $power ) {
 case 'k':
 $curSize = $base * 1024; // 640K ought to be enough for anybody
 break;
 case 'm':
 $curSize = $base * pow( 1024, 2 );
 break;
 case 'g':
 $curSize = $base * pow( 1024, 3 );
 break;
 case 't':
 $curSize = $base * pow( 1024, 4 );
 break;
 case 'p':
 $curSize = $base * pow( 1024, 5 ); // Someday this will also be not enough
 break;
 default:
 $curSize = 0;
 }
 } else {
 $curSize = (int)$curSize;
 }

 if ( $minSize > $curSize ) {
 ini_set( 'memory_limit', $minSize );
 }
 }
}