2012-01-01 20:57:26 +04:00
< ? php
/**
* ownCloud
*
* @ author Thomas Tanghus
* @ copyright 2011 Thomas Tanghus < thomas @ tanghus . net >
*
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation ; either
* version 3 of the License , or any later version .
*
* This library is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details .
*
* You should have received a copy of the GNU Affero General Public
* License along with this library . If not , see < http :// www . gnu . org / licenses />.
*
*/
/**
2012-01-05 20:42:40 +04:00
* Class for basic image manipulation
2012-01-01 20:57:26 +04:00
*/
class OC_Image {
2012-02-10 01:44:26 +04:00
protected $resource = false ; // tmp resource.
2013-08-06 18:56:50 +04:00
protected $imageType = IMAGETYPE_PNG ; // Default to png if file type isn't evident.
protected $mimeType = " image/png " ; // Default to png
protected $bitDepth = 24 ;
protected $filePath = null ;
private $fileInfo ;
2012-02-10 01:44:26 +04:00
2012-02-16 13:35:35 +04:00
/**
2014-05-19 19:50:53 +04:00
* Get mime type for an image file .
2014-02-28 16:53:41 +04:00
* @ param string | null $filePath The path to a local image file .
2014-03-17 11:17:56 +04:00
* @ return string The mime type if the it could be determined , otherwise an empty string .
2012-02-16 13:35:35 +04:00
*/
2013-08-06 18:56:50 +04:00
static public function getMimeTypeForFile ( $filePath ) {
2013-03-02 13:51:49 +04:00
// exif_imagetype throws "read error!" if file is less than 12 byte
2013-08-06 18:56:50 +04:00
if ( filesize ( $filePath ) > 11 ) {
$imageType = exif_imagetype ( $filePath );
2014-02-27 02:56:46 +04:00
} else {
2013-08-06 18:56:50 +04:00
$imageType = false ;
2013-03-02 13:51:49 +04:00
}
2013-08-06 18:56:50 +04:00
return $imageType ? image_type_to_mime_type ( $imageType ) : '' ;
2012-02-14 02:35:33 +04:00
}
2012-01-01 20:57:26 +04:00
/**
2014-05-19 19:50:53 +04:00
* Constructor .
2014-04-16 00:55:20 +04:00
* @ param resource | string $imageRef The path to a local file , a base64 encoded string or a resource created by
2014-03-17 11:17:56 +04:00
* an imagecreate * function .
* @ return \OC_Image False on error
*/
2013-08-06 18:56:50 +04:00
public function __construct ( $imageRef = null ) {
2012-02-10 01:44:26 +04:00
//OC_Log::write('core',__METHOD__.'(): start', OC_Log::DEBUG);
2012-01-02 16:40:23 +04:00
if ( ! extension_loaded ( 'gd' ) || ! function_exists ( 'gd_info' )) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): GD module not installed' , OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
return false ;
}
2013-08-06 18:56:50 +04:00
if ( \OC_Util :: fileInfoLoaded ()) {
$this -> fileInfo = new finfo ( FILEINFO_MIME_TYPE );
}
if ( ! is_null ( $imageRef )) {
$this -> load ( $imageRef );
2012-01-01 20:57:26 +04:00
}
}
2012-01-01 23:06:35 +04:00
/**
2014-05-19 19:50:53 +04:00
* Determine whether the object contains an image resource .
2014-03-17 11:17:56 +04:00
* @ return bool
2012-01-01 23:06:35 +04:00
*/
2012-01-02 02:26:24 +04:00
public function valid () { // apparently you can't name a method 'empty'...
2012-02-10 01:44:26 +04:00
return is_resource ( $this -> resource );
2012-01-02 02:26:24 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Returns the MIME type of the image or an empty string if no image is loaded .
2014-04-16 00:55:20 +04:00
* @ return string
2012-01-02 02:26:24 +04:00
*/
public function mimeType () {
2013-08-06 18:56:50 +04:00
return $this -> valid () ? $this -> mimeType : '' ;
2012-01-02 02:26:24 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Returns the width of the image or - 1 if no image is loaded .
2014-03-17 11:17:56 +04:00
* @ return int
2012-01-02 02:26:24 +04:00
*/
public function width () {
2012-02-12 17:28:16 +04:00
return $this -> valid () ? imagesx ( $this -> resource ) : - 1 ;
2012-01-02 02:26:24 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Returns the height of the image or - 1 if no image is loaded .
2014-03-17 11:17:56 +04:00
* @ return int
2012-01-02 02:26:24 +04:00
*/
public function height () {
2012-02-12 17:28:16 +04:00
return $this -> valid () ? imagesy ( $this -> resource ) : - 1 ;
2012-01-01 23:06:35 +04:00
}
2012-07-05 23:09:48 +04:00
/**
2014-05-19 19:50:53 +04:00
* Returns the width when the image orientation is top - left .
2014-03-17 11:17:56 +04:00
* @ return int
2012-07-05 23:09:48 +04:00
*/
public function widthTopLeft () {
$o = $this -> getOrientation ();
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->widthTopLeft() Orientation: ' . $o , OC_Log :: DEBUG );
2012-07-05 23:09:48 +04:00
switch ( $o ) {
case - 1 :
case 1 :
case 2 : // Not tested
case 3 :
case 4 : // Not tested
return $this -> width ();
case 5 : // Not tested
case 6 :
case 7 : // Not tested
case 8 :
return $this -> height ();
}
return $this -> width ();
}
/**
2014-05-19 19:50:53 +04:00
* Returns the height when the image orientation is top - left .
2014-03-17 11:17:56 +04:00
* @ return int
2012-07-05 23:09:48 +04:00
*/
public function heightTopLeft () {
$o = $this -> getOrientation ();
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->heightTopLeft() Orientation: ' . $o , OC_Log :: DEBUG );
2012-07-05 23:09:48 +04:00
switch ( $o ) {
case - 1 :
case 1 :
case 2 : // Not tested
case 3 :
case 4 : // Not tested
return $this -> height ();
case 5 : // Not tested
case 6 :
case 7 : // Not tested
case 8 :
return $this -> width ();
}
return $this -> height ();
}
2012-01-01 20:57:26 +04:00
/**
2014-05-19 19:50:53 +04:00
* Outputs the image .
2014-03-17 11:17:56 +04:00
* @ param string $mimeType
* @ return bool
*/
2014-03-14 14:13:45 +04:00
public function show ( $mimeType = null ) {
if ( $mimeType === null ) {
$mimeType = $this -> mimeType ();
}
header ( 'Content-Type: ' . $mimeType );
return $this -> _output ( null , $mimeType );
2012-01-02 15:09:45 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Saves the image .
2014-03-17 11:17:56 +04:00
* @ param string $filePath
* @ param string $mimeType
* @ return bool
*/
2012-01-02 16:40:23 +04:00
2014-03-14 14:13:45 +04:00
public function save ( $filePath = null , $mimeType = null ) {
if ( $mimeType === null ) {
$mimeType = $this -> mimeType ();
}
2013-08-06 18:56:50 +04:00
if ( $filePath === null && $this -> filePath === null ) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): called with no path.' , OC_Log :: ERROR );
2012-01-02 15:09:45 +04:00
return false ;
2013-08-06 18:56:50 +04:00
} elseif ( $filePath === null && $this -> filePath !== null ) {
$filePath = $this -> filePath ;
2012-01-02 15:09:45 +04:00
}
2014-03-14 14:13:45 +04:00
return $this -> _output ( $filePath , $mimeType );
2012-01-02 15:09:45 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Outputs / saves the image .
2014-03-17 11:17:56 +04:00
* @ param string $filePath
* @ param string $mimeType
* @ return bool
* @ throws Exception
*/
2014-03-14 14:13:45 +04:00
private function _output ( $filePath = null , $mimeType = null ) {
2013-08-06 18:56:50 +04:00
if ( $filePath ) {
if ( ! file_exists ( dirname ( $filePath )))
mkdir ( dirname ( $filePath ), 0777 , true );
if ( ! is_writable ( dirname ( $filePath ))) {
2013-02-11 20:44:02 +04:00
OC_Log :: write ( 'core' ,
2013-08-06 18:56:50 +04:00
__METHOD__ . '(): Directory \'' . dirname ( $filePath ) . '\' is not writable.' ,
2013-02-11 20:44:02 +04:00
OC_Log :: ERROR );
2012-01-02 16:40:23 +04:00
return false ;
2013-08-06 18:56:50 +04:00
} elseif ( is_writable ( dirname ( $filePath )) && file_exists ( $filePath ) && ! is_writable ( $filePath )) {
OC_Log :: write ( 'core' , __METHOD__ . '(): File \'' . $filePath . '\' is not writable.' , OC_Log :: ERROR );
2012-01-02 15:09:45 +04:00
return false ;
}
}
2012-02-08 01:33:01 +04:00
if ( ! $this -> valid ()) {
return false ;
}
2014-03-17 11:17:56 +04:00
$imageType = $this -> imageType ;
2014-03-14 14:13:45 +04:00
if ( $mimeType !== null ) {
switch ( $mimeType ) {
case 'image/gif' :
2014-03-14 14:17:20 +04:00
$imageType = IMAGETYPE_GIF ;
2014-03-14 14:13:45 +04:00
break ;
case 'image/jpeg' :
2014-03-14 14:17:20 +04:00
$imageType = IMAGETYPE_JPEG ;
2014-03-14 14:13:45 +04:00
break ;
case 'image/png' :
2014-03-14 14:17:20 +04:00
$imageType = IMAGETYPE_PNG ;
2014-03-14 14:13:45 +04:00
break ;
case 'image/x-xbitmap' :
2014-03-14 14:17:20 +04:00
$imageType = IMAGETYPE_XBM ;
2014-03-14 14:13:45 +04:00
break ;
case 'image/bmp' :
2014-03-14 14:17:20 +04:00
$imageType = IMAGETYPE_BMP ;
2014-03-14 14:13:45 +04:00
break ;
default :
2014-03-14 21:19:16 +04:00
throw new Exception ( '\OC_Image::_output(): "' . $mimeType . '" is not supported when forcing a specific output format' );
2014-03-14 14:13:45 +04:00
}
}
switch ( $imageType ) {
2012-01-02 02:26:24 +04:00
case IMAGETYPE_GIF :
2013-08-06 18:56:50 +04:00
$retVal = imagegif ( $this -> resource , $filePath );
2012-01-02 02:26:24 +04:00
break ;
case IMAGETYPE_JPEG :
2013-08-06 18:56:50 +04:00
$retVal = imagejpeg ( $this -> resource , $filePath );
2012-01-02 02:26:24 +04:00
break ;
case IMAGETYPE_PNG :
2013-08-06 18:56:50 +04:00
$retVal = imagepng ( $this -> resource , $filePath );
2012-01-02 02:26:24 +04:00
break ;
case IMAGETYPE_XBM :
2014-03-17 11:40:59 +04:00
if ( function_exists ( 'imagexbm' )) {
$retVal = imagexbm ( $this -> resource , $filePath );
} else {
throw new Exception ( '\OC_Image::_output(): imagexbm() is not supported.' );
}
2012-01-02 02:26:24 +04:00
break ;
case IMAGETYPE_WBMP :
2013-08-06 18:56:50 +04:00
$retVal = imagewbmp ( $this -> resource , $filePath );
2012-01-02 02:26:24 +04:00
break ;
2012-11-06 13:54:32 +04:00
case IMAGETYPE_BMP :
2013-08-06 18:56:50 +04:00
$retVal = imagebmp ( $this -> resource , $filePath , $this -> bitDepth );
2012-11-06 13:54:32 +04:00
break ;
2012-01-02 02:26:24 +04:00
default :
2013-08-06 18:56:50 +04:00
$retVal = imagepng ( $this -> resource , $filePath );
2012-01-02 02:26:24 +04:00
}
2013-08-06 18:56:50 +04:00
return $retVal ;
2012-01-01 20:57:26 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Prints the image when called as $image () .
2012-01-01 20:57:26 +04:00
*/
public function __invoke () {
2012-02-10 01:44:26 +04:00
return $this -> show ();
2012-01-01 20:57:26 +04:00
}
/**
2014-03-17 11:17:56 +04:00
* @ return resource Returns the image resource in any .
2012-01-01 20:57:26 +04:00
*/
2012-01-02 02:26:24 +04:00
public function resource () {
2012-02-10 01:44:26 +04:00
return $this -> resource ;
2012-01-01 20:57:26 +04:00
}
/**
2014-03-17 11:17:56 +04:00
* @ return string Returns the raw image data .
2012-01-01 20:57:26 +04:00
*/
2012-06-05 22:19:27 +04:00
function data () {
2012-01-01 20:57:26 +04:00
ob_start ();
2013-08-06 18:56:50 +04:00
switch ( $this -> mimeType ) {
case " image/png " :
$res = imagepng ( $this -> resource );
break ;
case " image/jpeg " :
$res = imagejpeg ( $this -> resource );
break ;
case " image/gif " :
$res = imagegif ( $this -> resource );
break ;
default :
$res = imagepng ( $this -> resource );
OC_Log :: write ( 'core' , 'OC_Image->data. Couldn\'t guess mimetype, defaulting to png' , OC_Log :: INFO );
break ;
}
2012-01-01 20:57:26 +04:00
if ( ! $res ) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , 'OC_Image->data. Error getting image data.' , OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
}
2012-06-05 22:19:27 +04:00
return ob_get_clean ();
}
/**
2014-02-27 02:56:46 +04:00
* @ return string - base64 encoded , which is suitable for embedding in a VCard .
*/
2012-06-05 22:19:27 +04:00
function __toString () {
return base64_encode ( $this -> data ());
2012-01-01 20:57:26 +04:00
}
2012-01-05 20:42:40 +04:00
/**
2012-01-08 18:35:29 +04:00
* ( I ' m open for suggestions on better method name ;)
2014-05-19 19:50:53 +04:00
* Get the orientation based on EXIF data .
2014-03-17 11:17:56 +04:00
* @ return int The orientation or - 1 if no EXIF data is available .
2012-01-05 20:42:40 +04:00
*/
2012-07-05 23:09:48 +04:00
public function getOrientation () {
2014-11-24 19:32:53 +03:00
if ( $this -> imageType !== IMAGETYPE_JPEG ) {
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() Image is not a JPEG.' , OC_Log :: DEBUG );
return - 1 ;
}
2012-09-07 17:22:01 +04:00
if ( ! is_callable ( 'exif_read_data' )) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() Exif module not enabled.' , OC_Log :: DEBUG );
2012-07-05 23:09:48 +04:00
return - 1 ;
2012-01-20 20:13:49 +04:00
}
2012-02-12 17:28:16 +04:00
if ( ! $this -> valid ()) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() No image loaded.' , OC_Log :: DEBUG );
2012-07-05 23:09:48 +04:00
return - 1 ;
2012-01-05 20:42:40 +04:00
}
2013-08-06 18:56:50 +04:00
if ( is_null ( $this -> filePath ) || ! is_readable ( $this -> filePath )) {
2012-11-04 14:10:46 +04:00
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() No readable file path set.' , OC_Log :: DEBUG );
2012-07-05 23:09:48 +04:00
return - 1 ;
2012-01-05 20:42:40 +04:00
}
2013-08-06 18:56:50 +04:00
$exif = @ exif_read_data ( $this -> filePath , 'IFD0' );
2012-01-05 20:42:40 +04:00
if ( ! $exif ) {
2012-07-05 23:09:48 +04:00
return - 1 ;
2012-01-05 20:42:40 +04:00
}
if ( ! isset ( $exif [ 'Orientation' ])) {
2012-07-05 23:09:48 +04:00
return - 1 ;
2012-01-05 20:42:40 +04:00
}
2012-07-05 23:09:48 +04:00
return $exif [ 'Orientation' ];
}
/**
* ( I ' m open for suggestions on better method name ;)
2014-05-19 19:50:53 +04:00
* Fixes orientation based on EXIF data .
2014-03-17 11:17:56 +04:00
* @ return bool .
2012-07-05 23:09:48 +04:00
*/
public function fixOrientation () {
2012-07-05 23:35:36 +04:00
$o = $this -> getOrientation ();
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() Orientation: ' . $o , OC_Log :: DEBUG );
2012-01-05 20:42:40 +04:00
$rotate = 0 ;
switch ( $o ) {
2012-07-05 23:09:48 +04:00
case - 1 :
return false ; //Nothing to fix
2012-01-05 20:42:40 +04:00
case 1 :
$rotate = 0 ;
break ;
case 2 : // Not tested
$rotate = 0 ;
break ;
case 3 :
$rotate = 180 ;
break ;
case 4 : // Not tested
$rotate = 180 ;
break ;
case 5 : // Not tested
$rotate = 90 ;
break ;
case 6 :
//$rotate = 90;
$rotate = 270 ;
break ;
case 7 : // Not tested
$rotate = 270 ;
break ;
case 8 :
2012-02-08 01:33:01 +04:00
$rotate = 90 ;
2012-01-05 20:42:40 +04:00
break ;
}
if ( $rotate ) {
2014-02-13 01:35:49 +04:00
$res = imagerotate ( $this -> resource , $rotate , 0 );
2012-01-05 20:42:40 +04:00
if ( $res ) {
if ( imagealphablending ( $res , true )) {
if ( imagesavealpha ( $res , true )) {
2012-03-27 01:53:48 +04:00
imagedestroy ( $this -> resource );
2012-02-10 01:44:26 +04:00
$this -> resource = $res ;
2012-01-05 20:42:40 +04:00
return true ;
} else {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() Error during alphasaving.' , OC_Log :: DEBUG );
2012-01-05 20:42:40 +04:00
return false ;
}
} else {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() Error during alphablending.' , OC_Log :: DEBUG );
2012-01-05 20:42:40 +04:00
return false ;
}
} else {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->fixOrientation() Error during oriention fixing.' , OC_Log :: DEBUG );
2012-01-05 20:42:40 +04:00
return false ;
}
}
2014-02-27 02:56:46 +04:00
return false ;
2012-01-05 20:42:40 +04:00
}
2012-01-01 20:57:26 +04:00
/**
2014-05-19 19:50:53 +04:00
* Loads an image from a local file , a base64 encoded string or a resource created by an imagecreate * function .
2014-04-16 00:55:20 +04:00
* @ param resource | string $imageRef The path to a local file , a base64 encoded string or a resource created by an imagecreate * function or a file resource ( file handle ) .
2014-03-17 11:17:56 +04:00
* @ return resource | false An image resource or false on error
*/
2013-08-06 18:56:50 +04:00
public function load ( $imageRef ) {
if ( is_resource ( $imageRef )) {
if ( get_resource_type ( $imageRef ) == 'gd' ) {
$this -> resource = $imageRef ;
2012-02-16 13:35:35 +04:00
return $this -> resource ;
2013-08-06 18:56:50 +04:00
} elseif ( in_array ( get_resource_type ( $imageRef ), array ( 'file' , 'stream' ))) {
return $this -> loadFromFileHandle ( $imageRef );
2012-02-16 13:35:35 +04:00
}
2013-08-06 18:56:50 +04:00
} elseif ( $this -> loadFromBase64 ( $imageRef ) !== false ) {
2012-02-10 01:44:26 +04:00
return $this -> resource ;
2014-02-13 01:35:49 +04:00
} elseif ( $this -> loadFromFile ( $imageRef ) !== false ) {
return $this -> resource ;
2013-08-06 18:56:50 +04:00
} elseif ( $this -> loadFromData ( $imageRef ) !== false ) {
2012-02-10 01:44:26 +04:00
return $this -> resource ;
2012-01-01 20:57:26 +04:00
} else {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): couldn\'t load anything. Giving up!' , OC_Log :: DEBUG );
2012-01-01 20:57:26 +04:00
return false ;
}
}
2012-02-16 13:35:35 +04:00
/**
2014-05-19 19:50:53 +04:00
* Loads an image from an open file handle .
2012-02-16 13:35:35 +04:00
* It is the responsibility of the caller to position the pointer at the correct place and to close the handle again .
2014-02-06 19:30:58 +04:00
* @ param resource $handle
2014-05-12 00:51:30 +04:00
* @ return resource | false An image resource or false on error
2012-02-16 13:35:35 +04:00
*/
public function loadFromFileHandle ( $handle ) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): Trying' , OC_Log :: DEBUG );
2012-03-27 00:33:37 +04:00
$contents = stream_get_contents ( $handle );
2012-02-16 13:35:35 +04:00
if ( $this -> loadFromData ( $contents )) {
return $this -> resource ;
}
}
2012-01-01 20:57:26 +04:00
/**
2014-05-19 19:50:53 +04:00
* Loads an image from a local file .
2014-03-17 11:17:56 +04:00
* @ param bool | string $imagePath The path to a local file .
* @ return bool | resource An image resource or false on error
2012-01-01 20:57:26 +04:00
*/
2013-08-06 18:56:50 +04:00
public function loadFromFile ( $imagePath = false ) {
2013-03-02 13:51:49 +04:00
// exif_imagetype throws "read error!" if file is less than 12 byte
2013-11-22 21:01:44 +04:00
if ( !@ is_file ( $imagePath ) || ! file_exists ( $imagePath ) || filesize ( $imagePath ) < 12 || ! is_readable ( $imagePath )) {
2014-01-11 15:07:28 +04:00
OC_Log :: write ( 'core' , 'OC_Image->loadFromFile, couldn\'t load: ' . ( string ) urlencode ( $imagePath ), OC_Log :: DEBUG );
2012-01-01 20:57:26 +04:00
return false ;
}
2013-11-22 21:01:44 +04:00
$iType = exif_imagetype ( $imagePath );
2013-08-06 18:56:50 +04:00
switch ( $iType ) {
2012-01-02 02:26:24 +04:00
case IMAGETYPE_GIF :
if ( imagetypes () & IMG_GIF ) {
2013-11-22 21:01:44 +04:00
$this -> resource = imagecreatefromgif ( $imagePath );
2014-08-12 13:00:00 +04:00
// Preserve transparency
imagealphablending ( $this -> resource , true );
imagesavealpha ( $this -> resource , true );
2012-01-02 16:40:23 +04:00
} else {
2013-02-11 20:44:02 +04:00
OC_Log :: write ( 'core' ,
2013-11-22 21:01:44 +04:00
'OC_Image->loadFromFile, GIF images not supported: ' . $imagePath ,
2013-02-11 20:44:02 +04:00
OC_Log :: DEBUG );
2012-01-02 02:26:24 +04:00
}
break ;
case IMAGETYPE_JPEG :
if ( imagetypes () & IMG_JPG ) {
2013-11-22 21:01:44 +04:00
$this -> resource = imagecreatefromjpeg ( $imagePath );
2012-01-02 16:40:23 +04:00
} else {
2013-02-11 20:44:02 +04:00
OC_Log :: write ( 'core' ,
2013-11-22 21:01:44 +04:00
'OC_Image->loadFromFile, JPG images not supported: ' . $imagePath ,
2013-02-11 20:44:02 +04:00
OC_Log :: DEBUG );
2012-01-02 02:26:24 +04:00
}
break ;
case IMAGETYPE_PNG :
if ( imagetypes () & IMG_PNG ) {
2013-11-22 21:01:44 +04:00
$this -> resource = imagecreatefrompng ( $imagePath );
2014-08-12 13:00:00 +04:00
// Preserve transparency
imagealphablending ( $this -> resource , true );
imagesavealpha ( $this -> resource , true );
2012-01-02 16:40:23 +04:00
} else {
2013-02-11 20:44:02 +04:00
OC_Log :: write ( 'core' ,
2013-11-22 21:01:44 +04:00
'OC_Image->loadFromFile, PNG images not supported: ' . $imagePath ,
2013-02-11 20:44:02 +04:00
OC_Log :: DEBUG );
2012-01-02 02:26:24 +04:00
}
break ;
case IMAGETYPE_XBM :
if ( imagetypes () & IMG_XPM ) {
2013-11-22 21:01:44 +04:00
$this -> resource = imagecreatefromxbm ( $imagePath );
2012-01-02 16:40:23 +04:00
} else {
2013-02-11 20:44:02 +04:00
OC_Log :: write ( 'core' ,
2013-11-22 21:01:44 +04:00
'OC_Image->loadFromFile, XBM/XPM images not supported: ' . $imagePath ,
2013-02-11 20:44:02 +04:00
OC_Log :: DEBUG );
2012-01-02 02:26:24 +04:00
}
break ;
case IMAGETYPE_WBMP :
if ( imagetypes () & IMG_WBMP ) {
2013-11-22 21:01:44 +04:00
$this -> resource = imagecreatefromwbmp ( $imagePath );
2012-01-02 16:40:23 +04:00
} else {
2013-02-11 20:44:02 +04:00
OC_Log :: write ( 'core' ,
2013-11-22 21:01:44 +04:00
'OC_Image->loadFromFile, WBMP images not supported: ' . $imagePath ,
2013-02-11 20:44:02 +04:00
OC_Log :: DEBUG );
2012-01-02 02:26:24 +04:00
}
break ;
2012-11-06 13:54:32 +04:00
case IMAGETYPE_BMP :
2013-11-22 21:01:44 +04:00
$this -> resource = $this -> imagecreatefrombmp ( $imagePath );
2012-11-06 13:54:32 +04:00
break ;
2012-01-02 02:26:24 +04:00
/*
case IMAGETYPE_TIFF_II : // (intel byte order)
break ;
case IMAGETYPE_TIFF_MM : // (motorola byte order)
break ;
case IMAGETYPE_JPC :
break ;
case IMAGETYPE_JP2 :
break ;
case IMAGETYPE_JPX :
break ;
case IMAGETYPE_JB2 :
break ;
case IMAGETYPE_SWC :
break ;
case IMAGETYPE_IFF :
break ;
case IMAGETYPE_ICO :
break ;
case IMAGETYPE_SWF :
break ;
case IMAGETYPE_PSD :
break ;
*/
default :
2012-08-29 10:38:33 +04:00
2012-06-09 17:12:28 +04:00
// this is mostly file created from encrypted file
2013-11-22 21:01:44 +04:00
$this -> resource = imagecreatefromstring ( \OC\Files\Filesystem :: file_get_contents ( \OC\Files\Filesystem :: getLocalPath ( $imagePath )));
2013-08-06 18:56:50 +04:00
$iType = IMAGETYPE_PNG ;
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->loadFromFile, Default' , OC_Log :: DEBUG );
2012-01-02 02:26:24 +04:00
break ;
}
2012-01-02 03:43:27 +04:00
if ( $this -> valid ()) {
2013-08-06 18:56:50 +04:00
$this -> imageType = $iType ;
$this -> mimeType = image_type_to_mime_type ( $iType );
$this -> filePath = $imagePath ;
2012-01-02 02:26:24 +04:00
}
2012-02-10 01:44:26 +04:00
return $this -> resource ;
2012-01-01 20:57:26 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Loads an image from a string of data .
2014-03-17 11:17:56 +04:00
* @ param string $str A string of image data as read from a file .
* @ return bool | resource An image resource or false on error
2012-01-01 20:57:26 +04:00
*/
2012-01-02 03:43:27 +04:00
public function loadFromData ( $str ) {
2012-01-01 20:57:26 +04:00
if ( is_resource ( $str )) {
return false ;
}
2012-06-02 17:25:50 +04:00
$this -> resource = @ imagecreatefromstring ( $str );
2013-09-01 17:50:58 +04:00
if ( $this -> fileInfo ) {
2013-08-06 18:56:50 +04:00
$this -> mimeType = $this -> fileInfo -> buffer ( $str );
}
2013-08-15 18:13:01 +04:00
if ( is_resource ( $this -> resource )) {
imagealphablending ( $this -> resource , false );
imagesavealpha ( $this -> resource , true );
}
2013-08-15 15:21:35 +04:00
2012-02-10 01:44:26 +04:00
if ( ! $this -> resource ) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->loadFromData, couldn\'t load' , OC_Log :: DEBUG );
2012-01-01 20:57:26 +04:00
return false ;
}
2012-02-10 01:44:26 +04:00
return $this -> resource ;
2012-01-01 20:57:26 +04:00
}
/**
2014-05-19 19:50:53 +04:00
* Loads an image from a base64 encoded string .
2014-03-17 11:17:56 +04:00
* @ param string $str A string base64 encoded string of image data .
* @ return bool | resource An image resource or false on error
2012-01-01 20:57:26 +04:00
*/
2012-01-02 03:43:27 +04:00
public function loadFromBase64 ( $str ) {
2012-01-01 20:57:26 +04:00
if ( ! is_string ( $str )) {
return false ;
}
$data = base64_decode ( $str );
if ( $data ) { // try to load from string data
2012-06-02 17:25:50 +04:00
$this -> resource = @ imagecreatefromstring ( $data );
2013-09-01 17:50:58 +04:00
if ( $this -> fileInfo ) {
2013-08-06 18:56:50 +04:00
$this -> mimeType = $this -> fileInfo -> buffer ( $data );
}
2012-02-10 01:44:26 +04:00
if ( ! $this -> resource ) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->loadFromBase64, couldn\'t load' , OC_Log :: DEBUG );
2012-01-01 20:57:26 +04:00
return false ;
}
2012-02-10 01:44:26 +04:00
return $this -> resource ;
2012-01-01 20:57:26 +04:00
} else {
return false ;
}
}
2012-11-12 14:39:04 +04:00
/**
* Create a new image from file or URL
* @ link http :// www . programmierer - forum . de / function - imagecreatefrombmp - laeuft - mit - allen - bitraten - t143137 . htm
* @ version 1.00
2014-02-06 19:30:58 +04:00
* @ param string $fileName < p >
2012-11-12 14:39:04 +04:00
* Path to the BMP image .
* </ p >
2014-03-17 11:17:56 +04:00
* @ return bool | resource an image resource identifier on success , < b > FALSE </ b > on errors .
2012-11-12 14:39:04 +04:00
*/
2013-08-06 18:56:50 +04:00
private function imagecreatefrombmp ( $fileName ) {
if ( ! ( $fh = fopen ( $fileName , 'rb' ))) {
trigger_error ( 'imagecreatefrombmp: Can not open ' . $fileName , E_USER_WARNING );
2012-11-06 13:54:32 +04:00
return false ;
}
// read file header
$meta = unpack ( 'vtype/Vfilesize/Vreserved/Voffset' , fread ( $fh , 14 ));
// check for bitmap
if ( $meta [ 'type' ] != 19778 ) {
2014-08-13 17:19:58 +04:00
fclose ( $fh );
2013-08-06 18:56:50 +04:00
trigger_error ( 'imagecreatefrombmp: ' . $fileName . ' is not a bitmap!' , E_USER_WARNING );
2012-11-06 13:54:32 +04:00
return false ;
}
// read image header
$meta += unpack ( 'Vheadersize/Vwidth/Vheight/vplanes/vbits/Vcompression/Vimagesize/Vxres/Vyres/Vcolors/Vimportant' , fread ( $fh , 40 ));
// read additional 16bit header
if ( $meta [ 'bits' ] == 16 ) {
$meta += unpack ( 'VrMask/VgMask/VbMask' , fread ( $fh , 12 ));
}
// set bytes and padding
$meta [ 'bytes' ] = $meta [ 'bits' ] / 8 ;
2013-08-06 18:56:50 +04:00
$this -> bitDepth = $meta [ 'bits' ]; //remember the bit depth for the imagebmp call
2012-11-06 13:54:32 +04:00
$meta [ 'decal' ] = 4 - ( 4 * (( $meta [ 'width' ] * $meta [ 'bytes' ] / 4 ) - floor ( $meta [ 'width' ] * $meta [ 'bytes' ] / 4 )));
if ( $meta [ 'decal' ] == 4 ) {
$meta [ 'decal' ] = 0 ;
}
// obtain imagesize
if ( $meta [ 'imagesize' ] < 1 ) {
$meta [ 'imagesize' ] = $meta [ 'filesize' ] - $meta [ 'offset' ];
// in rare cases filesize is equal to offset so we need to read physical size
if ( $meta [ 'imagesize' ] < 1 ) {
2014-02-27 02:56:46 +04:00
$meta [ 'imagesize' ] = @ filesize ( $fileName ) - $meta [ 'offset' ];
2012-11-06 13:54:32 +04:00
if ( $meta [ 'imagesize' ] < 1 ) {
2014-08-13 17:19:58 +04:00
fclose ( $fh );
2014-02-27 02:56:46 +04:00
trigger_error ( 'imagecreatefrombmp: Can not obtain filesize of ' . $fileName . '!' , E_USER_WARNING );
2012-11-06 13:54:32 +04:00
return false ;
}
}
}
// calculate colors
$meta [ 'colors' ] = ! $meta [ 'colors' ] ? pow ( 2 , $meta [ 'bits' ]) : $meta [ 'colors' ];
// read color palette
$palette = array ();
if ( $meta [ 'bits' ] < 16 ) {
$palette = unpack ( 'l' . $meta [ 'colors' ], fread ( $fh , $meta [ 'colors' ] * 4 ));
// in rare cases the color value is signed
if ( $palette [ 1 ] < 0 ) {
foreach ( $palette as $i => $color ) {
$palette [ $i ] = $color + 16777216 ;
}
}
}
// create gd image
$im = imagecreatetruecolor ( $meta [ 'width' ], $meta [ 'height' ]);
2014-09-16 03:12:07 +04:00
if ( $im == FALSE ) {
fclose ( $fh );
trigger_error ( 'imagecreatefrombmp(): imagecreatetruecolor failed for file "' . $fileName . '" with dimensions ' . $meta [ 'width' ] . 'x' . $meta [ 'height' ], E_USER_WARNING );
return FALSE ;
}
2012-11-06 13:54:32 +04:00
$data = fread ( $fh , $meta [ 'imagesize' ]);
$p = 0 ;
$vide = chr ( 0 );
$y = $meta [ 'height' ] - 1 ;
2013-08-06 18:56:50 +04:00
$error = 'imagecreatefrombmp: ' . $fileName . ' has not enough data!' ;
2012-11-06 13:54:32 +04:00
// loop through the image data beginning with the lower left corner
while ( $y >= 0 ) {
$x = 0 ;
while ( $x < $meta [ 'width' ]) {
switch ( $meta [ 'bits' ]) {
case 32 :
case 24 :
if ( ! ( $part = substr ( $data , $p , 3 ))) {
trigger_error ( $error , E_USER_WARNING );
return $im ;
}
$color = unpack ( 'V' , $part . $vide );
break ;
case 16 :
if ( ! ( $part = substr ( $data , $p , 2 ))) {
2014-08-13 17:19:58 +04:00
fclose ( $fh );
2012-11-06 13:54:32 +04:00
trigger_error ( $error , E_USER_WARNING );
return $im ;
}
$color = unpack ( 'v' , $part );
$color [ 1 ] = (( $color [ 1 ] & 0xf800 ) >> 8 ) * 65536 + (( $color [ 1 ] & 0x07e0 ) >> 3 ) * 256 + (( $color [ 1 ] & 0x001f ) << 3 );
break ;
case 8 :
$color = unpack ( 'n' , $vide . substr ( $data , $p , 1 ));
$color [ 1 ] = $palette [ $color [ 1 ] + 1 ];
break ;
case 4 :
$color = unpack ( 'n' , $vide . substr ( $data , floor ( $p ), 1 ));
$color [ 1 ] = ( $p * 2 ) % 2 == 0 ? $color [ 1 ] >> 4 : $color [ 1 ] & 0x0F ;
$color [ 1 ] = $palette [ $color [ 1 ] + 1 ];
break ;
case 1 :
$color = unpack ( 'n' , $vide . substr ( $data , floor ( $p ), 1 ));
switch (( $p * 8 ) % 8 ) {
case 0 :
$color [ 1 ] = $color [ 1 ] >> 7 ;
break ;
case 1 :
$color [ 1 ] = ( $color [ 1 ] & 0x40 ) >> 6 ;
break ;
case 2 :
$color [ 1 ] = ( $color [ 1 ] & 0x20 ) >> 5 ;
break ;
case 3 :
$color [ 1 ] = ( $color [ 1 ] & 0x10 ) >> 4 ;
break ;
case 4 :
$color [ 1 ] = ( $color [ 1 ] & 0x8 ) >> 3 ;
break ;
case 5 :
$color [ 1 ] = ( $color [ 1 ] & 0x4 ) >> 2 ;
break ;
case 6 :
$color [ 1 ] = ( $color [ 1 ] & 0x2 ) >> 1 ;
break ;
case 7 :
$color [ 1 ] = ( $color [ 1 ] & 0x1 );
break ;
}
$color [ 1 ] = $palette [ $color [ 1 ] + 1 ];
break ;
default :
2014-08-13 17:19:58 +04:00
fclose ( $fh );
2013-02-11 20:44:02 +04:00
trigger_error ( 'imagecreatefrombmp: '
2013-08-06 18:56:50 +04:00
. $fileName . ' has ' . $meta [ 'bits' ] . ' bits and this is not supported!' ,
2013-02-11 20:44:02 +04:00
E_USER_WARNING );
2012-11-06 13:54:32 +04:00
return false ;
}
imagesetpixel ( $im , $x , $y , $color [ 1 ]);
$x ++ ;
$p += $meta [ 'bytes' ];
}
$y -- ;
$p += $meta [ 'decal' ];
}
fclose ( $fh );
return $im ;
}
2013-01-14 23:30:39 +04:00
2012-01-01 20:57:26 +04:00
/**
2014-05-19 19:50:53 +04:00
* Resizes the image preserving ratio .
2014-02-19 12:31:54 +04:00
* @ param integer $maxSize The maximum size of either the width or height .
2014-03-17 11:17:56 +04:00
* @ return bool
2012-01-01 20:57:26 +04:00
*/
2013-08-06 18:56:50 +04:00
public function resize ( $maxSize ) {
2012-02-12 17:28:16 +04:00
if ( ! $this -> valid ()) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): No image loaded' , OC_Log :: ERROR );
2012-01-01 21:07:46 +04:00
return false ;
2012-01-01 20:57:26 +04:00
}
2013-08-06 18:56:50 +04:00
$widthOrig = imageSX ( $this -> resource );
$heightOrig = imageSY ( $this -> resource );
$ratioOrig = $widthOrig / $heightOrig ;
2012-08-29 10:38:33 +04:00
2013-08-06 18:56:50 +04:00
if ( $ratioOrig > 1 ) {
$newHeight = round ( $maxSize / $ratioOrig );
$newWidth = $maxSize ;
2012-01-01 20:57:26 +04:00
} else {
2013-08-06 18:56:50 +04:00
$newWidth = round ( $maxSize * $ratioOrig );
$newHeight = $maxSize ;
2012-01-01 20:57:26 +04:00
}
2013-08-06 18:56:50 +04:00
$this -> preciseResize ( round ( $newWidth ), round ( $newHeight ));
2012-01-01 20:57:26 +04:00
return true ;
}
2014-03-17 11:17:56 +04:00
/**
* @ param int $width
* @ param int $height
* @ return bool
*/
2012-06-02 17:25:50 +04:00
public function preciseResize ( $width , $height ) {
if ( ! $this -> valid ()) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): No image loaded' , OC_Log :: ERROR );
2012-08-29 10:38:33 +04:00
return false ;
2012-06-02 17:25:50 +04:00
}
2013-08-06 18:56:50 +04:00
$widthOrig = imageSX ( $this -> resource );
$heightOrig = imageSY ( $this -> resource );
2012-06-02 17:25:50 +04:00
$process = imagecreatetruecolor ( $width , $height );
if ( $process == false ) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): Error creating true color image' , OC_Log :: ERROR );
2012-06-02 17:25:50 +04:00
imagedestroy ( $process );
return false ;
}
2013-02-22 15:42:40 +04:00
// preserve transparency
2013-08-06 18:56:50 +04:00
if ( $this -> imageType == IMAGETYPE_GIF or $this -> imageType == IMAGETYPE_PNG ) {
2013-02-22 15:42:40 +04:00
imagecolortransparent ( $process , imagecolorallocatealpha ( $process , 0 , 0 , 0 , 127 ));
imagealphablending ( $process , false );
imagesavealpha ( $process , true );
}
2013-08-06 18:56:50 +04:00
imagecopyresampled ( $process , $this -> resource , 0 , 0 , 0 , 0 , $width , $height , $widthOrig , $heightOrig );
2012-06-02 17:25:50 +04:00
if ( $process == false ) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): Error resampling process image ' . $width . 'x' . $height , OC_Log :: ERROR );
2012-06-02 17:25:50 +04:00
imagedestroy ( $process );
return false ;
}
imagedestroy ( $this -> resource );
$this -> resource = $process ;
return true ;
}
2012-01-01 20:57:26 +04:00
/**
2014-05-19 19:50:53 +04:00
* Crops the image to the middle square . If the image is already square it just returns .
2014-03-17 11:17:56 +04:00
* @ param int $size maximum size for the result ( optional )
* @ return bool for success or failure
2012-01-01 20:57:26 +04:00
*/
2012-03-27 01:53:48 +04:00
public function centerCrop ( $size = 0 ) {
2012-02-12 17:28:16 +04:00
if ( ! $this -> valid ()) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , 'OC_Image->centerCrop, No image loaded' , OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
return false ;
}
2013-08-06 18:56:50 +04:00
$widthOrig = imageSX ( $this -> resource );
$heightOrig = imageSY ( $this -> resource );
if ( $widthOrig === $heightOrig and $size == 0 ) {
2012-01-01 20:57:26 +04:00
return true ;
}
2013-08-06 18:56:50 +04:00
$ratioOrig = $widthOrig / $heightOrig ;
$width = $height = min ( $widthOrig , $heightOrig );
2012-01-01 20:57:26 +04:00
2013-08-06 18:56:50 +04:00
if ( $ratioOrig > 1 ) {
$x = ( $widthOrig / 2 ) - ( $width / 2 );
2012-01-01 20:57:26 +04:00
$y = 0 ;
} else {
2013-08-06 18:56:50 +04:00
$y = ( $heightOrig / 2 ) - ( $height / 2 );
2012-01-01 20:57:26 +04:00
$x = 0 ;
}
2012-09-07 17:22:01 +04:00
if ( $size > 0 ) {
2012-03-27 01:53:48 +04:00
$targetWidth = $size ;
$targetHeight = $size ;
} else {
$targetWidth = $width ;
$targetHeight = $height ;
}
$process = imagecreatetruecolor ( $targetWidth , $targetHeight );
2012-01-01 20:57:26 +04:00
if ( $process == false ) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , 'OC_Image->centerCrop. Error creating true color image' , OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
imagedestroy ( $process );
return false ;
}
2013-02-22 15:42:40 +04:00
// preserve transparency
2013-08-06 18:56:50 +04:00
if ( $this -> imageType == IMAGETYPE_GIF or $this -> imageType == IMAGETYPE_PNG ) {
2013-02-22 15:42:40 +04:00
imagecolortransparent ( $process , imagecolorallocatealpha ( $process , 0 , 0 , 0 , 127 ));
imagealphablending ( $process , false );
imagesavealpha ( $process , true );
}
2013-02-22 20:21:57 +04:00
2012-03-27 01:53:48 +04:00
imagecopyresampled ( $process , $this -> resource , 0 , 0 , $x , $y , $targetWidth , $targetHeight , $width , $height );
2012-01-01 20:57:26 +04:00
if ( $process == false ) {
2013-02-11 20:44:02 +04:00
OC_Log :: write ( 'core' ,
'OC_Image->centerCrop. Error resampling process image ' . $width . 'x' . $height ,
OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
imagedestroy ( $process );
return false ;
}
2012-03-27 00:28:40 +04:00
imagedestroy ( $this -> resource );
2012-02-10 01:44:26 +04:00
$this -> resource = $process ;
2012-01-01 20:57:26 +04:00
return true ;
}
/**
2014-05-19 19:50:53 +04:00
* Crops the image from point $x $y with dimension $wx $h .
2014-03-17 11:17:56 +04:00
* @ param int $x Horizontal position
* @ param int $y Vertical position
* @ param int $w Width
* @ param int $h Height
* @ return bool for success or failure
2012-01-01 20:57:26 +04:00
*/
public function crop ( $x , $y , $w , $h ) {
2012-02-12 17:28:16 +04:00
if ( ! $this -> valid ()) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): No image loaded' , OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
return false ;
}
$process = imagecreatetruecolor ( $w , $h );
if ( $process == false ) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): Error creating true color image' , OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
imagedestroy ( $process );
return false ;
}
2014-07-30 14:16:03 +04:00
// preserve transparency
if ( $this -> imageType == IMAGETYPE_GIF or $this -> imageType == IMAGETYPE_PNG ) {
imagecolortransparent ( $process , imagecolorallocatealpha ( $process , 0 , 0 , 0 , 127 ));
imagealphablending ( $process , false );
imagesavealpha ( $process , true );
}
2012-02-10 01:44:26 +04:00
imagecopyresampled ( $process , $this -> resource , 0 , 0 , $x , $y , $w , $h , $w , $h );
2012-01-01 20:57:26 +04:00
if ( $process == false ) {
2012-10-29 02:58:08 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): Error resampling process image ' . $w . 'x' . $h , OC_Log :: ERROR );
2012-01-01 20:57:26 +04:00
imagedestroy ( $process );
return false ;
}
2012-03-27 00:28:40 +04:00
imagedestroy ( $this -> resource );
2012-02-10 01:44:26 +04:00
$this -> resource = $process ;
2012-01-01 20:57:26 +04:00
return true ;
}
2012-03-27 00:28:40 +04:00
2012-09-09 01:26:19 +04:00
/**
2014-05-19 19:50:53 +04:00
* Resizes the image to fit within a boundry while preserving ratio .
2014-02-19 12:31:54 +04:00
* @ param integer $maxWidth
* @ param integer $maxHeight
2014-03-17 11:17:56 +04:00
* @ return bool
2012-09-09 01:26:19 +04:00
*/
public function fitIn ( $maxWidth , $maxHeight ) {
if ( ! $this -> valid ()) {
2012-10-28 21:28:16 +04:00
OC_Log :: write ( 'core' , __METHOD__ . '(): No image loaded' , OC_Log :: ERROR );
2012-09-09 01:26:19 +04:00
return false ;
}
2013-08-06 18:56:50 +04:00
$widthOrig = imageSX ( $this -> resource );
$heightOrig = imageSY ( $this -> resource );
$ratio = $widthOrig / $heightOrig ;
2012-09-09 01:26:19 +04:00
$newWidth = min ( $maxWidth , $ratio * $maxHeight );
$newHeight = min ( $maxHeight , $maxWidth / $ratio );
2012-10-14 23:04:08 +04:00
2012-09-09 01:26:19 +04:00
$this -> preciseResize ( round ( $newWidth ), round ( $newHeight ));
return true ;
}
2012-09-07 17:22:01 +04:00
public function destroy () {
if ( $this -> valid ()) {
2012-03-27 00:28:40 +04:00
imagedestroy ( $this -> resource );
}
2012-03-27 01:53:48 +04:00
$this -> resource = null ;
}
2012-09-07 17:22:01 +04:00
public function __destruct () {
2012-03-27 01:53:48 +04:00
$this -> destroy ();
2012-03-27 00:28:40 +04:00
}
2012-01-01 20:57:26 +04:00
}
2012-11-12 16:56:29 +04:00
if ( ! function_exists ( 'imagebmp' ) ) {
/**
* Output a BMP image to either the browser or a file
* @ link http :// www . ugia . cn / wp - data / imagebmp . php
* @ author legend < legendsky @ hotmail . com >
* @ link http :// www . programmierer - forum . de / imagebmp - gute - funktion - gefunden - t143716 . htm
* @ author mgutt < marc @ gutt . it >
* @ version 1.00
2014-02-06 19:30:58 +04:00
* @ param string $fileName [ optional ] < p > The path to save the file to .</ p >
2012-11-12 16:56:29 +04:00
* @ param int $bit [ optional ] < p > Bit depth , ( default is 24 ) .</ p >
* @ param int $compression [ optional ]
* @ return bool < b > TRUE </ b > on success or < b > FALSE </ b > on failure .
*/
2013-08-06 18:56:50 +04:00
function imagebmp ( $im , $fileName = '' , $bit = 24 , $compression = 0 ) {
2012-11-12 16:56:29 +04:00
if ( ! in_array ( $bit , array ( 1 , 4 , 8 , 16 , 24 , 32 ))) {
$bit = 24 ;
}
else if ( $bit == 32 ) {
$bit = 24 ;
}
$bits = pow ( 2 , $bit );
imagetruecolortopalette ( $im , true , $bits );
$width = imagesx ( $im );
$height = imagesy ( $im );
2013-08-06 18:56:50 +04:00
$colorsNum = imagecolorstotal ( $im );
$rgbQuad = '' ;
2012-11-12 16:56:29 +04:00
if ( $bit <= 8 ) {
2013-08-06 18:56:50 +04:00
for ( $i = 0 ; $i < $colorsNum ; $i ++ ) {
2012-11-12 16:56:29 +04:00
$colors = imagecolorsforindex ( $im , $i );
2013-08-06 18:56:50 +04:00
$rgbQuad .= chr ( $colors [ 'blue' ]) . chr ( $colors [ 'green' ]) . chr ( $colors [ 'red' ]) . " \0 " ;
2012-11-12 16:56:29 +04:00
}
2013-08-06 18:56:50 +04:00
$bmpData = '' ;
2012-11-12 16:56:29 +04:00
if ( $compression == 0 || $bit < 8 ) {
$compression = 0 ;
$extra = '' ;
$padding = 4 - ceil ( $width / ( 8 / $bit )) % 4 ;
if ( $padding % 4 != 0 ) {
$extra = str_repeat ( " \0 " , $padding );
}
for ( $j = $height - 1 ; $j >= 0 ; $j -- ) {
$i = 0 ;
while ( $i < $width ) {
$bin = 0 ;
$limit = $width - $i < 8 / $bit ? ( 8 / $bit - $width + $i ) * $bit : 0 ;
for ( $k = 8 - $bit ; $k >= $limit ; $k -= $bit ) {
$index = imagecolorat ( $im , $i , $j );
$bin |= $index << $k ;
$i ++ ;
}
2013-08-06 18:56:50 +04:00
$bmpData .= chr ( $bin );
2012-11-12 16:56:29 +04:00
}
2013-08-06 18:56:50 +04:00
$bmpData .= $extra ;
2012-11-12 16:56:29 +04:00
}
}
// RLE8
else if ( $compression == 1 && $bit == 8 ) {
for ( $j = $height - 1 ; $j >= 0 ; $j -- ) {
2013-08-06 18:56:50 +04:00
$lastIndex = " \0 " ;
$sameNum = 0 ;
2012-11-12 16:56:29 +04:00
for ( $i = 0 ; $i <= $width ; $i ++ ) {
$index = imagecolorat ( $im , $i , $j );
2013-08-06 18:56:50 +04:00
if ( $index !== $lastIndex || $sameNum > 255 ) {
if ( $sameNum != 0 ) {
2014-02-27 02:56:46 +04:00
$bmpData .= chr ( $sameNum ) . chr ( $lastIndex );
2012-11-12 16:56:29 +04:00
}
2013-08-06 18:56:50 +04:00
$lastIndex = $index ;
$sameNum = 1 ;
2012-11-12 16:56:29 +04:00
}
else {
2013-08-06 18:56:50 +04:00
$sameNum ++ ;
2012-11-12 16:56:29 +04:00
}
}
2013-08-06 18:56:50 +04:00
$bmpData .= " \0 \0 " ;
2012-11-12 16:56:29 +04:00
}
2013-08-06 18:56:50 +04:00
$bmpData .= " \0 \1 " ;
2012-11-12 16:56:29 +04:00
}
2013-08-06 18:56:50 +04:00
$sizeQuad = strlen ( $rgbQuad );
$sizeData = strlen ( $bmpData );
2012-11-12 16:56:29 +04:00
}
else {
$extra = '' ;
$padding = 4 - ( $width * ( $bit / 8 )) % 4 ;
if ( $padding % 4 != 0 ) {
$extra = str_repeat ( " \0 " , $padding );
}
2013-08-06 18:56:50 +04:00
$bmpData = '' ;
2012-11-12 16:56:29 +04:00
for ( $j = $height - 1 ; $j >= 0 ; $j -- ) {
for ( $i = 0 ; $i < $width ; $i ++ ) {
$index = imagecolorat ( $im , $i , $j );
$colors = imagecolorsforindex ( $im , $index );
if ( $bit == 16 ) {
$bin = 0 << $bit ;
$bin |= ( $colors [ 'red' ] >> 3 ) << 10 ;
$bin |= ( $colors [ 'green' ] >> 3 ) << 5 ;
$bin |= $colors [ 'blue' ] >> 3 ;
2013-08-06 18:56:50 +04:00
$bmpData .= pack ( " v " , $bin );
2012-11-12 16:56:29 +04:00
}
else {
2013-08-06 18:56:50 +04:00
$bmpData .= pack ( " c* " , $colors [ 'blue' ], $colors [ 'green' ], $colors [ 'red' ]);
2012-11-12 16:56:29 +04:00
}
}
2013-08-06 18:56:50 +04:00
$bmpData .= $extra ;
2012-11-12 16:56:29 +04:00
}
2013-08-06 18:56:50 +04:00
$sizeQuad = 0 ;
$sizeData = strlen ( $bmpData );
$colorsNum = 0 ;
}
$fileHeader = 'BM' . pack ( 'V3' , 54 + $sizeQuad + $sizeData , 0 , 54 + $sizeQuad );
$infoHeader = pack ( 'V3v2V*' , 0x28 , $width , $height , 1 , $bit , $compression , $sizeData , 0 , 0 , $colorsNum , 0 );
if ( $fileName != '' ) {
$fp = fopen ( $fileName , 'wb' );
fwrite ( $fp , $fileHeader . $infoHeader . $rgbQuad . $bmpData );
2012-11-12 16:56:29 +04:00
fclose ( $fp );
return true ;
}
2013-08-06 18:56:50 +04:00
echo $fileHeader . $infoHeader . $rgbQuad . $bmpData ;
2012-11-12 16:56:29 +04:00
return true ;
}
}
if ( ! function_exists ( 'exif_imagetype' ) ) {
/**
* Workaround if exif_imagetype does not exist
* @ link http :// www . php . net / manual / en / function . exif - imagetype . php #80383
2014-02-06 19:30:58 +04:00
* @ param string $fileName
2012-11-12 16:56:29 +04:00
* @ return string | boolean
*/
2013-08-06 18:56:50 +04:00
function exif_imagetype ( $fileName ) {
if ( ( $info = getimagesize ( $fileName ) ) !== false ) {
2012-11-12 16:56:29 +04:00
return $info [ 2 ];
}
return false ;
}
}