Na maioria dos sistemas que criamos temos que utilizar imagens. Seja para um perfil de usuário, envio de um logo, galerias e assim por diante.

O PHP não só no oferece a possibilidade de criar página inteiramente dinâmicas, mas também de criar imagens dinamicamente. Com a extensão GD, de fato, você pode até mesmo criar imagens do zero, fazer desenhos, colorir e fazer mais algumas coisas legais.

Neste artigo você vai aprender a redimensionar imagens em PHP de duas maneiras; ou deixar a imagem em um local temporário e destruindo-a assim que ela for exibida, ou salvar a mesma em uma pasta permanente do seu servidor.

Ao final do artigo, vou mostrar uma classe que criei para redimensionar imagens em JPG, PNG e GIF. Assim você não vai precisar passar por todo o processo toda vez que precisar do redimensionamento.

Nota: Normalmente a biblioteca GD já vem com a instalação do PHP acima de versões 4.3, mas se no seu caso precisar fazer a instalação, siga os passos do Manual do PHP – Instalação da extensão GD.

Se você estiver utilizando o Windows, basta remover o comentário da seguinte linha:

extension=php_gd2.dll

Veja:

extension=php_gd2.dll

extension=php_gd2.dll

Então vamos lá.

Como redimensionar imagens com PHP

O primeiro passo para redimensionar uma imagem é verificar qual tipo de imagem você está manipulando. Neste tutorial vamos passar por três dos formatos mais utilizados na Web: PNG, GIF e JPG.

Vamos começar com JPG.

Imagens JPG com PHP

1 – Crie uma pasta qualquer aí no seu servidor e copia uma imagem JPG para essa pasta. Para nosso exemplo vou nomear meu arquivo de teste.jpg.

2 – Crie um arquivo PHP chamado index.php e vamos trabalhar dentro dele.

3 – Para iniciar, temos que criar uma imagem jpg a partir do arquivo que temos em nosso servidor (pode ser uma URL também). Para isso, utilize a função imagecreatefromjpeg, veja:

// O caminho da nossa imagem no servidor
$caminho_imagem = 'teste.jpg';

// Retorna o identificador da imagem
$imagem = imagecreatefromjpeg($caminho_imagem);

4 – Agora vamos capturar a largura e altura da nossa imagem. Para isso utilize a função getimagesize. Essa função nos retorna um array com os valores da imagem, sendo a primeira chave a largura, e segunda a altura (além de outras coisas). Com isso, podemos utilizar a função list para gerar variáveis na ordem largura/altura. Veja:

// Cria duas variáveis com a largura e altura da imagem
list( $largura, $altura ) = getimagesize( $caminho_imagem );

5 – Agora vamos utilizar uma proporção para redimensionar as imagens. Você pode utilizar o que preferir, até mesmo um tamanho fixo para largura e altura. Vou utilizar este método para simplificar o nosso tutorial. Nossa nova imagem terá 50% do tamanho original da imagem que estamos redimensionando.

// Nova largura e altura
$proporcao = 0.5;
$nova_largura = $largura * $proporcao;
$nova_altura = $altura * $proporcao;

Ou seja, a nova altura é a largura original vezes nossa proporção. O mesmo para altura.

6 – Agora vamos criar uma nova imagem em branco com as novas dimensões. Para isso utilizamos a função imagecreatetruecolor.

// Cria uma nova imagem em branco
$nova_imagem = imagecreatetruecolor( $nova_largura, $nova_altura );

Agora temos um identificador da nossa nova imagem.

7 – Temos que copiar a imagem original para a nova imagem com o novo tamanho, para isso utilizamos a função imagecopyresampled.

// Copia a imagem para a nova imagem com o novo tamanho
imagecopyresampled(
    $nova_imagem, // Nova imagem 
    $imagem, // Imagem original
    0, // Coordenada X da nova imagem
    0, // Coordenada Y da nova imagem 
    0, // Coordenada X da imagem 
    0, // Coordenada Y da imagem  
    $nova_largura, // Nova largura
    $nova_altura, // Nova altura
    $largura, // Largura original
    $altura // Altura original
);

