Cambiar el tamaño de la imagen en PHP

96

Quiero escribir un código PHP que cambie automáticamente el tamaño de cualquier imagen cargada a través de un formulario a 147x147px, pero no tengo idea de cómo hacerlo (soy un novato relativo de PHP).

Hasta ahora, las imágenes se cargan correctamente, los tipos de archivo se reconocen y los nombres se limpian, pero me gustaría agregar la funcionalidad de cambio de tamaño en el código. Por ejemplo, tengo una imagen de prueba que tiene 2,3 MB y una dimensión de 1331x1331, y me gustaría que el código la redujera, lo que supongo que también comprimirá drásticamente el tamaño de la imagen.

Hasta ahora, tengo lo siguiente:

if ($_FILES) {
                //Put file properties into variables
                $file_name = $_FILES['profile-image']['name'];
                $file_size = $_FILES['profile-image']['size'];
                $file_tmp_name = $_FILES['profile-image']['tmp_name'];

                //Determine filetype
                switch ($_FILES['profile-image']['type']) {
                    case 'image/jpeg': $ext = "jpg"; break;
                    case 'image/png': $ext = "png"; break;
                    default: $ext = ''; break;
                }

                if ($ext) {
                    //Check filesize
                    if ($file_size < 500000) {
                        //Process file - clean up filename and move to safe location
                        $n = "$file_name";
                        $n = ereg_replace("[^A-Za-z0-9.]", "", $n);
                        $n = strtolower($n);
                        $n = "avatars/$n";
                        move_uploaded_file($file_tmp_name, $n);
                    } else {
                        $bad_message = "Please ensure your chosen file is less than 5MB.";
                    }
                } else {
                    $bad_message = "Please ensure your image is of filetype .jpg or.png.";
                }
            }
$query = "INSERT INTO users (image) VALUES ('$n')";
mysql_query($query) or die("Insert failed. " . mysql_error() . "<br />" . $query);
Alex Ryans
fuente
¿Has probado ejemplos como estos stackoverflow.com/questions/10029838/image-resize-with-php ?
Coenie Richards
sin cambiar la entrada , upload_max_filesizeen php.iniprimer lugar, ¿es posible cargar el archivo de tamaño superior a upload_max_filesize?. ¿Hay alguna posibilidad de cambiar el tamaño de la imagen de tamaño más de upload_max_filesize? sin cambiar upload_max_filesizeenphp.ini
rch

Respuestas:

143

Debe utilizar las funciones ImageMagick o GD de PHP para trabajar con imágenes.

Con GD, por ejemplo, es tan simple como ...

function resize_image($file, $w, $h, $crop=FALSE) {
    list($width, $height) = getimagesize($file);
    $r = $width / $height;
    if ($crop) {
        if ($width > $height) {
            $width = ceil($width-($width*abs($r-$w/$h)));
        } else {
            $height = ceil($height-($height*abs($r-$w/$h)));
        }
        $newwidth = $w;
        $newheight = $h;
    } else {
        if ($w/$h > $r) {
            $newwidth = $h*$r;
            $newheight = $h;
        } else {
            $newheight = $w/$r;
            $newwidth = $w;
        }
    }
    $src = imagecreatefromjpeg($file);
    $dst = imagecreatetruecolor($newwidth, $newheight);
    imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);

    return $dst;
}

Y podrías llamar a esta función, así ...

$img = resize_image(‘/path/to/some/image.jpg’, 200, 200);

Por experiencia personal, el remuestreo de imágenes de GD también reduce drásticamente el tamaño del archivo, especialmente cuando se remuestrean imágenes de cámaras digitales sin procesar.

