image.inc 11.6 KB
Newer Older
1 2 3
<?php
// $Id$

4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/**
 * @file
 * API for manipulating images.
 */

/**
 * @defgroup image Image toolkits
 * @{
 * Drupal's image toolkits provide an abstraction layer for common image file
 * manipulations like scaling, cropping, and rotating. The abstraction frees
 * module authors from the need to support multiple image libraries, and it
 * allows site administrators to choose the library that's best for them.
 *
 * PHP includes the GD library by default so a GD toolkit is installed with
 * Drupal. Other toolkits like ImageMagic are available from contrib modules.
 * GD works well for small images, but using it with larger files may cause PHP
 * to run out of memory. In contrast the ImageMagick library does not suffer
 * from this problem, but it requires the ISP to have installed additional
 * software.
 *
24 25
 * Image toolkits are discovered based on the associated module's
 * hook_image_toolkits. Additionally the image toolkit include file
26
 * must be identified in the files array in the module.info file. The
27
 * toolkit must then be enabled using the admin/config/media/image-toolkit
28
 * form.
29
 *
30
 * Only one toolkit may be selected at a time. If a module author wishes to call
31 32 33 34
 * a specific toolkit they can check that it is installed by calling
 * image_get_available_toolkits(), and then calling its functions directly.
 */

35 36 37
/**
 * Return a list of available toolkits.
 *
38
 * @return
39
 *   An array with the toolkit names as keys and the descriptions as values.
40 41
 */
function image_get_available_toolkits() {
42 43
  // hook_image_toolkits returns an array of toolkit names.
  $toolkits = module_invoke_all('image_toolkits');
44 45

  $output = array();
46 47 48 49
  foreach ($toolkits as $name => $info) {
    // Only allow modules that aren't marked as unavailable.
    if ($info['available']) {
      $output[$name] = $info['title'];
50 51
    }
  }
52

53 54 55 56 57 58
  return $output;
}

/**
 * Retrieve the name of the currently used toolkit.
 *
59 60
 * @return
 *   String containing the name of the selected toolkit, or FALSE on error.
61 62 63
 */
function image_get_toolkit() {
  static $toolkit;
64

65 66
  if (!isset($toolkit)) {
    $toolkits = image_get_available_toolkits();
67
    $toolkit = variable_get('image_toolkit', 'gd');
68
    if (!isset($toolkits[$toolkit]) || !function_exists('image_' . $toolkit . '_load')) {
69 70
      // The selected toolkit isn't available so return the first one found. If
      // none are available this will return FALSE.
71 72
      reset($toolkits);
      $toolkit = key($toolkits);
73 74 75 76 77 78 79 80 81
    }
  }

  return $toolkit;
}

/**
 * Invokes the given method using the currently selected toolkit.
 *
82 83
 * @param $method
 *   A string containing the method to invoke.
84 85
 * @param $image
 *   An image object returned by image_load().
86 87 88
 * @param $params
 *   An optional array of parameters to pass to the toolkit method.
 * @return
89
 *   Mixed values (typically Boolean indicating successful operation).
90
 */
91 92
function image_toolkit_invoke($method, stdClass $image, array $params = array()) {
  $function = 'image_' . $image->toolkit . '_' . $method;
93
  if (function_exists($function)) {
94 95
    array_unshift($params, $image);
    return call_user_func_array($function, $params);
96
  }
97 98
  watchdog('image', 'The selected image handling toolkit %toolkit can not correctly process %function.', array('%toolkit' => $image->toolkit, '%function' => $function), WATCHDOG_ERROR);
  return FALSE;
99 100 101 102 103
}

/**
 * Get details about an image.
 *
104 105
 * Drupal only supports GIF, JPG and PNG file formats.
 *
106 107
 * @param $filepath
 *   String specifying the path of the image file.
108 109 110
 * @return
 *   FALSE, if the file could not be found or is not an image. Otherwise, a
 *   keyed array containing information about the image:
111 112
 *    'width'     - Width, in pixels.
 *    'height'    - Height, in pixels.
113 114 115
 *    'extension' - Commonly used file extension for the image.
 *    'mime_type' - MIME type ('image/jpeg', 'image/gif', 'image/png').
 *    'file_size' - File size in bytes.
116
 */