Essa função faz praticamente tudo, até mesmo corta a imagem se você precisar. Para nosso caso, estamos apenas redimensionando a imagem (Veja os comentários acima para entender melhor).

8 – Agora temos que gerar uma imagem JPG (o mesmo formato da imagem original). Para isso utilizamos a função imagejpeg do PHP.

// Cria a imagem
imagejpeg( $nova_imagem, 'nova_imagem.jpg', 100 );

O trecho acima irá salvar a nova imagem em um arquivo chamado nova_imagem.jpg com 100 de qualidade. Se você quisesse apenas exibir uma imagem temporária, bastaria configurar o segundo parâmetro da função como NULL, porém, você deveria adicionar um cabeçalho indicando que o conteúdo da página é uma imagem. Veja como ficaria:

// Cabeçalho
header('Content-type: image/jpg');

// Cria a imagem
imagejpeg( $nova_imagem, null, 100 );

Agora a imagem não é mais salva no disco, apenas exibida na tela.

9 – Por fim, temos que destruir as imagens que criamos. Fazemos isso da seguinte maneira:

// Remove as imagens temporárias
imagedestroy($imagem);
imagedestroy($nova_imagem);

E pronto! Agora temos nossa nova imagem redimensionada.

Código completo para redimensionar imagem JPG

Veja como ficou o código completo:

<?php
// O caminho da nossa imagem no servidor
$caminho_imagem = 'teste.jpg';

// Retorna o identificador da imagem
$imagem = imagecreatefromjpeg($caminho_imagem);

// Cria duas variáveis com a largura e altura da imagem
list( $largura, $altura ) = getimagesize( $caminho_imagem );

// Nova largura e altura
$proporcao = 0.5;
$nova_largura = $largura * $proporcao;
$nova_altura = $altura * $proporcao;

// Cria uma nova imagem em branco
$nova_imagem = imagecreatetruecolor( $nova_largura, $nova_altura );

// Copia a imagem para a nova imagem com o novo tamanho
imagecopyresampled(
    $nova_imagem, // Nova imagem 
    $imagem, // Imagem original
    0, // Coordenada X da nova imagem
    0, // Coordenada Y da nova imagem 
    0, // Coordenada X da imagem 
    0, // Coordenada Y da imagem  
    $nova_largura, // Nova largura
    $nova_altura, // Nova altura
    $largura, // Largura original
    $altura // Altura original
);

// Cria a imagem
imagejpeg( $nova_imagem, 'nova_imagem.jpg', 100 );

// Remove as imagens temporárias
imagedestroy($imagem);
imagedestroy($nova_imagem);
?>

Para os outros formatos, mudamos apenas algumas linhas de código. Vamos ver como funcionam PNG e GIF posteriormente.

Redimensionando imagens PNG com PHP

O processo é praticamente o mesmo, apenas mudamos duas funções. Ao invés de imagecreatefromjpeg, usaremos imagecreatefrompng e ao invés de  imagejpeg usaremos imagepng.

Observação: A qualidade para PNG deve ir de 0 a 9, não de 0 a 100.

Veja o código completo:

<?php
// O caminho da nossa imagem no servidor
$caminho_imagem = 'teste.png';

// Retorna o identificador da imagem
$imagem = imagecreatefrompng($caminho_imagem);

// Cria duas variáveis com a largura e altura da imagem
list( $largura, $altura ) = getimagesize( $caminho_imagem );

// Nova largura e altura
$proporcao = 0.5;
$nova_largura = $largura * $proporcao;
$nova_altura = $altura * $proporcao;

// Cria uma nova imagem em branco
$nova_imagem = imagecreatetruecolor( $nova_largura, $nova_altura );

