├── .gitignore
├── README
├── tests
    ├── README
    └── DdImageBasicTest.php
├── LICENSE
└── lib
    └── dd_image_ImageResizer.php


/.gitignore:
--------------------------------------------------------------------------------
1 | .buildpath
2 | .project
3 | .settings
4 | ._*
5 | build
6 | dist
7 | repos
8 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
1 | Dragonfly Development PHP Image Library
2 | http://dflydev.com/d2code/php/dd-image-php/
3 | 
4 | 
5 | dd-image is useful for doing simple image manipulation operations.
6 | 


--------------------------------------------------------------------------------
/tests/README:
--------------------------------------------------------------------------------
 1 | Testing with PHPUnit (http://www.phpunit.de/)
 2 | 
 3 | To run an individual test:
 4 | 
 5 |     phpunit SpecificTest.php
 6 | 
 7 | To run all tests it is best to execute the Phing build script
 8 | which has the appropriate filters setup to ensure that only
 9 | the tests that need to be run will be run.
10 | 
11 |     phing test
12 | 


--------------------------------------------------------------------------------
/tests/DdImageBasicTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once('PHPUnit/Framework.php');
 4 | 
 5 | define('PACKAGE_LIB', dirname(dirname(__FILE__)) . '/lib/');
 6 | $includePath = explode(PATH_SEPARATOR, get_include_path());
 7 | array_unshift($includePath, PACKAGE_LIB);
 8 | set_include_path(implode(PATH_SEPARATOR, $includePath));
 9 | 
10 | class DdCoreBasicTest extends PHPUnit_Framework_TestCase {
11 | 
12 |     /**
13 |      * Simple test to see if test starts up.
14 |      */
15 |     public function testStartup() {
16 |     }
17 | 
18 | }
19 | ?>
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2010, Dragonfly Development Inc 
 2 | All rights reserved. 
 3 | 
 4 | Redistribution and use in source and binary forms, with or without 
 5 | modification, are permitted provided that the following conditions are met: 
 6 | 
 7 |  * Redistributions of source code must retain the above copyright notice, 
 8 |    this list of conditions and the following disclaimer. 
 9 |  * Redistributions in binary form must reproduce the above copyright 
10 |    notice, this list of conditions and the following disclaimer in the 
11 |    documentation and/or other materials provided with the distribution. 
12 |  * Neither the name of Dragonfly Development Inc nor the names of its 
13 |    contributors may be used to endorse or promote products derived from 
14 |    this software without specific prior written permission. 
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
17 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
18 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
19 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
20 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
21 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
22 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
23 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
24 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
25 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
26 | POSSIBILITY OF SUCH DAMAGE.
27 | 


--------------------------------------------------------------------------------
/lib/dd_image_ImageResizer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class dd_image_ImageResizer {
  4 | 
  5 |     /**
  6 |     * Get an image resource from a file.
  7 |     * @param string $fileName File name on disk.
  8 |     * @param array $imageInfo getimagesize image information.
  9 |     * @return resource
 10 |     */
 11 |     static public function resourceFrom($fileName, $imageInfo = null)
 12 |     {
 13 | 
 14 |         $image = null;
 15 | 
 16 |         if ( $imageInfo === null )
 17 |             $imageInfo = getimagesize($fileName);
 18 | 
 19 |         switch($imageInfo['mime'])
 20 |         {
 21 | 
 22 |             case 'image/gif':
 23 |                 if ( imagetypes() & IMG_GIF)
 24 |                 {
 25 |                     $image = imagecreatefromgif($fileName);
 26 |                 }
 27 |                 break;
 28 | 
 29 |             case 'image/jpeg':
 30 |                 if ( imagetypes() & IMG_JPG)
 31 |                 {
 32 |                     $image = imagecreatefromjpeg($fileName);
 33 |                 }
 34 |                 break;
 35 | 
 36 |             case 'image/png':
 37 |                 if ( imagetypes() & IMG_PNG)
 38 |                 {
 39 |                     $image = imagecreatefrompng($fileName);
 40 |                 }
 41 |                 break;
 42 | 
 43 |         }
 44 | 
 45 |         return $image;
 46 | 
 47 |     }
 48 | 
 49 |     static private function outputPrep($input, $targetType = null, $targetFileName = null, $targetWidth = null, $targetHeight = null)
 50 |     {
 51 | 
 52 |         // Default to JPEG.
 53 |         if ( $targetType === null )
 54 |             $targetType = IMG_JPG;
 55 | 
 56 |         // If no target filename is specified, create one.
 57 |         if ( $targetFileName === null )
 58 |             $targetFileName = tempnam( '/tmp', 'dd_image_ImageResizer-' );
 59 | 
 60 |         // Assume we have been given a filename.
 61 |         $sourceImageInfo = getimagesize($input);
 62 |         $source = self::resourceFrom($input, $sourceImageInfo);
 63 | 
 64 |         list($sourceWidth, $sourceHeight, $sourceType) = $sourceImageInfo;
 65 | 
 66 |         // If no target width or height is specified, use the source
 67 |         // image width and height.
 68 |         if ( ! isset($targetWidth) ) $targetWidth = $sourceWidth;
 69 |         if ( ! isset($targetHeight) ) $targetHeight = $sourceHeight;
 70 | 
 71 |         $target = imagecreatetruecolor($targetWidth, $targetHeight);
 72 | 
 73 |         return array($target, $targetType, $targetFileName, $targetWidth, $targetHeight, $source, $sourceWidth, $sourceHeight, $sourceType);
 74 | 
 75 |     }
 76 | 
 77 |     /**
 78 |     * Copy an image.
 79 |     * @param mixed $input File name
 80 |     * @param int $targetType Image type.
 81 |     * @param string $targetFileName Target file name.
 82 |     * @param int $targetWidth Target width.
 83 |     * @param int $targetHeight Target height.
 84 |     * @return HC_Image_File
 85 |     */
 86 |     static public function copy($input, $targetType = null, $targetFileName = null, $targetWidth = null, $targetHeight = null, $quality = null)
 87 |     {
 88 | 
 89 |         $oldTargetFileName = $targetFileName;
 90 | 
 91 |         list(
 92 |             $target, $targetType, $targetFileName, $targetWidth, $targetHeight,
 93 |             $source, $sourceWidth, $sourceHeight, $sourceType
 94 |         ) = self::outputPrep($input, $targetType, $targetFileName, $targetWidth, $targetHeight);
 95 | 
 96 |         self::copyResource(
 97 |             $source, $sourceWidth, $sourceHeight,
 98 |             $target, $targetWidth, $targetHeight
 99 |         );
100 | 
101 |         if ( $targetFileName !== null )
102 |         {
103 |             // If a target file name was specified, we should store out to that filename.
104 |             self::storeTo($target, $targetType, $targetFileName, $quality);
105 |         }
106 | 
107 |     }
108 | 
109 |     /**
110 |     * Copy a source resource into a target resource.
111 |     * @param resource $source Source resource.
112 |     * @param int $sourceWidth Source width.
113 |     * @param int $sourceHeight Source height.
114 |     * @param resource $target Source resource.
115 |     * @param int $targetWidth Source width.
116 |     * @param int $targetHeight Source height.
117 |     */
118 |     static public function copyResource($source, $sourceWidth, $sourceHeight, $target, $targetWidth, $targetHeight)
119 |     {
120 | 
121 |         if ( $sourceHeight != $targetHeight )
122 |         {
123 | 
124 |             // We resample if there is any change at all in height.
125 | 
126 |             imagecopyresampled(
127 |                 $target,
128 |                 $source,
129 |                 0,
130 |                 0,
131 |                 0,
132 |                 0,
133 |                 $targetWidth,
134 |                 $targetHeight,
135 |                 $sourceWidth,
136 |                 $sourceHeight
137 |             );
138 | 
139 |         }
140 |         else
141 |         {
142 | 
143 |             // If there is no change in size, we can just do an image
144 |             // copy.
145 |             imagecopy(
146 |                 $target,
147 |                 $source,
148 |                 0,
149 |                 0,
150 |                 0,
151 |                 0,
152 |                 $targetWidth,
153 |                 $targetHeight
154 |             );
155 | 
156 |         }
157 | 
158 |     }
159 | 
160 |     /**
161 |     * Store an image out to a file on disk.
162 |     * @param resource $target Target image.
163 |     * @param int $targetType Type of image.
164 |     * @param string $targetFileName Target file name on disk.
165 |     */
166 |     static public function storeTo($target, $targetType, $targetFileName, $quality = null)
167 |     {
168 | 
169 |         $args = array($target, $targetFileName);
170 |         if ( $quality !== null ) $args[] = $quality;
171 | 
172 |         switch($targetType)
173 |         {
174 | 
175 |             case IMG_GIF:
176 |                 imagegif($target, $targetFileName);
177 |                 break;
178 | 
179 |             case IMG_JPG:
180 |                 call_user_func_array('imagejpeg', $args);
181 |                 break;
182 | 
183 |             case IMG_PNG:
184 |                 imagepng($target, $targetFileName);
185 |                 break;
186 | 
187 |             default:
188 |                 //error_log('Unknown target type!');
189 |                 break;
190 | 
191 |         }
192 | 
193 |     }
194 | 
195 |     static public function scaleTo($input, $type, $targetFileName, $maxWidth = null, $maxHeight = null, $quality = null, $shrinkOnly = null) {
196 |         $target = self::copyScaled($input, $maxWidth, $maxHeight, $shrinkOnly);
197 |         self::storeTo($target, $type, $targetFileName, $quality);
198 |     }
199 |     static public function copyScaled($input, $maxWidth = null, $maxHeight = null, $shrinkOnly = null)
200 |     {
201 | 
202 |         $sourceImageInfo = getimagesize($input);
203 | 
204 |         if ( $shrinkOnly === null ) $shrinkOnly = true;
205 | 
206 |         if ( $maxWidth === null ) $maxWidth = $sourceImageInfo['0'];
207 |         if ( $maxHeight === null ) $maxHeight = $sourceImageInfo['1'];
208 | 
209 |         list($targetWidth, $targetHeight) = self::fitToBox(
210 |             $sourceImageInfo['0'], $sourceImageInfo['1'],
211 |             $maxWidth, $maxHeight,
212 |             $shrinkOnly
213 |         );
214 | 
215 |         $target = imagecreatetruecolor($targetWidth, $targetHeight);
216 |         imagealphablending($target, false);
217 |         imagesavealpha($target, true);
218 |         
219 |         self::copyResource(
220 |             self::resourceFrom($input, $sourceImageInfo), $sourceImageInfo['0'], $sourceImageInfo['1'],
221 |             $target, $targetWidth, $targetHeight
222 |         );
223 | 
224 |         return $target;
225 | 
226 |     }
227 | 
228 |     static public function cropTo($input, $type, $targetFileName, $maxWidth = null, $maxHeight = null, $quality = null, $shrinkOnly = null) {
229 |         $target = self::copyCropped($input, $maxWidth, $maxHeight, $shrinkOnly);
230 |         self::storeTo($target, $type, $targetFileName, $quality);
231 |     }
232 | 
233 |     public function copyCropped($input, $maxWidth = null, $maxHeight = null, $shrinkOnly = null)
234 |     {
235 | 
236 |         $sourceImageInfo = getimagesize($input);
237 | 
238 |         if ( $shrinkOnly === null ) $shrinkOnly = true;
239 | 
240 |         if ( $maxWidth === null ) $maxWidth = $sourceImageInfo['0'];
241 |         if ( $maxHeight === null ) $maxHeight = $sourceImageInfo['1'];
242 | 
243 |         list($targetWidth, $targetHeight, $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH) = self::cropToBox(
244 |             $sourceImageInfo['0'], $sourceImageInfo['1'],
245 |             $maxWidth, $maxHeight,
246 |             $shrinkOnly
247 |         );
248 | 
249 |         $target = imagecreatetruecolor($targetWidth, $targetHeight);
250 |         imagealphablending($target, false);
251 |         imagesavealpha($target, true);
252 |         
253 |         imagecopyresampled(
254 |             $target,
255 |             self::resourceFrom($input, $sourceImageInfo),
256 |             $dstX,
257 |             $dstY,
258 |             $srcX,
259 |             $srcY,
260 |             $dstW,
261 |             $dstH,
262 |             $srcW,
263 |             $srcH
264 |         );
265 | 
266 |         return $target;
267 | 
268 |     }
269 | 
270 |     /**
271 |     * Fit a box inside another box.
272 |     * @param int $origWidth Width of source.
273 |     * @param int $origHeight Height of source.
274 |     * @param int $maxWidth Largest allowed width of image.
275 |     * @param int $maxHeight Largest allowed height of image.
276 |     * @param bool $shrinkOnly We should only shrink, never enlarge.
277 |     * @return array Width and height of image.
278 |     */
279 |     static public function fitToBox( $origWidth, $origHeight, $maxWidth, $maxHeight, $shrinkOnly = null )
280 |     {
281 | 
282 |         if ( $shrinkOnly === null ) $shrinkOnly = true;
283 | 
284 |         /**
285 |         * This math was borrowed from a couple of random PHP tutorials.
286 |         **/
287 | 
288 |         $widthRatio = $maxWidth / $origWidth;
289 |         $heightRatio = $maxHeight / $origHeight;
290 | 
291 |         if ( ( $origWidth <= $maxWidth ) and ( $origHeight <= $maxHeight ) )
292 |         {
293 |             if ( $shrinkOnly )
294 |             {
295 |                 //error_log('Shrinking only...');
296 |                 $targetWidth = $origWidth;
297 |                 $targetHeight = $origHeight;
298 |             }
299 |             else
300 |             {
301 |                 //error_log('Enlarging...');
302 |                 $multiplier = $maxWidth + $maxHeight;
303 |                 list($targetWidth, $targetHeight) = self::fitToBox(
304 |                     $origWidth * $multiplier, $origHeight * $multiplier ,
305 |                     $maxWidth, $maxHeight,
306 |                     false
307 |                 );
308 |             }
309 |         }
310 |         elseif ( ( $widthRatio * $origHeight ) < $maxHeight )
311 |         {
312 |             $targetWidth = $maxWidth;
313 |             $targetHeight = ceil($widthRatio * $origHeight);
314 |         }
315 |         else
316 |         {
317 |             $targetWidth = ceil($heightRatio * $origWidth);
318 |             $targetHeight = $maxHeight;
319 |         }
320 | 
321 |         return array($targetWidth, $targetHeight);
322 | 
323 |     }
324 | 
325 |     /**
326 |     * Crop a box inside another box.
327 |     * @param int $origWidth Width of source.
328 |     * @param int $origHeight Height of source.
329 |     * @param int $maxWidth Largest allowed width of image.
330 |     * @param int $maxHeight Largest allowed height of image.
331 |     * @param bool $shrinkOnly We should only shrink, never enlarge.
332 |     * @return array Width and height of image.
333 |     */
334 |     static public function cropToBox( $origWidth, $origHeight, $maxWidth, $maxHeight, $shrinkOnly = null )
335 |     {
336 | 
337 |         if ( $shrinkOnly === null ) $shrinkOnly = true;
338 | 
339 |         $widthRatio = $maxWidth / $origWidth;
340 |         $heightRatio = $maxHeight / $origHeight;
341 | 
342 |         //echo " [ origWidth ( $origWidth <= $maxWidth ) and ( $origHeight <= $maxHeight ) ]\n";
343 |         if ( ( $origWidth <= $maxWidth ) and ( $origHeight <= $maxHeight ) )
344 |         {
345 |             if ( $shrinkOnly )
346 |             {
347 |                 //echo " [ we are only going to shrink! ]\n";
348 |                 $targetWidth = $origWidth;
349 |                 $targetHeight = $origHeight;
350 |                 $dstX = 0;
351 |                 $dstY = 0;
352 |                 $srcX = 0;
353 |                 $srcY = 0;
354 |                 $dstW = $origWidth;
355 |                 $dstH = $origHeight;
356 |                 $srcW = $origWidth;
357 |                 $srcH = $origHeight;
358 |             }
359 |             else
360 |             {
361 |                 error_log('Enlarging...');
362 |                 error_log('Not sure how we will do this yet!');
363 |                 exit();
364 |             }
365 |         }
366 |         else
367 |         {
368 | 
369 |             $targetHeight = $origHeight;
370 |             $targetWidth = $origWidth;
371 |             $dstX = 0;
372 |             $dstY = 0;
373 |             $srcX = 0;
374 |             $srcY = 0;
375 |             $dstW = $origWidth;
376 |             $dstH = $origHeight;
377 |             $srcW = $origWidth;
378 |             $srcH = $origHeight;
379 | 
380 |             $overallRatio = ( $heightRatio > $widthRatio ) ? $heightRatio : $widthRatio;
381 | 
382 |             $dstW = $origWidth * $overallRatio;
383 |             $dstH = $origHeight * $overallRatio;
384 | 
385 |             //echo " [ ( ($dstW > $origWidth) or ($dstH > $origHeight) ) ]\n";
386 |             if ( ($dstW > $origWidth) or ($dstH > $origHeight) ) {
387 |                 if ( $shrinkOnly ) {
388 |                     $dstW = $origWidth;
389 |                     $dstH = $origHeight;
390 |                 }
391 |             }
392 | 
393 |             $targetWidth = $dstW > $maxWidth ? $maxWidth : $dstW;
394 |             $targetHeight = $dstH > $maxHeight ? $maxHeight : $dstH;
395 | 
396 |             if ( $targetWidth < $dstW )
397 |             {
398 |                 $dstX = ( ($dstW - $targetWidth) / 2 ) * -1;
399 |             }
400 | 
401 |             if ( $targetHeight < $dstH )
402 |             {
403 |                 $dstY = ( ($dstH - $targetHeight) / 2 ) * -1;
404 |             }
405 | 
406 |         }
407 | 
408 |         return array($targetWidth, $targetHeight, $dstX, $dstY, $srcX, $srcY, $dstW, $dstH, $srcW, $srcH);
409 | 
410 |     }
411 | 
412 | }
413 | 
414 | ?>
415 | 


--------------------------------------------------------------------------------