117 118
function image_get_info($filepath) {
  if (!is_file($filepath)) {
119
    return FALSE;
120 121
  }

122
  $details = FALSE;
123 124
  $data = @getimagesize($filepath);
  $file_size = @filesize($filepath);
125

126
  if (isset($data) && is_array($data)) {
127 128 129
    $extensions = array('1' => 'gif', '2' => 'jpg', '3' => 'png');
    $extension = array_key_exists($data[2], $extensions) ?  $extensions[$data[2]] : '';
    $details = array('width'     => $data[0],
130 131
                     'height'    => $data[1],
                     'extension' => $extension,
132
                     'file_size' => $file_size,
133
                     'mime_type' => $data['mime']);
134 135 136 137 138
  }

  return $details;
}

139
/**
140 141 142 143 144
 * Scales an image to the exact width and height given.
 *
 * This function achieves the target aspect ratio by cropping the original image
 * equally on both sides, or equally on the top and bottom. This function is
 * useful to create uniform sized avatars from larger images.
145 146 147
 *
 * The resulting image always has the exact target dimensions.
 *
148 149
 * @param $image
 *   An image object returned by image_load().
150 151 152 153 154 155
 * @param $width
 *   The target width, in pixels.
 * @param $height
 *   The target height, in pixels.
 * @return
 *   TRUE or FALSE, based on success.
156 157 158 159
 *
 * @see image_load()
 * @see image_resize()
 * @see image_crop()
160
 */
161 162 163 164
function image_scale_and_crop(stdClass $image, $width, $height) {
  $scale = max($width / $image->info['width'], $height / $image->info['height']);
  $x = ($image->info['width'] * $scale - $width) / 2;
  $y = ($image->info['height'] * $scale - $height) / 2;
165

166 167
  if (image_resize($image, $image->info['width'] * $scale, $image->info['height'] * $scale)) {
    return image_crop($image, $x, $y, $width, $height);
168 169 170 171
  }
  return FALSE;
}

172
/**
173
 * Scales an image to the given width and height while maintaining aspect ratio.
174
 *
175 176
 * The resulting image can be smaller for one or both target dimensions.
 *
177 178
 * @param $image
 *   An image object returned by image_load().
179
 * @param $width
180 181
 *   The target width, in pixels. This value is omitted then the scaling will
 *   based only on the height value.
182
 * @param $height
183 184 185 186 187
 *   The target height, in pixels. This value is omitted then the scaling will
 *   based only on the width value.
 * @param $upscale
 *   Boolean indicating that files smaller than the dimensions will be scalled
 *   up. This generally results in a low quality image.
188 189
 * @return
 *   TRUE or FALSE, based on success.
190 191 192
 *
 * @see image_load()
 * @see image_scale_and_crop()
193
 */
194 195
function image_scale(stdClass $image, $width = NULL, $height = NULL, $upscale = FALSE) {
  $aspect = $image->info['height'] / $image->info['width'];
196

197 198 199 200 201 202 203 204 205 206 207 208 209 210
  if ($upscale) {
    // Set width/height according to aspect ratio if either is empty.
    $width = !empty($width) ? $width : $height / $aspect;
    $height = !empty($height) ? $height : $width / $aspect;
  }
  else {
    // Set impossibly large values if the width and height aren't set.
    $width = !empty($width) ? $width : 9999999;
    $height = !empty($height) ? $height : 9999999;

    // Don't scale up.
    if (round($width) >= $image->info['width'] && round($height) >= $image->info['height']) {
      return TRUE;
    }
211 212 213
  }

  if ($aspect < $height / $width) {
214
    $height = $width * $aspect;
215 216
  }
  else {
217
    $width = $height / $aspect;
218 219
  }

220
  return image_resize($image, $width, $height);
221 222 223 224 225
}

/**
 * Resize an image to the given dimensions (ignoring aspect ratio).
 *
226 227
 * @param $image
 *   An image object returned by image_load().
228 229 230 231 232 233
 * @param $width
 *   The target width, in pixels.
 * @param $height
 *   The target height, in pixels.
 * @return
 *   TRUE or FALSE, based on success.
234 235
 *
 * @see image_load()
236
 * @see image_gd_resize()
237
 */
