Salvar Imagem depois de alterar o tamanho

Consegui o script abaixo para diminuir o tamanho da imagem, gostaria de saber como faço pra salvar esta nova imagem em outro diretorio?


<?php
//Script modificado por Luciano Vieira

function imagemProd($tam, $dir, $foto){

$imageSize = GetImageSize ($dir."/".$foto);
$img_w = $imageSize[0];
$img_h = $imageSize[1];
$calc= $tam*100/$img_w;

$thumb_w = $tam;
$thumb_h = $img_h*$calc/100;

echo '<img border="0" src="'.$dir."/".$foto.'"width="'. $thumb_w.'" height="'.$thumb_h.'">';
}
?>
<?php imagemProd("T","D","F");

//T = Tamanho da foto. Ex (150 pixels coloque somente 150)
//D = Diretório que está a foto. Ex (imagens/foto)
//F = Nome da foto com estenção. Ex (carro.jpg) ?>

Meu tenho um script pronto que faz isso, precisa apenas passar os dados certos como parâmetro.

Ele faz o resize utilizando o tamanho da largura, e calcula a altura automático.

Modo de utilizar:
<?
$cur_dir -> Diretório atual,
$cur_file -> imagem,
$newwidth -> tamanho a redimencionar
$output_dir -> Diretório de Saída;
resize($cur_dir, $cur_file, $newwidth, $output_dir)

resize('galeria_fotos/'.$hash, $filename, 78, 'galeria_fotos/'.$hash.'/thumbs/');
?>

<?php
function resize($cur_dir, $cur_file, $newwidth, $output_dir)
{
$dir_name = $cur_dir;
$olddir = getcwd();
$dir = opendir($dir_name);
$filename = $dir_name.'/'.$cur_file;
$format='';
if(preg_match("/.jpg/i", "$filename"))
{
$format = 'image/jpeg';
}
if (preg_match("/.gif/i", "$filename"))
{
$format = 'image/gif';
}
if(preg_match("/.png/i", "$filename"))
{
$format = 'image/png';
}
if($format!='')
{
list($width, $height) = getimagesize($filename);
$newheight=$height*$newwidth/$width;
switch($format)
{
case 'image/jpeg':
$source = imagecreatefromjpeg($filename);
break;
case 'image/gif';
$source = imagecreatefromgif($filename);
break;
case 'image/png':
$source = imagecreatefrompng($filename);
break;
}
$thumb = imagecreatetruecolor($newwidth,$newheight);
imagealphablending($thumb, false);
$source = @imagecreatefromjpeg($filename);
imagecopyresized($thumb, $source, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);
$filename=$output_dir.$cur_file;
imagejpeg($thumb, $filename);
}
}
?>

Att

Tulio Ribeiro

Pequena correção no script do Tulio:

Ao invés de usar a expressão regular:
if(preg_match("/.jpg/i", "$filename")) {

Usar essa:
if (preg_match('/\.jpg$/i', $filename)) {

Pois o "." representa "qualquer símbolo", logo, é preciso escapá-lo para representar "ponto final". Além disso, usar o "$" para indicar final da string.

A expressão anterior casava as strings "xjpg" ou "xjpgx".

Usar a definição de tipo de imagem pelo nome de arquivo por si só já é uma falha.
O correto é usar a definição pelo tipo mime.
Como é uma postagem de meses atrás...

Marcos, detectar com o mime-type é útil (ou, melhor, necessário) para assegurar que o arquivo recebido por upload realmente é do tipo esperado e é condizente com a extensão utilizada.

Porém, no script postado, o arquivo já existe em algum lugar e o Valdenir queria apenas redimensioná-lo. Para usar a extensão GD, foi necessário detectar o tipo de arquivo. Eu acho útil usar a extensão do arquivo se este arquivo já passou por uma checagem de mime-type anterior (por exemplo, no momento do upload) e não sofreu alterações no conteúdo ou no nome. Afinal, verificar o mime-type de um arquivo é um trabalho custoso e, a meu ver, com muitas restrições, já que usa "mágica".

Neste sentido, você não acha que usar o preg_match para pegar a extensão já não seria suficiente? Considerando que a extensão foi verificada e validada em conjunto com o mime-type no momento do upload, por exemplo.

Não estou questionando o fato de que checar o mime-type seja mais seguro, apenas questionando que, em algumas situações, pegar a extensão do arquivo não é "por si só" uma falha.

Uma alternativa boa é guardar o mime-type no BD, por exemplo. Assim não precisa checá-lo toda vez que for fazer alguma coisa com o arquivo.

Bom, em todo caso, o script do Tulio também poderia ser modificado para que, ao invés de criar o resource com as funções imagecreatefromXXX, usasse o imagecreatefromstring, que recebe a imagem no formato binário. Esta função leva em conta o conteúdo do arquivo (logo, o mime-type), mas, por sorte, não precisa conferir tantos mime-types (apenas aqueles suportados pela GD).

O código final fica bem mais simples, inclusive:

function resize($arquivo, $nova_largura) {
$img = imagecreatefromstring(file_get_contents($arquivo));
$largura = imagesx($img);
$altura = imagesy($img);
$nova_altura = $altura * $nova_largura / $largura;
$nova_img = imagecreatetruecolor($nova_largura, $nova_altura);
imagealphablending($nova_img, false);
imagecopyresized($nova_img, $img, 0, 0, 0, 0, $nova_largura, $nova_altura, $largura, $altura);
imagejpeg($nova_img, $arquivo);
}

Se bem que a função do Tulio tinha um problema: gerava a imagem redimensionada sempre em JPEG, mas mantinha o nome do arquivo.

Como a função imagecreatefromstring não devolve o tipo de arquivo lido, então recairia sobre o mesmo problema de precisar checar o tipo, só que agora pra salvar a nova imagem.

function resize($arquivo, $nova_largura) {
____$img = imagecreatefromstring(file_get_contents($arquivo));
____$largura = imagesx($img);
____$altura = imagesy($img);
____$nova_altura = $altura * $nova_largura / $largura;
____$nova_img = imagecreatetruecolor($nova_largura, $nova_altura);
____imagealphablending($nova_img, false);
____imagecopyresized($nova_img, $img, 0, 0, 0, 0, $nova_largura, $nova_altura, $largura, $altura);
____imagedestroy($img);

____preg_match('/\.([^\.]+)$/i', $arquivo, $matches);
____switch (strtolower($matches[1])) {
____case 'bmp':
________imagewbmp($nova_img, $arquivo);
________break;
____case 'gif':
________imagegif($nova_img, $arquivo);
________break;
____case 'jpg':
________imagejpeg($nova_img, $arquivo);
________break;
____case 'png':
________imagepng($nova_img, $arquivo);
________break;
____case 'xbm':
________imagepng($nova_img, $arquivo);
________break;
____}
____imagedestroy($nova_img);
}

Poxa, que inconveniente né... Acho que a GD podia ter uma função de output genérico, onde seria passado o resource, a constante do tipo de imagem desejado e o nome do arquivo de destino. Daí a função imagecreatefromstring devolvia o tipo lido e facilitaria a vida.

Resumindo... Melhor sempre checar o tipo mime. É mais seguro e evita bugs bobos.