Redimensionar imagem em PHP

96

Estou querendo escrever um código PHP que redimensiona automaticamente qualquer imagem carregada por meio de um formulário para 147x147px, mas não tenho ideia de como fazer isso (sou relativamente novato em PHP).

Até agora, carreguei imagens com sucesso, tipos de arquivos sendo reconhecidos e nomes limpos, mas gostaria de adicionar a funcionalidade de redimensionamento ao código. Por exemplo, eu tenho uma imagem de teste que tem 2,3 MB e 1331 x 1331 de dimensão e gostaria que o código diminuísse, o que suponho que comprimirá drasticamente o tamanho do arquivo da imagem também.

Até agora, tenho o seguinte:

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
fonte
Você já experimentou amostras como estas stackoverflow.com/questions/10029838/image-resize-with-php ?
Coenie Richards
sem alterar a entrada , upload_max_filesizeem php.iniprimeiro lugar é possível carregar o arquivo com um tamanho maior que upload_max_filesize?. Existe alguma chance de redimensionar a imagem para um tamanho maior que upload_max_filesize? sem alterar upload_max_filesizeemphp.ini
RCH

Respostas:

140

Você precisa usar as funções ImageMagick ou GD do PHP para trabalhar com imagens.

Com o GD, por exemplo, é tão simples quanto ...

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;
}

E você pode chamar esta função, assim ...

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

Por experiência pessoal, a reamostragem de imagem do GD também reduz drasticamente o tamanho do arquivo, especialmente ao reamostrar imagens brutas de câmeras digitais.

Ian Atkin
fonte
Obrigado! Perdoe minha ignorância, mas onde isso estaria no código que já obtive e onde estaria a chamada de função? Estou certo ao dizer que, onde obtive meu banco de dados, INSERT, em vez de inserir $ n, eu inseriria $ img? Ou $ n seria estruturado $ n = ($ img = resize_image ('/ path / to / some / image.jpg', 200, 200)) ;?
Alex Ryans
1
Você está armazenando imagens como BLOBs? Eu recomendaria armazenar imagens no sistema de arquivos e inserir referências em seu banco de dados. Também recomendo a leitura da documentação completa do GD (ou ImageMagick) para ver quais outras opções você tem disponíveis.
Ian Atkin
17
Observe que esta solução só funciona para JPEGs. Você pode substituir imagecreatefromjpeg por qualquer um dos seguintes: imagecreatefromgd, imagecreatefromgif, imagecreatefrompng, imagecreatefromstring, imagecreatefromwbmp, imagecreatefromxbm, imagecreatefromxpm para lidar com diferentes tipos de imagem.
Chris Hanson
2
@GordonFreeman Obrigado pelo ótimo trecho de código, mas há uma falha aí, adicione abs(), goste ceil($width-($width*abs($r-$w/$h)))e igual à parte da altura. É necessário em alguns casos.
Arman P.
4
Para salvar a imagem redimensionada no sistema de arquivos, adicione imagejpeg($dst, $file);após a imagecopyresampled($dst,...linha. Altere $filese não quiser substituir o original.
wkille
23

Este recurso (link quebrado) também vale a pena considerar - alguns códigos bem organizados que usam GD. No entanto, eu modifiquei seu trecho de código final para criar esta função que atende aos requisitos de OPs ...

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
    
}

Você também precisará incluir este arquivo 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-geoengenharia
fonte
1
Sua amostra é a melhor. ele funciona no framework Zend diretamente sem criar comédia, drama, puxões de cabelo. polegar para cima
Acho que todo o código de que você precisa deve estar na minha resposta, mas isso também pode ajudar: gist.github.com/arrowmedia/7863973 .
ban-geoengenharia de
19

Função simples de usar PHP ( imagescale ):

Sintaxe:

imagescale ( $image , $new_width , $new_height )

Exemplo:

Etapa: 1 Leia o arquivo

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

Etapa: 2: carregar o arquivo de imagem

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

Etapa: 3: Nosso salva-vidas vem em '_' | Dimensione a imagem

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

Nota: imagescale funcionará para (PHP 5> = 5.5.0, PHP 7)

Fonte: Clique para ler mais

M Abdullah
fonte
Melhor solução para PHP 5.6.3>
Pattycake Jr
12

Se você não se preocupa com a relação de aspecto (ou seja, você deseja forçar a imagem para uma dimensão específica), aqui está uma resposta 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;
}

Agora vamos cuidar da parte do upload. Primeiro passo, carregue o arquivo no diretório desejado. Em seguida, chame uma das funções acima com base no tipo de arquivo (jpg, png ou gif) e passe o caminho absoluto do seu arquivo enviado conforme abaixo:

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

O valor de retorno $imgé um objeto de recurso. Podemos salvar em um novo local ou substituir o original conforme abaixo:

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

Espero que isso ajude alguém. Verifique estes links para mais informações sobre redimensionamento de Imagick :: resizeImage e imagejpeg ()

Tunde Michael
fonte
sem alterar a entrada , upload_max_filesizeem php.iniprimeiro lugar você não pode carregar o arquivo com tamanho superior a upload_max_filesize. Existe alguma chance para redimensionar a imagem de tamanho mais do que upload_max_filesize, sem alterar upload_max_filesizeemphp.ini
RCH
6

Espero que funcione para você.