Ian Atkin
fuente
1
¿Está almacenando imágenes como BLOBs? Recomendaría almacenar imágenes en el sistema de archivos e insertar referencias en su base de datos. También recomiendo leer la documentación completa de GD (o ImageMagick) para ver qué otras opciones tiene disponibles.
Ian Atkin
20
Tenga en cuenta que esta solución solo funciona para archivos JPEG. Puede reemplazar imagecreatefromjpeg con cualquiera de los siguientes: imagecreatefromgd, imagecreatefromgif, imagecreatefrompng, imagecreatefromstring, imagecreatefromwbmp, imagecreatefromxbm, imagecreatefromxpm para tratar con diferentes tipos de imágenes.
Chris Hanson
2
@GordonFreeman Gracias por el gran fragmento de código, pero hay un error, agregar abs(), me gusta ceil($width-($width*abs($r-$w/$h)))y lo mismo en la parte de altura. Es necesario para algunos casos.
Arman P.
1
Cambiar el valor de recorte predeterminado a verdadero y cambiar el tamaño de la imagen http://wallpapercave.com/wp/wc1701171.jpga 400x128 (banner) creó una imagen negra; Sin embargo, no puedo entender por qué está haciendo eso.
FoxInFlame
5
Para guardar la imagen redimensionada en el sistema de archivos, agregue imagejpeg($dst, $file);después de la imagecopyresampled($dst,...línea. Cámbielo $filesi no desea sobrescribir el original.
semana
23

También vale la pena considerar este recurso (enlace roto): un código muy ordenado que usa GD. Sin embargo, modifiqué su fragmento de código final para crear esta función que cumple con los requisitos de OP ...

function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {
    
    $target_dir = "your-uploaded-images-folder/";
    $target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);
    
    $image = new SimpleImage();
    $image->load($_FILES[$html_element_name]['tmp_name']);
    $image->resize($new_img_width, $new_img_height);
    $image->save($target_file);
    return $target_file; //return name of saved file in case you want to store it in you database or show confirmation message to user
    
}

También deberá incluir este archivo PHP ...

<?php
 
/*
* File: SimpleImage.php
* Author: Simon Jarvis
* Copyright: 2006 Simon Jarvis
* Date: 08/11/06
* Link: http://www.white-hat-web-design.co.uk/blog/resizing-images-with-php/
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details:
* http://www.gnu.org/licenses/gpl.html
*
*/
 
class SimpleImage {
 
   var $image;
   var $image_type;
 
   function load($filename) {
 
      $image_info = getimagesize($filename);
      $this->image_type = $image_info[2];
      if( $this->image_type == IMAGETYPE_JPEG ) {
 
         $this->image = imagecreatefromjpeg($filename);
      } elseif( $this->image_type == IMAGETYPE_GIF ) {
 
         $this->image = imagecreatefromgif($filename);
      } elseif( $this->image_type == IMAGETYPE_PNG ) {
 
         $this->image = imagecreatefrompng($filename);
      }
   }
   function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {
 
      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image,$filename,$compression);
      } elseif( $image_type == IMAGETYPE_GIF ) {
 
         imagegif($this->image,$filename);
      } elseif( $image_type == IMAGETYPE_PNG ) {
 
         imagepng($this->image,$filename);
      }
      if( $permissions != null) {
 
         chmod($filename,$permissions);
      }
   }
   function output($image_type=IMAGETYPE_JPEG) {
 
      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image);
      } elseif( $image_type == IMAGETYPE_GIF ) {
 
         imagegif($this->image);
      } elseif( $image_type == IMAGETYPE_PNG ) {
 
         imagepng($this->image);
      }
   }
   function getWidth() {
 
      return imagesx($this->image);
   }
   function getHeight() {
 
      return imagesy($this->image);
   }
   function resizeToHeight($height) {
 
      $ratio = $height / $this->getHeight();
      $width = $this->getWidth() * $ratio;
      $this->resize($width,$height);
   }
 
   function resizeToWidth($width) {
      $ratio = $width / $this->getWidth();
      $height = $this->getheight() * $ratio;
      $this->resize($width,$height);
   }
 
   function scale($scale) {
      $width = $this->getWidth() * $scale/100;
      $height = $this->getheight() * $scale/100;
      $this->resize($width,$height);
   }
 
   function resize($width,$height) {
      $new_image = imagecreatetruecolor($width, $height);
      imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
      $this->image = $new_image;
   }      
 
}
?>
ban-geoingeniería
fuente
1
Tu muestra es la mejor. funciona en el marco de Zend directamente sin hacer comedia, drama, tirones de pelo. pulgares arriba
Creo que todo el código que necesita debería estar en mi respuesta, pero esto también puede ayudar: gist.github.com/arrowmedia/7863973 .
ban-geoengineering
20