// Copia a imagem para a nova imagem com o novo tamanho
imagecopyresampled(
    $nova_imagem, // Nova imagem 
    $imagem, // Imagem original
    0, // Coordenada X da nova imagem
    0, // Coordenada Y da nova imagem 
    0, // Coordenada X da imagem 
    0, // Coordenada Y da imagem  
    $nova_largura, // Nova largura
    $nova_altura, // Nova altura
    $largura, // Largura original
    $altura // Altura original
);

// Cria a imagem
imagepng( $nova_imagem, 'nova_imagem.png', 1 );

// Remove as imagens temporárias
imagedestroy($imagem);
imagedestroy($nova_imagem);
?>

Pronto! Temos uma imagem PNG redimensionada.

Lembre-se de ler a primeira parte deste tutorial (falando sobre JPG), nela eu detalho todas as etapas do processo.

Redimensionando imagens GIF com PHP

O processo é o mesmo, apenas mudamos duas funções. Ao invés de imagecreatefromjpeg, usaremos imagecreatefromgif e ao invés de  imagejpeg usaremos imagegif.

Observação: GIF não tem o parâmetro qualidade. Outro fato interessante para você saber, é que para GIFs você só terá a primeira imagem, não todas as imagens de uma ação.

Veja o código completo:

<?php
// O caminho da nossa imagem no servidor
$caminho_imagem = 'teste.gif';

// Retorna o identificador da imagem
$imagem = imagecreatefromgif($caminho_imagem);

// Cria duas variáveis com a largura e altura da imagem
list( $largura, $altura ) = getimagesize( $caminho_imagem );

// Nova largura e altura
$proporcao = 0.5;
$nova_largura = $largura * $proporcao;
$nova_altura = $altura * $proporcao;

// Cria uma nova imagem em branco
$nova_imagem = imagecreatetruecolor( $nova_largura, $nova_altura );

// Copia a imagem para a nova imagem com o novo tamanho
imagecopyresampled(
    $nova_imagem, // Nova imagem 
    $imagem, // Imagem original
    0, // Coordenada X da nova imagem
    0, // Coordenada Y da nova imagem 
    0, // Coordenada X da imagem 
    0, // Coordenada Y da imagem  
    $nova_largura, // Nova largura
    $nova_altura, // Nova altura
    $largura, // Largura original
    $altura // Altura original
);

// Cria a imagem
imagegif( $nova_imagem, 'nova_imagem.gif' );

// Remove as imagens temporárias
imagedestroy($imagem);
imagedestroy($nova_imagem);
?>

Pronto, agora temos uma nova imagem GIF redimensionada.

Considerações sobre sobrescrever as imagens

Se você quiser sobrescrever a imagem original para não ficar guardando várias imagens dentro do servidor, basta colocar o mesmo nome da imagem original na última função (que salva a imagem), são elas: imagejpeg, imagepng e imagegif.

Veja nosso último exemplo (gif), porém agora sobrescrevendo a imagem original:

<?php
// O caminho da nossa imagem no servidor
$caminho_imagem = 'teste.gif';

// Retorna o identificador da imagem
$imagem = imagecreatefromgif($caminho_imagem);

// Cria duas variáveis com a largura e altura da imagem
list( $largura, $altura ) = getimagesize( $caminho_imagem );

// Nova largura e altura
$proporcao = 0.5;
$nova_largura = $largura * $proporcao;
$nova_altura = $altura * $proporcao;

// Cria uma nova imagem em branco
$nova_imagem = imagecreatetruecolor( $nova_largura, $nova_altura );

// Copia a imagem para a nova imagem com o novo tamanho
imagecopyresampled(
    $nova_imagem, // Nova imagem 
    $imagem, // Imagem original
    0, // Coordenada X da nova imagem
    0, // Coordenada Y da nova imagem 
    0, // Coordenada X da imagem 
    0, // Coordenada Y da imagem  
    $nova_largura, // Nova largura
    $nova_altura, // Nova altura
    $largura, // Largura original
    $altura // Altura original
);

// Cria a imagem e sobrescreve a original
imagegif( $nova_imagem, $caminho_imagem );

// Remove as imagens temporárias
imagedestroy($imagem);
imagedestroy($nova_imagem);
?>

