File Source for netpbmresize.class.php

<?php
/**
* NetpbmResize is a php class that works as a wrapper for the netpbm binaries
* which are easily obtainable thanks to the Gallery project
* (http://tinyurl.com/25daoc). It is *only* focused on resizing images
* (by Width, Height, Percentage or Bounding Box) and create square thumbnails.
* It supports JPG, GIF and PNG.
*
* Its intended audience are php developers who are using images in their
* applications and need a resizing solution. Most common use would be an
* application which needs gallery functionality.
*
* @author Favio Manriquez <favio@favrik.com>
* @access public
* @see ImageInfo
*/
class NetpbmResize {
/**
* Stores the filename of the resized image
*
* @var string resized image filename
* @access private
*/
var $OutputImage;
/**
* Working Directory. Most commonly: where you are storing or uploading
* your images.
*
* @var string path of working directory
* @access private
*/
var $WorkingDir;
/**
* Stores the command line parameteres of the different netpbm programs.
*
* @var string
* @access private
*/
var $Params;
/**
* An instance of the class ImageInfo that contains necessary information
* from the current initialized image. You can initialize an image by
* calling the method setImageInfo.
*
* @var object instance of ImageInfo class
* @access private
* @see setImageInfo()
* @see ImageInfo
*/
var $ImageInfo;
/**
* These strings appear in the filenames of the netpbm programs. This fact
* is used for calling a program dynamically since the only part of the
* name that changes is the format to be resized.
*
* @var array part of the names of the netpbm programs
* @access private
*/
var $Programs = array(1 => 'gif', 'jpeg', 'png');
/**
* NetpbmResize doesn't delete the source image so you have to either
* define an output name (setOutputImage) or the resulting resized image
* name will contain this suffix. You can also change the suffix.
*
* @var string the default suffix of the resized image
* @access private
* @see setSuffix()
*/
var $DefaultSuffix;
/**
* Constructor.
*
* @param string $NetpbmPath path to netpbm binaries WITHOUT trailing slash
* @param string $Path path to working dir which may include the output filename
* WITHOUT trailing slash
* @access public
*/
function NetpbmResize($NetpbmPath, $Path) {
$this->setPathSeparator();
$this->setNetpbmPath($NetpbmPath);
$this->initialize($Path);
$this->DefaultSuffix = '.rs';
}
/**
* Should use "const" when leaving PHP4 for good.
*
* @param string $Netpbm path to netpbm binaries
* @return void
* @access private
*/
function setNetpbmPath($Netpbm) {
if (!defined('NETPBM_PATH') and is_dir($Netpbm)) {
define('NETPBM_PATH', $Netpbm . DIR_SLASH);
}
}
/**
* Tries to detect which trailing slash to use: unix like or windows like.
*
* @param void
* @return void
* @access private
*/
function setPathSeparator() {
$slash = (eregi("win",$_ENV['OS'])) ? '\\' : '/';
if (!defined('DIR_SLASH')) {
define('DIR_SLASH', $slash);
}
}
/**
* Set working directory and image info if applicable.
*
* @param string $path working directory or absolute path of an image
* @return void
* @access private
*/
function initialize($Path) {
if (is_dir($Path)) {
$this->setWorkingDir($Path . DIR_SLASH);
} else {
$this->setImageInfo($Path);
$this->setWorkingDir(dirname($Path) . DIR_SLASH);
}
}
/**
* Initializes the ImageInfo object useful for retrieving Image info.
*
* @param string $Image full path to an image file
* @return void
* @see ImageInfo
* @access public
*/
function setImageInfo($Image) {
$this->ImageInfo = new ImageInfo($Image);
if (!$this->ImageInfo->validImage()) {
$this->raiseError('Image format not supported! Only JPG, GIF or PNG are supported.');
}
}
function getWidth() {
return $this->ImageInfo->width();
}
function getHeight() {
return $this->ImageInfo->height();
}
/**
* Sets the default suffix of the the resized image.
*
* @param string $suffix suffix to be used for the resized image
* @return void
* @see $DefaultSuffix
* @access public
*/
function setSuffix($suffix) {
$this->DefaultSuffix = $suffix;
}
/**
* Sets the working directory.
*
* @param string $dir working directory
* @return void
* @access public
*/
function setWorkingDir($dir) {
$this->WorkingDir = $dir;
}
/**
* Gets the working directory.
*
* @param void
* @return string working directory
* @access public
*/
function getWorkingDir() {
return $this->WorkingDir;
}
/**
* Sets the filename of the resized image.
*
* @param string $filename output image filename
* @return void
* @access public
*/
function setOutputImage($filename) {
$this->OutputImage = $filename;
}
/**
* Gets the filename of the resized image.
*
* @param void
* @return string output image filename
* @access public
*/
function getOutputImage() {
return $this->OutputImage;
}
/**
* Checks if image is empty, if not sets the image info object
*
* @param string $image image name without path
* @return void
* @access public
*/
function setImage($image) {
if (!empty($image)) {
$this->setImageInfo($this->getWorkingDir() . $image);
}
}
/**
* Returns the nice name (without spaces, special chars, etc.)
* of the last image processed.
*
* @param void
* @return string image name
* @access public
*/
function getNiceName() {
return $this->ImageInfo->name();
}
/**
* Returns a command name with absolute path prepended.
*
* @param string $cmd program name
* @return string command with path and trailing space
* @access private
*/
function command($cmd) {
return NETPBM_PATH . $cmd .' ';
}
/**
* Uses pnmcut to produce square thumbnails (pnmcut left top width height).
* First slices the square centered region of the input image and then
* resizes that to the dimension specified.
*
* @param int $size dimension
* @param string $suffix_op optional suffix for resulting image
* @return void
* @access public
*/
function squareThumbnail($size, $suffix_op = '') {
$suffix = empty($suffix_op) ? $size : $suffix_op;
$this->setOutputImage($this->ImageInfo->customName($suffix));
$this->Params = '-width ' . $size . ' ';
$cmd = $this->getPreCommand() . $this->getThumbnailCommand() . $this->getPostCommand();
$this->setOutputImage(''); // reset Output image for next images to be processed
$this->execute($cmd);
}
/**
* Calculates the dimensions required to slice a square from the original
* image. This is used as the new source for the resizing program.
*
* @param void
* @return string command line to be executed
* @access private
*/
function getThumbnailCommand() {
$min = ($this->ImageInfo->width() > $this->ImageInfo->height()) ? 'height' : 'width';
$max = ($this->ImageInfo->width() > $this->ImageInfo->height()) ? 'width' : 'height';
$max_value = intval ( ($this->ImageInfo->{$max}() - $this->ImageInfo->{$min}()) / 2 );
if ($max == 'width') {
$top = 0;
$left = $max_value;
$width = $height = $this->ImageInfo->height();
} else {
$top = $max_value;
$left = 0;
$width = $height = $this->ImageInfo->width();
}
return $this->command('pnmcut') . $left .' '. $top .' '. $width . ' ' . $height . ' | ';
}
/**
* Cuts an image section to be taken as the base for a specific width and
* height resize.
*
* @param int $x target width of image
* @param int $y target height of image
* @return string command line to be executed
* @access private
*/
function getFixedCut($x, $y) {
$width_factor = intval($this->ImageInfo->width() / $x);
$height_factor = intval($this->ImageInfo->height() / $y);
$max = max($width_factor, $height_factor);
$difference = abs($width_factor - $height_factor);
if ($max == $width_factor) {
$width = $width_factor * $x - ($difference * $x);
$height = $height_factor * $y;
} else {
$width = $width_factor * $x;
$height = $height_factor * $y - ($difference * $y);
}
$left = intval(($this->ImageInfo->width() - $width) / 2);
$top = intval(($this->ImageInfo->height() - $height) / 2);
return $this->command('pnmcut') . $left .' '. $top .' '. $width . ' ' . $height . ' | ';
}
/**
* Generic resize method, it defaults to resize by Bounding Box. The first
* parameter can also be an array containing different dimensions and
* suffixes so you can have different resized versions of the original
* image.
*
* @param mixed $pixels pixels to be resized by
* @param string $image input image filename
* @return void
* @access public
* @see resizeByBoundingBox()
*/
function resize($pixels, $image = '') {
if (is_array($pixels)) {
$this->setImage($image);
foreach ($pixels as $size => $suffix) {
$this->setOutputImage($this->ImageInfo->customName($suffix));
$this->resizeByBoundingBox($size, $size);
}
} else {
$this->resizeByBoundingBox($pixels, $pixels, $image);
}
}
/**
* Resizes an image taking width as the base dimension.
*
* @param integer $pixels pixels to be resized by
* @param string $image input image filename
* @return void
* @access public
*/
function resizeByWidth($pixels, $image = '') {
$this->Params = '-width ' . $pixels . ' ';
$this->process($image);
}
/**
* Resizes an image taking height as the base dimension.
*
* @param integer $pixels pixels to be resized by
* @param string $image input image filename
* @return void
* @access public
*/
function resizeByHeight($pixels, $image = '') {
$this->Params = '-height ' . $pixels . ' ';
$this->process($image);
}
/**
* Resizes an image by a percentage.
*
* @param mixed $percentage float or int taken as a percentage
* @param string $image input image filename
* @return void
* @access public
*/
function resizeByPercentage($percentage, $image = '') {
$this->Params = $percentage . ' ';
$this->process($image);
}
/**
* This does a bounding box resize. It will try to fit the image into
* a box with the columns and rows specified.
*
* @param integer $cols number of columns of the bounding box
* @param integer $rows number of rows of the bounding box
* @param string $image input image filename without path info
* @return void
* @access public
*/
function resizeByBoundingBox($cols, $rows, $image = '') {
$this->Params = '-xysize ' . $cols . ' ' . $rows . ' ';
$this->process($image);
}
/**
* This does a specific resize. It resizes the image to the specified
* dimensions without altering the aspect ratio, but of course the
* algorithm used centers the new frame and some portions of the image are
* lost. Also, the original image should be larger than the target image.
*
* @param integer $width target width of image
* @param integer $height target height of image
* @param string $suffix image suffix to be used
* @param string $image input image filename without path info
* @return void
* @access public
*/
function resizeByDimensions($width, $height, $suffix = '', $image = '') {
$this->setImage($image);
$suffix = empty($suffix) ? $width : $suffix;
$this->setOutputImage($this->ImageInfo->customName($suffix));
$this->Params = '-width ' . $width . ' -height ' . $height . ' ';
$cmd = $this->getPreCommand() . $this->getFixedCut($width, $height) . $this->getPostCommand();
$this->setOutputImage(''); // reset Output image for next images to be processed
$this->execute($cmd);
}
/**
* If an image path was passed it will initialize it and resize using that
* instead. Compiles the command to be called for resizing.
*
* @param string $image image filename to be initialized
* @return void
* @access private
*/
function process($image = '') {
$this->setImage($image);
if (!is_a($this->ImageInfo, 'ImageInfo')) {
$this->raiseError('You have not setup an Image!');
}
$cmd = $this->getPreCommand() . $this->getPostCommand();
$this->execute($cmd);
}
/**
* Executes a command line to resize an image.
*
* @param string $cmd command line to be executed
* @return void
* @access private
*/
function execute($cmd) {
$output = array();
exec($cmd, $output, $return_var);
if ($return_var > 0) {
$this->raiseError('Error at netpbm execution, full command line: '.$cmd);
}
}
/**
* Compiles the first part of the command line to be executed.
*
* @param void
* @return string first part of the command line
* @access private
*/
function getPreCommand() {
return $this->command($this->Programs[$this->ImageInfo->type()] . 'topnm')
. $this->getWorkingDir() . $this->ImageInfo->name() . ' | ';
}
/**
* Compiles the last part of the command line to be executed. This is where
* format based logic occurs and the reason why $this->Programs exist.
*
* @param void
* @return string last part the command line
* @access private
* @see $Programs
*/
function getPostCommand() {
$Type = $this->Programs[$this->ImageInfo->type()];
$Command = $this->command('pnmscale') . $this->Params . ' | ';
if ($Type == 'gif') {
$Command .= $this->command('ppmquant') . '256 | '
. $this->command('ppmto' . $Type) . '> ';
} else {
$options = ($Type == 'jpeg') ? '--quality=95 ' : '';
$Command .= $this->command('pnmto' . $Type) . $options . '> ';
}
return $Command . $this->getDestination();
}
/**
* Calculates the resized image filaname since it can come from $OutputImage
* or just be the original filename with a suffix appended.
*
* @param void
* @return string final full path of the resized image
* @access public
*/
function getDestination() {
$file = $this->getOutputImage();
$OutputFile = empty($file)
? $this->ImageInfo->customName($this->DefaultSuffix) : $file;
$OutputFile .= '.' . $this->ImageInfo->extension();
return $this->getWorkingDir() . $OutputFile;
}
/**
* Triggers an USER error. This should/could be changed touse a custom
* error handler.
*
* @param string $message message to be displayed in case of user error
* @return void
* @access private
*/
function raiseError($message) {
trigger_error('NetpbmResize Error: '.$message, E_USER_ERROR);
}
}
/**
* Stores all the required/useful information of a given image in an array
* and provides accessor methods to that data.
*
* @author Favio Manriquez <favio@favrik.com>
* @access public
* @see NetpbmResize
*/
class ImageInfo {
/**
* Used to store and retrieve all the image info.
*
* @var array stores all the image info
* @access private
*/
var $ImageInfo = array();
/**
* Stores the supported image formats.
*
* @var array image formats
* @access private
*/
var $SupportedTypes = array(1 => 'gif', 'jpg', 'png');
/**
* Constructor. Uses getimagesize() output as initial data.
*
* @param string $image full path of an image
* @return void
* @access public
*/
function ImageInfo($Image) {
$size = getimagesize($Image);
$this->ImageInfo['width'] = $size[0];
$this->ImageInfo['height'] = $size[1];
$this->ImageInfo['type'] = $size[2];
$this->ImageInfo['mime'] = $size['mime'];
$this->ImageInfo['route'] = $Image;
$this->ImageInfo['original_name'] = basename($Image);
}
/**
* Checks if image is of a supported format.
*
* @param void
* @return void
* @access private
*/
function validImage() {
if (array_key_exists($this->ImageInfo['type'], $this->SupportedTypes)) {
$this->ImageInfo['ext'] = $this->SupportedTypes[$this->ImageInfo['type']];
$this->useNiceName();
return true;
}
return false;
}
/**
* Regular expressions taken from gallery.menalto.com. It produces nice
* filenames. =D
*
* @param void
* @return void
* @access private
*/
function useNiceName() {
$name = urldecode($this->ImageInfo['original_name']); // remove %20 and the like from name
$tag = $this->ImageInfo['ext'];
$tempFilename = eregi_replace(".$tag$", "", $name);// parse out original filename without extension
$tempFilename = eregi_replace(".jpeg$", "", $tempFilename);
$tempFilename = ereg_replace("[^[:alnum:]]", "_", $tempFilename);// replace multiple non-word characters with a single "_"
$tempFilename = ereg_replace("_+", "_", $tempFilename);// Get rid of extra underscores
$tempFilename = ereg_replace("(^_|_$)", "", $tempFilename);
if ($name != $tempFilename) {
$this->renameImage($tempFilename . '.' . $tag);
}
$this->ImageInfo['nice_name'] = $tempFilename;
$this->ImageInfo['temp_name'] = $tempFilename . '.tmp.' . $tag;
}
/**
* Renames an image by copying and deleting.
*
* @param string $NewNameinput image filename
* @return void
* @access private
*/
function renameImage($NewName) {
$Filename = dirname($this->ImageInfo['route']) . DIR_SLASH . $NewName;
if (!file_exists($Filename)) {
copy($this->ImageInfo['route'], $Filename);
unlink($this->ImageInfo['route']);
}
}
/**
* Returns the format of the image like GIF, JPG or PNG as an integer.
*
* @param void
* @return string image format
* @access public
*/
function type() {
return $this->ImageInfo['type'];
}
/**
* Returns the image extension.
*
* @param void
* @return string image extension
* @access public
*/
function extension() {
return $this->ImageInfo['ext'];
}
/**
* Returns the image width.
*
* @param void
* @return int image width
* @access public
*/
function width() {
return $this->ImageInfo['width'];
}
/**
* Returns the image height.
*
* @param void
* @return int image height
* @access public
*/
function height() {
return $this->ImageInfo['height'];
}
/**
* Returns the image name after being converted to a nice version.
*
* @param void
* @return string nice image filename
* @access public
*/
function name() {
return $this->ImageInfo['nice_name'] . '.' . $this->ImageInfo['ext'];
}
/**
* Returns the nice image filename with the custom suffix added.
*
* @param string $suffix suffix for image
* @return string nice image filename with custom suffix added
* @access public
*/
function customName($suffix) {
return $this->ImageInfo['nice_name'] . $suffix;
}
/**
* Returns the image temp name. Possibly not useful at this point. This
* could change in the future.
*
* @param void
* @return string image temp filename
* @access public
*/
function tempName() {
return $this->ImageInfo['temp_name'];
}
}
?>

Source for file netpbmresize.class.php