/**
         * 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
fonte
6

( IMPORTANTE : no caso de redimensionamento de animação (webp ou gif animado), o resultado será uma imagem não animada, mas redimensionada do primeiro quadro! (A animação original permanece intacta ...)

Eu criei isso no meu projeto php 7.2 (exemplo imagebmp sure (PHP 7> = 7.2.0): php / manual / function.imagebmp ) sobre techfry.com/php-tutorial , com GD2, (então nada de biblioteca de terceiros) e muito semelhante à resposta de Nico Bistolfi, mas funciona com todos os cinco tipos básicos de imagem ( png, jpeg, webp, bmp e gif ), criando um novo arquivo redimensionado, sem modificar o original, e tudo em uma função e pronto para usar (copie e cole no seu projeto). (Você pode definir a extensão do novo arquivo com o quinto parâmetro, ou apenas deixá-lo, se quiser manter o 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
fonte
Você é ótimo! Esta é uma solução simples e limpa. Tive problemas com o módulo Imagick e resolvi problemas com esta classe simples. Obrigado!
Ivijan Stefan Stipić
Ótimo, se quiser, posso adicionar outra atualização depois, vou melhorar um pouco.
Ivijan Stefan Stipić
certo! Ainda não tive tempo de construir a parte de redimensionamento da animação ...
danigore
@danigore, como redimensionar imagens raw ( .cr2, .dng, .nefe similares)? GD2 não tem nenhum suporte e depois de muita luta consegui configurar o ImageMagick. Mas, ele falha com erro de tempo limite de conexão ao ler o arquivo. E, também não há registro de erros ..
Krishna Chebrolu
1
@danigore adiciono à sua função rotação automática de imagem para corrigir problemas da Apple.
Ivijan Stefan Stipić
5

Criei uma biblioteca fácil de usar para redimensionar imagens. Ele pode ser encontrado aqui no Github .

Um exemplo de como usar a 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');

Outros recursos, caso você precise deles, são:

  • Redimensionar rápido e fácil - redimensionar para paisagem, retrato ou automático
  • Colheita fácil
  • Adicione texto
  • Ajuste de qualidade
  • Marca d'água
  • Sombras e reflexos
  • Suporte de transparência
  • Ler metadados EXIF
  • Bordas, cantos arredondados, rotação
  • Filtros e efeitos
  • Nitidez da imagem
  • Conversão de tipo de imagem
  • Suporte BMP
Jarrod
fonte
Isso salvou meu dia. Porém, há um pequeno aviso que eu fiz para alguém que estava procurando por 3 dias como eu e estava prestes a perder a esperança de encontrar uma solução de redimensionamento. Se você vir avisos de índice indefinido no futuro, basta ver este link: github.com/Oberto/php-image-magician/pull/16/commits E aplicar as alterações aos arquivos. Funcionará 100% sem problemas.
Hema_Elmasry de
1
Ei, @Hema_Elmasry. Para sua informação, acabei de mesclar essas alterações no principal :)
Jarrod
Ok, desculpe, não percebi. Mas tenho uma pergunta. Quando faço um redimensionamento para uma resolução menor com a qualidade não alterada, a qualidade da imagem exibida é muito inferior. Algo semelhante já aconteceu com você antes? Porque ainda não encontrei uma solução.
Hema_Elmasry
2

Aqui está uma versão estendida da resposta que @Ian Atkin 'deu. Achei que funcionou extremamente bem. Para imagens maiores, isto é :). Você pode realmente tornar as imagens menores maiores se não tiver cuidado. Mudanças: - Suporta arquivos jpg, jpeg, png, gif, bmp - Preserva a transparência para .png e .gif - Verifica duas vezes se o tamanho do original já não é menor - Substitui a imagem fornecida diretamente (é o que eu precisava)

Então aqui está. Os valores padrão da função são a "regra de ouro"

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
fonte
Ótima função @DanielDoinov - obrigado por postar - pergunta rápida: existe uma maneira de apenas passar a largura e deixar a função ajustar a altura relativamente com base na imagem original? Em outras palavras, se o original é 400x200, podemos dizer à função que queremos que a nova largura seja 200 e deixar a função descobrir que a altura deve ser 100?
marcnyc
Em relação à sua expressão condicional, não acho que faça sentido executar a técnica de redimensionamento se $w === $width && $h === $height. Pense nisso. Deve ser >=e >=comparações. @Daniel
mickmackusa
1

Bolo 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 ));        
      }



  }  

fonte
1

Eu encontrei uma maneira matemática de fazer este trabalho

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

Exemplo ao 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
fonte
0

Você pode experimentar a biblioteca PHP TinyPNG. Usando esta biblioteca, sua imagem é otimizada automaticamente durante o processo de redimensionamento. Tudo o que você precisa para instalar a biblioteca e obter uma chave de API em https://tinypng.com/developers . Para instalar uma biblioteca, execute o comando abaixo.

composer require tinify/tinify

Depois disso, seu código é o seguinte.

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

Eu escrevi um blog sobre o mesmo tópico http://artisansweb.net/resize-image-php-using-tinypng

Sajid Sayyad
fonte
0

Eu sugeriria uma maneira 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
fonte
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 é uma solução adaptada com base nesta grande explicação. Esse cara deu uma explicação passo a passo. Espero que todos gostem.

Emiliano Barboza
fonte