Función PHP de uso simple ( escala de imágenes ):

Sintaxis:

imagescale ( $image , $new_width , $new_height )

Ejemplo:

Paso: 1 Leer el archivo

$image_name =  'path_of_Image/Name_of_Image.jpg|png';      

Paso: 2: Cargue el archivo de imagen

 $image = imagecreatefromjpeg($image_name); // For JPEG
//or
 $image = imagecreatefrompng($image_name);   // For PNG

Paso: 3: Nuestro salvavidas viene en '_' | Escala la imagen

   $imgResized = imagescale($image , 500, 400); // width=500 and height = 400
//  $imgResized is our final product

Nota: la escala de imágenes funcionará para (PHP 5> = 5.5.0, PHP 7)

Fuente: Haga clic para leer más

M Abdullah
fuente
La mejor solución para PHP 5.6.3>
Pattycake Jr
12

Si no le importa la relación de aspecto (es decir, desea forzar la imagen a una dimensión en particular), aquí hay una respuesta simplificada

// for jpg 
function resize_imagejpg($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefromjpeg($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

 // for png
function resize_imagepng($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefrompng($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

// for gif
function resize_imagegif($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefromgif($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

Ahora manejemos la parte de carga. Primer paso, cargue el archivo en el directorio que desee. Luego, llame a una de las funciones anteriores según el tipo de archivo (jpg, png o gif) y pase la ruta absoluta de su archivo cargado como se muestra a continuación:

 // jpg  change the dimension 750, 450 to your desired values
 $img = resize_imagejpg('path/image.jpg', 750, 450);

El valor de retorno $imges un objeto de recurso. Podemos guardar en una nueva ubicación o anular el original como se muestra a continuación:

 // again for jpg
 imagejpeg($img, 'path/newimage.jpg');

Espero que esto ayude a alguien. Consulte estos enlaces para obtener más información sobre cómo cambiar el tamaño de Imagick :: resizeImage e imagejpeg ()

Tunde Michael
fuente
sin cambiar la entrada , upload_max_filesizeen php.iniprimer lugar no puede cargar el archivo de tamaño superior a upload_max_filesize. ¿Hay alguna posibilidad de cambiar el tamaño de la imagen de tamaño más upload_max_filesizesin cambiar upload_max_filesizeenphp.ini
RCH
6

Espero que funcione para ti.

/**
         * Image re-size
         * @param int $width
         * @param int $height
         */
        function ImageResize($width, $height, $img_name)
        {
                /* Get original file size */
                list($w, $h) = getimagesize($_FILES['logo_image']['tmp_name']);


                /*$ratio = $w / $h;
                $size = $width;

                $width = $height = min($size, max($w, $h));

                if ($ratio < 1) {
                    $width = $height * $ratio;
                } else {
                    $height = $width / $ratio;
                }*/

                /* Calculate new image size */
                $ratio = max($width/$w, $height/$h);
                $h = ceil($height / $ratio);
                $x = ($w - $width / $ratio) / 2;
                $w = ceil($width / $ratio);
                /* set new file name */
                $path = $img_name;


                /* Save image */
                if($_FILES['logo_image']['type']=='image/jpeg')
                {
                    /* Get binary data from image */
                    $imgString = file_get_contents($_FILES['logo_image']['tmp_name']);
                    /* create image from string */
                    $image = imagecreatefromstring($imgString);
                    $tmp = imagecreatetruecolor($width, $height);
                    imagecopyresampled($tmp, $image, 0, 0, $x, 0, $width, $height, $w, $h);
                    imagejpeg($tmp, $path, 100);
                }
                else if($_FILES['logo_image']['type']=='image/png')
                {
                    $image = imagecreatefrompng($_FILES['logo_image']['tmp_name']);
                    $tmp = imagecreatetruecolor($width,$height);
                    imagealphablending($tmp, false);
                    imagesavealpha($tmp, true);
                    imagecopyresampled($tmp, $image,0,0,$x,0,$width,$height,$w, $h);
                    imagepng($tmp, $path, 0);
                }
                else if($_FILES['logo_image']['type']=='image/gif')
                {
                    $image = imagecreatefromgif($_FILES['logo_image']['tmp_name']);

                    $tmp = imagecreatetruecolor($width,$height);
                    $transparent = imagecolorallocatealpha($tmp, 0, 0, 0, 127);
                    imagefill($tmp, 0, 0, $transparent);
                    imagealphablending($tmp, true); 

                    imagecopyresampled($tmp, $image,0,0,0,0,$width,$height,$w, $h);
                    imagegif($tmp, $path);
                }
                else
                {
                    return false;
                }

                return true;
                imagedestroy($image);
                imagedestroy($tmp);
        }
Er.gaurav soni
fuente
6

Creé una biblioteca fácil de usar para cambiar el tamaño de la imagen. Se puede encontrar aquí en Github .

Un ejemplo de cómo usar la biblioteca:

// Include PHP Image Magician library
require_once('php_image_magician.php');

// Open JPG image
$magicianObj = new imageLib('racecar.jpg');

// Resize to best fit then crop (check out the other options)
$magicianObj -> resizeImage(100, 200, 'crop');

// Save resized image as a PNG (or jpg, bmp, etc)
$magicianObj -> saveImage('racecar_small.png');

Otras características, si las necesita, son:

  • Cambio de tamaño rápido y fácil: cambie el tamaño a horizontal, vertical o automático
  • Cultivo fácil
  • Añadir texto
  • Ajuste de calidad
  • Marca de agua
  • Sombras y reflejos
  • Soporte de transparencia
  • Leer metadatos EXIF
  • Bordes, Esquinas redondeadas, Rotación
  • Filtros y efectos
  • Nitidez de imagen
  • Conversión de tipo de imagen
  • Soporte BMP
Jarrod
fuente
1
Esto me salvó el día. Sin embargo, hay un pequeño aviso que le he enviado a alguien que estuvo buscando durante 3 días como yo y estaba a punto de perder la esperanza de encontrar una solución para cambiar el tamaño. Si ve avisos de índice indefinidos en el futuro, simplemente vea este enlace: github.com/Oberto/php-image-magician/pull/16/commits Y aplique los cambios a los archivos. Funcionará al 100% sin problemas.
Hema_Elmasry
2
Hola, @Hema_Elmasry. FYI, acabo de fusionar esos cambios en el principal :)
Jarrod
Ok, lo siento, no me di cuenta. Pero tengo una pregunta. Cuando hago un cambio de tamaño a una resolución menor sin cambiar la calidad, la calidad de la imagen mostrada será mucho menor. ¿Te ha pasado algo parecido antes? Porque todavía no encontré una solución.
Hema_Elmasry
6

( IMPORTANTE : En el caso del cambio de tamaño de la animación (webp animado o gif), el resultado será una imagen no animada, pero redimensionada desde el primer fotograma (la animación original permanece intacta ...)

Creé esto en mi proyecto php 7.2 (ejemplo imagebmp seguro (PHP 7> = 7.2.0): php / manual / function.imagebmp ) sobre techfry.com/php-tutorial , con GD2, (así que nada de biblioteca de terceros) y muy similar a la respuesta de Nico Bistolfi, pero funciona con los cinco tipos básicos de imagen mime ( png, jpeg, webp, bmp y gif ), creando un nuevo archivo redimensionado, sin modificar el original, y todo en una función y listo para usar (copiar y pegar en su proyecto). (Puede establecer la extensión del nuevo archivo con el quinto parámetro, o simplemente dejarlo, si desea mantener el original):

function createResizedImage(
    string $imagePath = '',
    string $newPath = '',
    int $newWidth = 0,
    int $newHeight = 0,
    string $outExt = 'DEFAULT'
) : ?string
{
    if (!$newPath or !file_exists ($imagePath)) {
        return null;
    }

    $types = [IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_GIF, IMAGETYPE_BMP, IMAGETYPE_WEBP];
    $type = exif_imagetype ($imagePath);

    if (!in_array ($type, $types)) {
        return null;
    }

    list ($width, $height) = getimagesize ($imagePath);

    $outBool = in_array ($outExt, ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']);

    switch ($type) {
        case IMAGETYPE_JPEG:
            $image = imagecreatefromjpeg ($imagePath);
            if (!$outBool) $outExt = 'jpg';
            break;
        case IMAGETYPE_PNG:
            $image = imagecreatefrompng ($imagePath);
            if (!$outBool) $outExt = 'png';
            break;
        case IMAGETYPE_GIF:
            $image = imagecreatefromgif ($imagePath);
            if (!$outBool) $outExt = 'gif';
            break;
        case IMAGETYPE_BMP:
            $image = imagecreatefrombmp ($imagePath);
            if (!$outBool) $outExt = 'bmp';
            break;
        case IMAGETYPE_WEBP:
            $image = imagecreatefromwebp ($imagePath);
            if (!$outBool) $outExt = 'webp';
    }

    $newImage = imagecreatetruecolor ($newWidth, $newHeight);

    //TRANSPARENT BACKGROUND
    $color = imagecolorallocatealpha ($newImage, 0, 0, 0, 127); //fill transparent back
    imagefill ($newImage, 0, 0, $color);
    imagesavealpha ($newImage, true);

    //ROUTINE
    imagecopyresampled ($newImage, $image, 0, 0, 0, 0, $newWidth, $newHeight, $width, $height);

    // Rotate image on iOS
    if(function_exists('exif_read_data') && $exif = exif_read_data($imagePath, 'IFD0'))
    {
        if(isset($exif['Orientation']) && isset($exif['Make']) && !empty($exif['Orientation']) && preg_match('/(apple|ios|iphone)/i', $exif['Make'])) {
            switch($exif['Orientation']) {
                case 8:
                    if ($width > $height) $newImage = imagerotate($newImage,90,0);
                    break;
                case 3:
                    $newImage = imagerotate($newImage,180,0);
                    break;
                case 6:
                    $newImage = imagerotate($newImage,-90,0);
                    break;
            }
        }
    }

    switch (true) {
        case in_array ($outExt, ['jpg', 'jpeg']): $success = imagejpeg ($newImage, $newPath);
            break;
        case $outExt === 'png': $success = imagepng ($newImage, $newPath);
            break;
        case $outExt === 'gif': $success = imagegif ($newImage, $newPath);
            break;
        case  $outExt === 'bmp': $success = imagebmp ($newImage, $newPath);
            break;
        case  $outExt === 'webp': $success = imagewebp ($newImage, $newPath);
    }

    if (!$success) {
        return null;
    }

    return $newPath;
}
danigore
fuente
¡Eres genial! Esta es una solución simple y limpia. Tuve un problema con el módulo Imagick y resolví problemas con esta clase simple. ¡Gracias!
Ivijan Stefan Stipić
Genial, si quieres puedo agregar otra actualización más tarde, mejoro esto un poco.
Ivijan Stefan Stipić
¡Por supuesto! Todavía no tengo tiempo para construir la parte de cambio de tamaño de la animación ...
danigore
@danigore, ¿cómo cambiar el tamaño de las imágenes en bruto ( .cr2, .dng, .nefy los me gusta)? GD2 no tiene ningún soporte y después de mucha lucha, pude configurar ImageMagick. Pero, falla con un error de tiempo de espera de conexión al leer el archivo. Y tampoco hay registro de errores ..
Krishna Chebrolu
1
@danigore Agrego a su función la rotación automática de imágenes para solucionar problemas de Apple.
Ivijan Stefan Stipić
2

Aquí hay una versión extendida de la respuesta que dio @Ian Atkin '. Descubrí que funcionaba muy bien. Para imágenes más grandes, eso es :). De hecho, puede hacer que las imágenes más pequeñas sean más grandes si no tiene cuidado. Cambios: - Admite archivos jpg, jpeg, png, gif, bmp - Conserva la transparencia para .png y .gif - Comprueba dos veces si el tamaño del original ya no es más pequeño - Anula la imagen proporcionada directamente (es lo que necesitaba)

Asi que aqui esta. Los valores predeterminados de la función son la "regla de oro".

function resize_image($file, $w = 1200, $h = 741, $crop = false)
   {
       try {
           $ext = pathinfo(storage_path() . $file, PATHINFO_EXTENSION);
           list($width, $height) = getimagesize($file);
           // if the image is smaller we dont resize
           if ($w > $width && $h > $height) {
               return true;
           }
           $r = $width / $height;
           if ($crop) {
               if ($width > $height) {
                   $width = ceil($width - ($width * abs($r - $w / $h)));
               } else {
                   $height = ceil($height - ($height * abs($r - $w / $h)));
               }
               $newwidth = $w;
               $newheight = $h;
           } else {
               if ($w / $h > $r) {
                   $newwidth = $h * $r;
                   $newheight = $h;
               } else {
                   $newheight = $w / $r;
                   $newwidth = $w;
               }
           }
           $dst = imagecreatetruecolor($newwidth, $newheight);

           switch ($ext) {
               case 'jpg':
               case 'jpeg':
                   $src = imagecreatefromjpeg($file);
                   break;
               case 'png':
                   $src = imagecreatefrompng($file);
                   imagecolortransparent($dst, imagecolorallocatealpha($dst, 0, 0, 0, 127));
                   imagealphablending($dst, false);
                   imagesavealpha($dst, true);
                   break;
               case 'gif':
                   $src = imagecreatefromgif($file);
                   imagecolortransparent($dst, imagecolorallocatealpha($dst, 0, 0, 0, 127));
                   imagealphablending($dst, false);
                   imagesavealpha($dst, true);
                   break;
               case 'bmp':
                   $src = imagecreatefrombmp($file);
                   break;
               default:
                   throw new Exception('Unsupported image extension found: ' . $ext);
                   break;
           }
           $result = imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);
           switch ($ext) {
               case 'bmp':
                   imagewbmp($dst, $file);
                   break;
               case 'gif':
                   imagegif($dst, $file);
                   break;
               case 'jpg':
               case 'jpeg':
                   imagejpeg($dst, $file);
                   break;
               case 'png':
                   imagepng($dst, $file);
                   break;
           }
           return true;
       } catch (Exception $err) {
           // LOG THE ERROR HERE 
           return false;
       }
   }
Daniel Doinov
fuente
Gran función @DanielDoinov - gracias por publicarlo - pregunta rápida: ¿hay alguna manera de pasar solo el ancho y dejar que la función ajuste relativamente la altura en función de la imagen original? En otras palabras, si el original es 400x200, ¿podemos decirle a la función que queremos que el nuevo ancho sea 200 y dejar que la función descubra que la altura debe ser 100?
marcnyc
Con respecto a su expresión condicional, no creo que tenga sentido ejecutar la técnica de cambio de tamaño si $w === $width && $h === $height. Piénsalo. Debería ser >=y >=comparaciones. @Daniel
mickmackusa
1

Pastel ZF:

<?php

class FkuController extends Zend_Controller_Action {

  var $image;
  var $image_type;

  public function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {

    $target_dir = APPLICATION_PATH  . "/../public/1/";
    $target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);

    //$image = new SimpleImage();
    $this->load($_FILES[$html_element_name]['tmp_name']);
    $this->resize($new_img_width, $new_img_height);
    $this->save($target_file);
    return $target_file; 
    //return name of saved file in case you want to store it in you database or show confirmation message to user



  public function load($filename) {

      $image_info = getimagesize($filename);
      $this->image_type = $image_info[2];
      if( $this->image_type == IMAGETYPE_JPEG ) {

         $this->image = imagecreatefromjpeg($filename);
      } elseif( $this->image_type == IMAGETYPE_GIF ) {

         $this->image = imagecreatefromgif($filename);
      } elseif( $this->image_type == IMAGETYPE_PNG ) {

         $this->image = imagecreatefrompng($filename);
      }
   }
  public function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image,$filename,$compression);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image,$filename);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image,$filename);
      }
      if( $permissions != null) {

         chmod($filename,$permissions);
      }
   }
  public function output($image_type=IMAGETYPE_JPEG) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image);
      }
   }
  public function getWidth() {

      return imagesx($this->image);
   }
  public function getHeight() {

      return imagesy($this->image);
   }
  public function resizeToHeight($height) {

      $ratio = $height / $this->getHeight();
      $width = $this->getWidth() * $ratio;
      $this->resize($width,$height);
   }

  public function resizeToWidth($width) {
      $ratio = $width / $this->getWidth();
      $height = $this->getheight() * $ratio;
      $this->resize($width,$height);
   }

  public function scale($scale) {
      $width = $this->getWidth() * $scale/100;
      $height = $this->getheight() * $scale/100;
      $this->resize($width,$height);
   }

  public function resize($width,$height) {
      $new_image = imagecreatetruecolor($width, $height);
      imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
      $this->image = $new_image;
   }

  public function savepicAction() {
    ini_set('display_errors', 1);
    ini_set('display_startup_errors', 1);
    error_reporting(E_ALL);

    $this->_helper->layout()->disableLayout();
    $this->_helper->viewRenderer->setNoRender();
    $this->_response->setHeader('Access-Control-Allow-Origin', '*');

    $this->db = Application_Model_Db::db_load();        
    $ouser = $_POST['ousername'];


      $fdata = 'empty';
      if (isset($_FILES['picture']) && $_FILES['picture']['size'] > 0) {
        $file_size = $_FILES['picture']['size'];
        $tmpName  = $_FILES['picture']['tmp_name'];  

        //Determine filetype
        switch ($_FILES['picture']['type']) {
            case 'image/jpeg': $ext = "jpg"; break;
            case 'image/png': $ext = "png"; break;
            case 'image/jpg': $ext = "jpg"; break;
            case 'image/bmp': $ext = "bmp"; break;
            case 'image/gif': $ext = "gif"; break;
            default: $ext = ''; break;
        }

        if($ext) {
          //if($file_size<400000) {  
            $img = $this->store_uploaded_image('picture', 90,82);
            //$fp      = fopen($tmpName, 'r');
            $fp = fopen($img, 'r');
            $fdata = fread($fp, filesize($tmpName));        
            $fdata = base64_encode($fdata);
            fclose($fp);

          //}
        }

      }

      if($fdata=='empty'){

      }
      else {
        $this->db->update('users', 
          array(
            'picture' => $fdata,             
          ), 
          array('username=?' => $ouser ));        
      }



  }  

