Nenhum produto encontrado nessa seleção.
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
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:
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.