Mas tome muito cuidado, se você fizer algo errado, não terá como voltar atrás.

Acessando a imagem dinamicamente

Para acessar a imagem, basta acessar o segundo parâmetro das funções: imagejpeg, imagepng ou imagegif.

Veja:

<?php
// O caminho da nossa imagem no servidor
$caminho_imagem = 'teste.gif';

// Retorna o identificador da imagem
$imagem = imagecreatefromgif($caminho_imagem);

// Cria duas variáveis com a largura e altura da imagem
list( $largura, $altura ) = getimagesize( $caminho_imagem );

// Nova largura e altura
$proporcao = 0.5;
$nova_largura = $largura * $proporcao;
$nova_altura = $altura * $proporcao;

// Cria uma nova imagem em branco
$nova_imagem = imagecreatetruecolor( $nova_largura, $nova_altura );

// Copia a imagem para a nova imagem com o novo tamanho
imagecopyresampled(
    $nova_imagem, // Nova imagem 
    $imagem, // Imagem original
    0, // Coordenada X da nova imagem
    0, // Coordenada Y da nova imagem 
    0, // Coordenada X da imagem 
    0, // Coordenada Y da imagem  
    $nova_largura, // Nova largura
    $nova_altura, // Nova altura
    $largura, // Largura original
    $altura // Altura original
);

// Caminho da nova imagem
$caminho_nova_imagem = 'nova_imagem.jpg';

// Cria a imagem e sobrescreve a original
imagegif( $nova_imagem, $caminho_nova_imagem );

// Remove as imagens temporárias
imagedestroy($imagem);
imagedestroy($nova_imagem);

// Mostro a imagem criada na tela
echo '<img src="' . $caminho_nova_imagem . '">';
?>

 Classe para redimensionar imagens com PHP

Para facilitar sua vida, criei uma classe que faz todo o processo de redimensionamento de imagens com PHP para você. Essa classe somente redimensiona imagens em JPG, PNG e GIF.

Veja seu código:

<?php
/**
 * TutsupRedimensionaImagem - Tutsup Redimensiona Imagem
 *
 * Classe para redimensionar imagens.
 */
class TutsupRedimensionaImagem
{

    /*-------------------------------------------------------------------------*
     * Público
    /*------------------------------------------------------------------------*/
    
    /* Configurações públicas referentes à imagem */
    public $imagem, 
           $imagem_destino, 
           $largura, 
           $altura, 
           $qualidade = 75; // Max. 100
    
    // Nosso erro
    public $erro;
    
    /* Extensões permitidas */
    public $extensoes = array ( 'jpg', 'png', 'gif' );

    /*-------------------------------------------------------------------------*
     * Privado
    /*------------------------------------------------------------------------*/

    /* Extensão da imagem enviada */
    private $extensao;
    
    /* Configurações privadas referentes à nova imagem */
    private $r_imagem, 
            $nova_altura, 
            $nova_largura, 
            $largura_original, 
            $altura_original;

    /*-------------------------------------------------------------------------*
     * Métodos Públicos
    /*------------------------------------------------------------------------*/
    