fuente
1

Encontré una forma matemática de hacer este trabajo

Repositorio de Github: https://github.com/gayanSandamal/easy-php-image-resizer

Ejemplo en vivo: https://plugins.nayague.com/easy-php-image-resizer/

<?php
//path for the image
$source_url = '2018-04-01-1522613288.PNG';

//separate the file name and the extention
$source_url_parts = pathinfo($source_url);
$filename = $source_url_parts['filename'];
$extension = $source_url_parts['extension'];

//define the quality from 1 to 100
$quality = 10;

//detect the width and the height of original image
list($width, $height) = getimagesize($source_url);
$width;
$height;

//define any width that you want as the output. mine is 200px.
$after_width = 200;

//resize only when the original image is larger than expected with.
//this helps you to avoid from unwanted resizing.
if ($width > $after_width) {

    //get the reduced width
    $reduced_width = ($width - $after_width);
    //now convert the reduced width to a percentage and round it to 2 decimal places
    $reduced_radio = round(($reduced_width / $width) * 100, 2);

    //ALL GOOD! let's reduce the same percentage from the height and round it to 2 decimal places
    $reduced_height = round(($height / 100) * $reduced_radio, 2);
    //reduce the calculated height from the original height
    $after_height = $height - $reduced_height;

    //Now detect the file extension
    //if the file extension is 'jpg', 'jpeg', 'JPG' or 'JPEG'
    if ($extension == 'jpg' || $extension == 'jpeg' || $extension == 'JPG' || $extension == 'JPEG') {
        //then return the image as a jpeg image for the next step
        $img = imagecreatefromjpeg($source_url);
    } elseif ($extension == 'png' || $extension == 'PNG') {
        //then return the image as a png image for the next step
        $img = imagecreatefrompng($source_url);
    } else {
        //show an error message if the file extension is not available
        echo 'image extension is not supporting';
    }

    //HERE YOU GO :)
    //Let's do the resize thing
    //imagescale([returned image], [width of the resized image], [height of the resized image], [quality of the resized image]);
    $imgResized = imagescale($img, $after_width, $after_height, $quality);

    //now save the resized image with a suffix called "-resized" and with its extension. 
    imagejpeg($imgResized, $filename . '-resized.'.$extension);

    //Finally frees any memory associated with image
    //**NOTE THAT THIS WONT DELETE THE IMAGE
    imagedestroy($img);
    imagedestroy($imgResized);
}
?>
Gayan Sandamal
fuente
0

