resizing images

sneakyimp

ok...i'm trying to let users upload image for ads and i want to make sure they aren't too big, etc. got a couple of questions:

from getimagesize() docs

Returns an array with 4 elements. Index 0 contains the width of the image in pixels. Index 1 contains the height. Index 2 is a flag indicating the type of the image: 1 = GIF, 2 = JPG, 3 = PNG, 4 = SWF, 5 = PSD, 6 = BMP, 7 = TIFF(intel byte order), 8 = TIFF(motorola byte order), 9 = JPC, 10 = JP2, 11 = JPX, 12 = JB2, 13 = SWC, 14 = IFF, 15 = WBMP, 16 = XBM. These values correspond to the IMAGETYPE constants that were added in PHP 4.3.0. Index 3 is a text string with the correct height="yyy" width="xxx" string that can be used directly in an IMG tag.

what the heck are formats jpc, jp2, jpx, jb2, swc, etc.? is wbmp the same as bmp? Can I convert these using php functions?

Also, this is something of a math-type question. I need to make sure images don't exceed 600 pixels in width and 1200 pixels in height. When i resize, i want to shrink the image is little as possible. I'm guessing that if either width or height is too large, a resize will be required. Furthermore if either dimension exceeds its maximum value, then I will have to use the more extreme resizing factor required by the dimenions.

in short, is this PHP logic correct in that it will resize things enough, but as little as possible?

	  // create new image if the image is too large
      $bool_resize = false;	  

	  $scale_factors = array();
	  // check width
	  if ($imagewidth > MAX_IMAGE_WIDTH) {
	    // too wide, see what resize based on width is
		$bool_resize = true;
		$scale_factors[] = MAX_IMAGE_WIDTH/$imagewidth;
	  } else {
		$scale_factors[] = 1;
	  }

  // check height
  if ($imageheight > MAX_IMAGE_HEIGHT) {
    // too wide, see what resize based on width is
	$bool_resize = true;
	$scale_factors[] = MAX_IMAGE_HEIGHT/$imageheight;
  } else {
	$scale_factors[] = 1;
  }

  // sadly, we must take the minimum scaling factor as it represents
  // the necessary scaling factor to reduce the most extreme dimension
  $final_scaling_factor = min($scaling_factors);

Weedpacket

sneakyimp wrote:
what the heck are formats jpc, jp2, jpx, jb2, swc,

The only one I recognise straight off is JPEG2000. For the rest, I'd look at something like http://www.wotsit.org/ to see if it has a record.

etc.?[/quote]

is wbmp the same as bmp?

No, it's a WAP format.

Can I convert these using php functions?

Judging from the manual, not with GD Lib.

Your comment at the end is backwards - you need the MAXIMUM scaling (see the comment below for why).

if($width>MAX_WIDTH || $height>MAX_HEIGHT)
{
	// Resize needed
	$width_difference = MAX_WIDTH-$width;
	$height_difference = MAX_HEIGHT-$height;
	// It will be necessary to reduce the size so that the larger side is small
	// enough. If the difference between the current height and the maximum height
	// is larger than the difference between the current width and the maximum width,
	// then the scaling will have to be done so that new height is equal to the maximum
	// width (the new width will be less than the maximum width; if it were equal to
	// the maximum width, the height would still be too large). Otherwise, the
	// width should be reduced to MAX_WIDTH and the height to something less than MAX_HEIGHT.
	$scaling_factor = ($height_difference > $width_difference)
		? MAX_HEIGHT/$height
		: MAX_WIDTH/$width;

$new_height = intval($height*$scaling_factor);
$new_width = intval($width*$scaling_factor);

// Rescale to new dimensions.
}

sneakyimp

thanks for the tips on images. i will be depending on gd lib. what the heck is WAP format? am i correct in thinking that imagecreatefromwbmp doesn't work on windows bitmaps? am i also correct in thinking that gd lib can't help me with TIFs or windows bitmaps?

as for the resizing reasoning, i'm a bit confused by your code. consider an image that is 600w x 1800h. my maxes are:

define('MAX_WIDTH', 600);
define('MAX_HEIGHT', 1200);

so in your example:

$width_difference = MAX_WIDTH-$width; // returns 0
$height_difference = MAX_HEIGHT-$height; // returns -600
$scaling_factor = ($height_difference > $width_difference) // false
        ? MAX_HEIGHT/$height // no
        : MAX_WIDTH/$width; // yes, returns 1 -- no good

it occurred to me that you might have just switched the subtract sequence but i still think it doesn't work. consider an image 1199w x 1800 h

$width_difference = $width - MAX_WIDTH; // returns 599
$height_difference = $height - MAX_HEIGHT; // returns 600
$scaling_factor = ($height_difference > $width_difference) // true
        ? MAX_HEIGHT/$height // yes, returns 0.6667
        : MAX_WIDTH/$width; // no

$new_height = intval($height*$scaling_factor); // returns 1200 which is great!
$new_width = intval($width*$scaling_factor); // returns 799 which is *too wide*

my original thinking with the logic was basically that if either width or height requires scaling down, it is the lower scaling factor because one is 100% and the other must be scaled.

when both need rescaling, it is the more extreme rescaling we should use because otherwise that dimension will not be sufficiently scaled down. i can't prove it mathematically though and i'm not sure my logic accomplishes that. it's bugging me.

Weedpacket

sneakyimp wrote:
what the heck is WAP format?

http://www.google.com/search?q=WAP

am i correct in thinking that imagecreatefromwbmp doesn't work on windows bitmaps?

That depends. Are they different formats?

am i also correct in thinking that gd lib can't help me with TIFs or windows bitmaps?

If it did, there'd be documentation to say so and functions to do it. Are there?

i can't prove it mathematically though

That's because mathematics doesn't know what you want unless you tell it. You could try this: replace $imagewidth by MAX_IMAGE_WIDTH+$x and $imageheight=MAX_IMAGE_HEIGHT+$y and then simplify everything on the assumptions that (1) both $x and $y are >0, (2) one is >0 and the other is <=0, and (3) both are <=0 (that's actually four cases to consider. And obviously, if the image is too wide or too tall and you scale it "as little as possible", one of the dimensions will be the appropriate maximum, and the other won't be larger than its maximum value - by definition: it can't have that property and not be scaled "as little as possible").