    /**
     * Executa o redimensionamento da imagem
     *
     * @return string|bool O endereço da imagem ou false
     */
    public function executa() { 
        
        /* Captura a extensão da imagem enviada */
        $extensao = strrchr( $this->imagem, '.' );
        
        /* Garante que a extensão terá apenas letras minúsculas */
        $extensao = strtolower( $extensao );
        
        /* Remove o ponto da extensão */
        $extensao = str_replace('.', '', $extensao);
        
        /* 
        Se a extensão enviada não estiver entre as extensões permitidas, 
        preenche o erro e retorna falso
        */
        if ( ! in_array( $extensao, $this->extensoes ) ) {
            $this->erro = 'Arquivo não permitido.';
            return;
        }
        
        /* 
        Se a imagem não existir, preenche o erro e retorna falso
        */
        if ( ! file_exists( $this->imagem ) ) {
            $this->erro = 'Arquivo inexistente.';
            return;
        }
        
        /* Se a extensão for jpg */
        if ( 'jpg' === $extensao ) {
            
            /* Cria uma imagem jpg a partir da imagem enviada */
            $this->r_imagem = imagecreatefromjpeg($this->imagem);
            
            /* Cria a nova imagem com o tamanho correto */
            $imagem_redimensionada = $this->redimensiona();
            
            /* Se a nova imagem não for criada, preenche o erro e retorna */
            if ( ! $imagem_redimensionada ) {
                $this->erro = 'Erro ao redimensionar imagem.';
                return;
            }
            
            /* Copia a nova imagem da imagem antiga com o tamanho correto */
            imagecopyresampled(
                $imagem_redimensionada, 
                $this->r_imagem, 
                0, 
                0, 
                0, 
                0, 
                $this->nova_largura, 
                $this->nova_altura,
                $this->largura_original, 
                $this->altura_original
            
            );
            
            /* 
            Se a imagem de destino não for configurada, vamos exibir a nova 
            imagem na tela 
            */
            if ( ! $this->imagem_destino ) {
                header('Content-type: image/jpg');
            }        
            
            /* Cria a imagem ou exibe na tela */
            imagejpeg ( 
                $imagem_redimensionada, 
                $this->imagem_destino, 
                $this->qualidade 
            );
            
        } /* jpg */
        
        /* Se a extensão for png */
        elseif ( 'png' === $extensao ) {
        
            /* Cria uma imagem png a partir da imagem enviada */
            $this->r_imagem = imagecreatefrompng($this->imagem);
            
            /* Cria a nova imagem com o tamanho correto */
            $imagem_redimensionada = $this->redimensiona();
            
            /* Se a nova imagem não for criada, preenche o erro e retorna */
            if ( ! $imagem_redimensionada ) {
                $this->erro = 'Erro ao redimensionar imagem.';
                return;
            }
            
            /* 
            Se a imagem de destino não for configurada, vamos exibir a nova 
            imagem na tela 
            */
            if ( ! $this->imagem_destino ) {
                header('Content-type: image/png');
            }        
            
            /* Copia a nova imagem da imagem antiga com o tamanho correto */
            imagecopyresampled(
                $imagem_redimensionada, 
                $this->r_imagem, 
                0, 
                0, 
                0, 
                0, 
                $this->nova_largura, 
                $this->nova_altura, 
                $this->largura_original, 
                $this->altura_original
            
            );
            
            /* Para o formato png, a qualidade vai de 0 a 9 */
            $this->qualidade = $this->qualidade / 10;
            $this->qualidade = $this->qualidade > 9 ? 
                               9 : 
                               floor( $this->qualidade );
            
            /* Cria a imagem ou exibe na tela */
            imagepng ( 
                $imagem_redimensionada, 
                $this->imagem_destino, 
                $this->qualidade 
            );
            
        } /* png */
        
        /* Se a extensão for gif */
        elseif ( 'gif' === $extensao ) {
        
            /* Cria uma imagem gif a partir da imagem enviada */
            $this->r_imagem = imagecreatefromgif($this->imagem);
            
            /* Cria a nova imagem com o tamanho correto */
            $imagem_redimensionada = $this->redimensiona();

            /* Se a nova imagem não for criada, preenche o erro e retorna */
            if ( ! $imagem_redimensionada ) {
                $this->erro = 'Erro ao redimensionar imagem.';
                return;
            }
            
            /* 
            Se a imagem de destino não for configurada, vamos exibir a nova 
            imagem na tela 
            */
            if ( ! $this->imagem_destino ) {
                header('Content-type: image/png');
            }        
            
            /* Copia a nova imagem da imagem antiga com o tamanho correto */
            imagecopyresampled(
                $imagem_redimensionada, 
                $this->r_imagem, 
                0, 
                0, 
                0, 
                0, 
                $this->nova_largura, 
                $this->nova_altura, 
                $this->largura_original, 
                $this->altura_original
            
            );
            
            /* Cria a imagem ou exibe na tela */
            imagegif( $imagem_redimensionada, $this->imagem_destino );
            
        } /* gif */
        
        /* Destroy as imagens geradas */
        if ( $imagem_redimensionada ) {
            imagedestroy( $imagem_redimensionada );
        }
        
        if ( $this->r_imagem ) {
            imagedestroy( $this->r_imagem );
        } 
        
        /* Retorna o endereço da imagem */
        return $this->imagem_destino;
        
    } /* executa() */
    
