Redimensionnement proportionnel de l'image

Question

Je rencontre un petit problème en mesurant mes images à une taille correctement prédéfinie. Je me demandais - puisque c'est purement mathématique, s'il existe une sorte d'algorithme logique commun qui fonctionne dans toutes les langues (PHP, ActionScript, Javascript, etc.) pour redimensionner les images proportionnellement.

J'utilise ce au moment:

var maxHeight = 300; 
var maxWidth = 300; 

var ratio:Number = height/width; 

if (height > maxHeight) { 
    height = maxHeight; 
    width = Math.round(height/ratio); 
} 

else if(width > maxWidth) { 
    width = maxWidth; 
    height = Math.round(width * ratio); 
} 

Mais il ne fonctionne pas correctement. Les images sont proportionnelles, bien sûr, mais la taille n'est pas fixée à 300 (en largeur ou en hauteur). Cela a du sens, mais je me demandais s'il y avait un moyen infaillible et facile de faire évoluer les images proportionnellement.

Answer 1

ratio = MIN(maxWidth/width, maxHeight/ height); 
width = ratio * width; 
height = ratio * height; 

Assurez-vous que toutes les divisions sont en virgule flottante.

Answer 2

Je vous recommande de ne pas écrire ce code vous-même; il y a des myriades de détails au niveau des pixels qui prennent un sérieux temps pour aller droit. Utilisez ImageMagick, c'est la meilleure bibliothèque graphique sur le marché.

Answer 3

Dark Shikari l'a. Votre solution, comme indiqué dans la question, échoue parce que vous n'êtes pas d'abord établissant quel rapport taille-à-maximum de dimenson est plus grand et puis réduisant les deux dimensions par ce rapport plus grand.

L'utilisation par votre solution actuelle d'une analyse sérielle et conditionnelle d'une violation de dimension potentielle, puis de l'autre ne fonctionnera pas.

Notez également que si vous voulez images haut de gamme, votre solution actuelle ne volera pas, et Dark Shikari sera à nouveau.

Answer 4

Voici une fonction que j'ai développée pour mon site, vous pourriez vouloir l'utiliser. C'est basé sur votre réponse ci-dessus.

Il fait d'autres choses non seulement le traitement d'image - s'il vous plaît supprimer tout ce qui est inutile.

<?php 

$thumb_width = 500; 
$thumb_height = 500; 

if ($handle = opendir('to-do')) { 
    echo "Directory handle: $handle<br />"; 
    echo "Files:<br /><br />"; 

    /* This is the correct way to loop over the directory. */ 
    while (false !== ($file = readdir($handle))) { 

     if (($file != ".") && ($file != "..")){ 
      echo "$file"; 

      $original_path = "to-do/" . $file; 

      $source_image = ImageCreateFromJPEG($original_path); 
      $thumb_width = $thumb_width; 
      $thumb_height = $thumb_height; 

      // Create the image, of the required size 
      $thumbnail = imagecreatetruecolor($thumb_width, $thumb_height); 
      if($thumbnail === false) { 
       //creation failed -- probably not enough memory 
       return null; 
      } 

      // Fill the image with a white color (this will be visible in the padding around the image, 
      // if the aspect ratios of the image and the thumbnail do not match) 
      // Replace this with any color you want, or comment it out for black. 
      // I used grey for testing =) 
      $fill = imagecolorallocate($thumbnail, 255, 255, 255); 
      imagefill($thumbnail, 0, 0, $fill); 

      // Compute resize ratio 
      $hratio = $thumb_height/imagesy($source_image); 
      $wratio = $thumb_width/imagesx($source_image); 
      $ratio = min($hratio, $wratio); 

      // If the source is smaller than the thumbnail size, 
      // Don't resize -- add a margin instead 
      // (that is, dont magnify images) 
      if ($ratio > 1.0) 
       $ratio = 1.0; 

      // Compute sizes 
      $sy = floor(imagesy($source_image) * $ratio); 
      $sx = floor(imagesx($source_image) * $ratio); 

      // Compute margins 
      // Using these margins centers the image in the thumbnail. 
      // If you always want the image to the top left, set both of these to 0 
      $m_y = floor(($thumb_height - $sy)/2); 
      $m_x = floor(($thumb_width - $sx)/2); 

      // Copy the image data, and resample 
      // If you want a fast and ugly thumbnail, replace imagecopyresampled with imagecopyresized 
      if (!imagecopyresampled($thumbnail, $source_image, 
       $m_x, $m_y, //dest x, y (margins) 
       0, 0, //src x, y (0,0 means top left) 
       $sx, $sy,//dest w, h (resample to this size (computed above) 
       imagesx($source_image), imagesy($source_image)) //src w, h (the full size of the original) 
      ) { 
       //copy failed 
       imagedestroy($thumbnail); 
       return null; 
      } 

      /* Set the new file name */ 
      $thumbnail_file_name = $file; 

      /* Apply changes on the original image and write the result on the disk */ 
      ImageJPEG($thumbnail, $complete_path . "done/" . $thumbnail_file_name); 
      unset($source_image); 
      unset($thumbnail); 
      unset($original_path); 
      unset($targeted_image_size); 

      echo " done<br />"; 

     } 

    } 

    closedir($handle); 
} 

?> 

Answer 5

bien je fait cette fonction à l'échelle proportionnelle, il utilise une largeur donnée, la hauteur et éventuellement la largeur max/hauteur u veux (dépend de la largeur et de la hauteur donnée)

function scaleProportional($img_w,$img_h,$max=50) 
    { 
     $w = 0; 
     $h = 0; 

     $img_w > $img_h ? $w = $img_w/$img_h : $w = 1; 
     $img_h > $img_w ? $h = $img_h/$img_w : $h = 1; 

     $ws = $w > $h ? $ws = ($w/$w) * $max : $ws = (1/$h) * $max; 
     $hs = $h > $w ? $hs = ($h/$h) * $max : $hs = (1/$w) * $max; 

     return array(
      'width'=>$ws, 
      'height'=>$hs 
     ); 
    } 

utilisation :

  $getScale = scaleProportional(600,200,500); 
      $targ_w = $getScale['width']; //returns 500 
      $targ_h = $getScale['height']; //returns 16,6666667 

Answer 6

Voici comment je le fais:

+ (NSSize) scaleHeight:(NSSize)origSize 
      newHeight:(CGFloat)height { 

    NSSize newSize = NSZeroSize; 
    if (origSize.height == 0) return newSize; 

    newSize.height = height; 
    CGFloat factor = (height/origSize.height); 
    newSize.width = (origSize.width * factor); 

    return newSize; 
} 

+ (NSSize) scaleWidth:(NSSize)origSize 
      newWidth:(CGFloat)width { 

    NSSize newSize = NSZeroSize; 
    if (origSize.width == 0) return newSize; 

    newSize.width = width; 
    CGFloat factor = (width/origSize.width); 
    newSize.height = (origSize.height * factor); 

    return newSize; 
}