Puede probar la biblioteca PHP TinyPNG. Al usar esta biblioteca, su imagen se optimiza automáticamente durante el proceso de cambio de tamaño. Todo lo que necesita para instalar la biblioteca y obtener una clave API de https://tinypng.com/developers . Para instalar una biblioteca, ejecute el siguiente comando.

composer require tinify/tinify

Después de eso, su código es el siguiente.

require_once("vendor/autoload.php");

\Tinify\setKey("YOUR_API_KEY");

$source = \Tinify\fromFile("large.jpg"); //image to be resize
$resized = $source->resize(array(
    "method" => "fit",
    "width" => 150,
    "height" => 100
));
$resized->toFile("thumbnail.jpg"); //resized image

Tengo un blog escrito sobre el mismo tema http://artisansweb.net/resize-image-php-using-tinypng

Sajid Sayyad
fuente
0

Sugeriría una forma fácil:

function resize($file, $width, $height) {
    switch(pathinfo($file)['extension']) {
        case "png": return imagepng(imagescale(imagecreatefrompng($file), $width, $height), $file);
        case "gif": return imagegif(imagescale(imagecreatefromgif($file), $width, $height), $file);
        default : return imagejpeg(imagescale(imagecreatefromjpeg($file), $width, $height), $file);
    }
}
Amir Fo
fuente
0
private function getTempImage($url, $tempName){
  $tempPath = 'tempFilePath' . $tempName . '.png';
  $source_image = imagecreatefrompng($url); // check type depending on your necessities.
  $source_imagex = imagesx($source_image);
  $source_imagey = imagesy($source_image);
  $dest_imagex = 861; // My default value
  $dest_imagey = 96;  // My default value

  $dest_image = imagecreatetruecolor($dest_imagex, $dest_imagey);

  imagecopyresampled($dest_image, $source_image, 0, 0, 0, 0, $dest_imagex, $dest_imagey, $source_imagex, $source_imagey);

  imagejpeg($dest_image, $tempPath, 100);

  return $tempPath;

}

Esta es una solución adaptada basada en esta gran explicación. Este chico hizo una explicación paso a paso. Espero que todos lo disfruten.

Emiliano Barboza
fuente