238 239 240 241 242
function image_resize(stdClass $image, $width, $height) {
  $width = (int) round($width);
  $height = (int) round($height);

  return image_toolkit_invoke('resize', $image, array($width, $height));
243 244
}

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
/**
 * Rotate an image by the given number of degrees.
 *
 * @param $image
 *   An image object returned by image_load().
 * @param $degrees
 *   The number of (clockwise) degrees to rotate the image.
 * @param $background
 *   An hexadecimal integer specifying the background color to use for the
 *   uncovered area of the image after the rotation. E.g. 0x000000 for black,
 *   0xff00ff for magenta, and 0xffffff for white. For images that support
 *   transparency, this will default to transparent. Otherwise it will
 *   be white.
 * @return
 *   TRUE or FALSE, based on success.
 *
 * @see image_load()
 * @see image_gd_rotate()
 */
function image_rotate(stdClass $image, $degrees, $background = NULL) {
  return image_toolkit_invoke('rotate', $image, array($degrees, $background));
}

268 269 270
/**
 * Crop an image to the rectangle specified by the given rectangle.
 *
271 272
 * @param $image
 *   An image object returned by image_load().
273
 * @param $x
274
 *   The top left coordinate, in pixels, of the crop area (x axis value).
275
 * @param $y
276
 *   The top left coordinate, in pixels, of the crop area (y axis value).
277 278 279 280 281 282
 * @param $width
 *   The target width, in pixels.
 * @param $height
 *   The target height, in pixels.
 * @return
 *   TRUE or FALSE, based on success.
283 284 285
 *
 * @see image_load()
 * @see image_scale_and_crop()
286
 * @see image_gd_crop()
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
 */
function image_crop(stdClass $image, $x, $y, $width, $height) {
  $aspect = $image->info['height'] / $image->info['width'];
  if (empty($height)) $height = $width / $aspect;
  if (empty($width)) $width = $height * $aspect;

  $width = (int) round($width);
  $height = (int) round($height);

  return image_toolkit_invoke('crop', $image, array($x, $y, $width, $height));
}

/**
 * Convert an image to grayscale.
 *
 * @param $image
 *   An image object returned by image_load().
 * @return
 *   TRUE or FALSE, based on success.
 *
 * @see image_load()
308
 * @see image_gd_desaturate()
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
 */
function image_desaturate(stdClass $image) {
  return image_toolkit_invoke('desaturate', $image);
}


/**
 * Load an image file and return an image object.
 *
 * Any changes to the file are not saved until image_save() is called.
 *
 * @param $file
 *   Path to an image file.
 * @param $toolkit
 *   An optional, image toolkit name to override the default.
 * @return
 *   An image object or FALSE if there was a problem loading the file. The
 *   image object has the following properties:
 *    - 'source' - The original file path.
 *    - 'info' - The array of information returned by image_get_info()
 *    - 'toolkit' - The name of the image toolkit requested when the image was
 *      loaded.
 *   Image tookits may add additional properties. The caller is advised not to
 *   monkey about with them.
 *
 * @see image_save()
 * @see image_get_info()
 * @see image_get_available_toolkits()
337
 * @see image_gd_load()
338
 */
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
function image_load($file, $toolkit = FALSE) {
  if (!$toolkit) {
    $toolkit = image_get_toolkit();
  }
  if ($toolkit) {
    $image = new stdClass();
    $image->source = $file;
    $image->info = image_get_info($file);
    $image->toolkit = $toolkit;
    if (image_toolkit_invoke('load', $image)) {
      return $image;
    }
  }
  return FALSE;
}

/**
 * Close the image and save the changes to a file.
 *
 * @param $image
 *   An image object returned by image_load(). The object's 'info' property
 *   will be updated if the file is saved successfully.
 * @param $destination
 *   Destination path where the image should be saved. If it is empty the
 *   original image file will be overwritten.
 * @return
 *   TRUE or FALSE, based on success.
 *
 * @see image_load()
368
 * @see image_gd_save()
369 370 371 372 373 374 375 376 377 378
 */
function image_save(stdClass $image, $destination = NULL) {
  if (empty($destination)) {
    $destination = $image->source;
  }
  if ($return = image_toolkit_invoke('save', $image, array($destination))) {
    // Clear the cached file size and refresh the image information.
    clearstatcache();
    $image->info = image_get_info($destination);

379
    if (drupal_chmod($destination)) {
380 381 382 383
      return $return;
    }
  }
  return FALSE;
384 385 386
}

/**
387
 * @} End of "defgroup image".
388
 */