    /*-------------------------------------------------------------------------*
     * Métodos Privados
    /*------------------------------------------------------------------------*/

    /* Cria a nova imagem redimensionada */
    final private function redimensiona() {
    
        /* Se não for resource, termina aqui */
        if( ! is_resource( $this->r_imagem ) ) return;
        
        /* Obtém a largura e altura da imagem */
        list($largura, $altura) = getimagesize( $this->imagem );
        
        /* Configura as propriedades */
        $this->largura_original = $largura;
        $this->altura_original = $altura;
        
        /* Configura a nova largura */
        $this->nova_largura = 
        $this->largura ? $this->largura : 
        floor ( ( $this->largura_original / $this->altura_original ) * 
        $this->altura );
        
        /* Configura a nova altura */
        $this->nova_altura = 
        $this->altura ? $this->altura : 
        floor( ( $this->altura_original / $this->largura_original ) * 
        $this->largura );
        
        /* Retorna a nova imagem criada */
        return imagecreatetruecolor( $this->nova_largura, $this->nova_altura );
        
    } /* redimensiona() */
    
    
} /* TutsupRedimensionaImagem */

Todo o código está comentado acima.

Veja como utilizar nossa classe (ela faz tudo por você, somente é necessário indicar o que deseja que seja feito).

<?php
/* Inclui a classe */
require 'classes/TutsupRedimensionaImagem.php';

/* Cria a instancia da classe */
$imagem = new TutsupRedimensionaImagem();

/* Configura a imagem que vamos redimensionar */
$imagem->imagem = 'imagens/teste.png';

/* 
Configura a imagem de destino. Se você for apenas exibir uma imagem
temporária, comente esta linha
*/
$imagem->imagem_destino = 'arquivos/nova_imagem.png';

/* 
Se uma largura for definida, você pode deixar a classe calcular o aspect 
ratio da imagem deixando a altura zerada. O mesmo vale para a largura, porém,
uma altura deverá existir (uma das duas deve ser definida).

Você também pode configurar as duas, neste caso você força a imagem a ter o 
tamanho desejado
*/
$imagem->largura = 520;

/* A nova altura será gerada automaticamente. */
$imagem->altura = 0;

/* Qualidade de 0 a 100 */
$imagem->qualidade = 100;

/* Gera a nova imagem */
$nova_imagem = $imagem->executa();

/* Se não for uma imagem temporária, você poderá exibi-la assim */
if ( $imagem->imagem_destino && $nova_imagem ) {
    echo "<img src='{$nova_imagem}'>";
}

/* Se você quiser ver se algum erro ocorreu, utilize o seguinte. */
if ( $imagem->erro ) echo $imagem->erro;
?>

 Download da classe para redimensionar imagens com PHP

Você pode baixar essa classe já pronta e com exemplos no link abaixo:

TutsupRedimensionaImagem.zip

Existe um exemplo de utilização já pronto no arquivo index.php.

Caso queira contribuir e ajudar a melhorar essa classe simples, acesso seu código no github.

Concluindo

Conforme eu disse anteriormente, em algum momento do seu código será necessário redimensionar imagens e este artigo vai lhe guiar pelo processo inicial sobre como fazer o serviço.

Mas lembre-se, conhecimento nunca é demais, e há milhares de coisas legais que você pode fazer com a biblioteca GD, incluindo criar suas próprias imagens do zero. Continue ficando fera no PHP seguindo o tutsup.

Te vejo nos próximos tutoriais.