[Resolvido] Criar thumbnails com bitmap's

[GustavoMZ 1]

Eu achei uma função mas não sei usar, ela é meio complicada:

public function redimensiona_bmp($filename){

    $file = fopen( $filename, "rb" );
    $read = fread( $file, 10 );
        
    while( !feof( $file ) && $read != "" ){
        $read .= fread( $file, 1024 );
          }
                    
    $temp = unpack( "H*", $read );
    $hex = $temp[1];
    $header = substr( $hex, 0, 104 );
    $body = str_split( substr( $hex, 108 ), 6 );
        
    if( substr( $header, 0, 4 ) == "424d" ){
        $header = substr( $header, 4 );
        // Remove some stuff?
        $header = substr( $header, 32 );
        // Get the width
        $width = hexdec( substr( $header, 0, 2 ) );
        // Remove some stuff?
        $header = substr( $header, 8 );
        // Get the height
        $height = hexdec( substr( $header, 0, 2 ) );
        unset( $header );
    }
        
    $x = 0;
    $y = 1;
    $image = imagecreatetruecolor( $width, $height );
    foreach( $body as $rgb ){
        $r = hexdec( substr( $rgb, 4, 2 ) );
        $g = hexdec( substr( $rgb, 2, 2 ) );
        $b = hexdec( substr( $rgb, 0, 2 ) );
        $color = imagecolorallocate( $image, $r, $g, $b );
        imagesetpixel( $image, $x, $height-$y, $color );
        $x++;
        if( $x >= $width ){
            $x = 0;
            $y++;
        }
    }
    return $image; //, me parece que a função retorna essa variável com a imagem bmp, mas usei var_dump nela e não mostrou nada na tela 
        
//daqui para baixo é meu código tentando se adaptar a função acima       
        
     $this->img= $image;//variável $image retornada pela função
        
    $x= imagesx($this->img);
    $y= imagesy($this->img);  
    $altura= (int)($y*$this->largura)/$x;
    $this->nova= imagecreatetruecolor($this->largura, $altura);    
     
    imagecopyresampled($this->nova, $this->img, 0,0,0,0, $this->largura, $altura, $x, $y);
    
    imagejpeg($this->nova, $this->pasta.$this->imagem, 100);
     

} 

redimensiona_bmp('fotos/imagem.bmp');
  

Alguém tem uma função melhor? ou alguém pode me ensinar como usar essa function?

 

 

Função original:

http://br.php.net/manual/en/function.imagecreatefromwbmp.php#83119

[Periscuelo 20]

Amigo pelo que pude perceber ele redimensiona seu bmp criando um jpg do mesmo.

 

Não sei se te ajuda mas eu fiz uma classe da qual compartilhei com os amigos do PHPBrasil

onde eu gero thumbnails de jpeg,gif,png e wbmp.

 

Gera Thumbnails By Periscuelo ^_^

A classe está bem simples e tem comentários nas linhas para você entender o que se passa.

Com 4 linhas de código você gera a thumbnail.

Baixa a classe e da uma analisada no teste de exemplo que coloquei junto.

 

O Princípio da classe é gerar um thumbnail da imagem qual foi feita o upload.

Ou seja ela detecta se é PNG, GIF, JPG ou WBMP e gera um thumb no mesmo formato.

 

Veja se te ajuda.

 

Abraços.

[GustavoMZ 1]

Obrigado por compartilhar Periscuelo.

 

Quando a imagem a ser processada é .bmp a função imagecreatefromwbmp() não funciona.

 

Pois .wbmp é um formato de imagem preto e branco para celulares, é diferente de .bmp.

 

Acabei de achar essa classe na terra do tio san:

 

http://phpthumb.sourceforge.net/

 

Agora vou ver se consigo usar :P

[GustavoMZ 1]

http://phpthumb.sourceforge.net/ :o negativo!

 

Estou tentando usar essa função que converte do formato .bmp para gd. Então de gd vai para jpg jpeg png gif:

 

function ConvertBMP2GD($src, $dest = false) {
 if(!($src_f = fopen($src, "rb"))) {
  return false;
 }
 if(!($dest_f = fopen($dest, "wb"))) {
  return false;
 }
 
 $header = unpack("vtype/Vsize/v2reserved/Voffset", fread($src_f,14));
 $info = unpack("Vsize/Vwidth/Vheight/vplanes/vbits/Vcompression/Vimagesize/Vxres/Vyres/Vncolor/Vimportant",
 fread($src_f, 40));

 extract($info);
 extract($header);

 if($type != 0x4D42) { // signature "BM"
  return false;
 }

 $palette_size = $offset - 54;
 $ncolor = $palette_size / 4;
 $gd_header = "";

 // true-color vs. palette
 $gd_header .= ($palette_size == 0) ? "\xFF\xFE" : "\xFF\xFF";
 $gd_header .= pack("n2", $width, $height);
 $gd_header .= ($palette_size == 0) ? "\x01" : "\x00";
 
 if($palette_size) {
  $gd_header .= pack("n", $ncolor);
 }
 // no transparency
 $gd_header .= "\xFF\xFF\xFF\xFF";

 fwrite($dest_f, $gd_header);

 if($palette_size) {
  $palette = fread($src_f, $palette_size);
  $gd_palette = "";
  $j = 0;
  
  while($j < $palette_size) {
   $b = $palette{$j++};
   $g = $palette{$j++};
   $r = $palette{$j++};
   $a = $palette{$j++};
   $gd_palette .= "$r$g$b$a";
  }

  $gd_palette .= str_repeat("\x00\x00\x00\x00", 256 - $ncolor);
  fwrite($dest_f, $gd_palette);
 }

 $scan_line_size = (($bits * $width) + 7) >> 3;
 $scan_line_align = ($scan_line_size & 0x03) ? 4 - ($scan_line_size &0x03) : 0;

 for($i = 0, $l = $height - 1; $i < $height; $i++, $l--) {
  // BMP stores scan lines starting from bottom
  fseek($src_f, $offset + (($scan_line_size + $scan_line_align) *$l));
  $scan_line = fread($src_f, $scan_line_size);
  
  if($bits == 24) {
   $gd_scan_line = "";
   $j = 0;
   while($j < $scan_line_size) {
    $b = $scan_line{$j++};
    $g = $scan_line{$j++};
    $r = $scan_line{$j++};
    $gd_scan_line .= "\x00$r$g$b";
   }
  }
  else if($bits == 8) {
   $gd_scan_line = $scan_line;
  }
  else if($bits == 4) {
   $gd_scan_line = "";
   $j = 0;
   while($j < $scan_line_size) {
    $byte = ord($scan_line{$j++});
    $p1 = chr($byte >> 4);
    $p2 = chr($byte & 0x0F);
    $gd_scan_line .= "$p1$p2";
   } 
   $gd_scan_line = substr($gd_scan_line, 0, $width);
  }
  else if($bits == 1) {
   $gd_scan_line = "";
   $j = 0;
   while($j < $scan_line_size) {
    $byte = ord($scan_line{$j++});
    $p1 = chr((int) (($byte & 0x80) != 0));
    $p2 = chr((int) (($byte & 0x40) != 0));
    $p3 = chr((int) (($byte & 0x20) != 0));
    $p4 = chr((int) (($byte & 0x10) != 0));
    $p5 = chr((int) (($byte & 0x08) != 0));
    $p6 = chr((int) (($byte & 0x04) != 0));
    $p7 = chr((int) (($byte & 0x02) != 0));
    $p8 = chr((int) (($byte & 0x01) != 0));
    $gd_scan_line .= "$p1$p2$p3$p4$p5$p6$p7$p8";
   } 
   
   $gd_scan_line = substr($gd_scan_line, 0, $width);
  }

  fwrite($dest_f, $gd_scan_line);
 }
 fclose($src_f);
 fclose($dest_f);
 return true;
}

function imagecreatefrombmp($filename) {
 $tmp_name = tempnam("/tmp", "GD");
 if(ConvertBMP2GD($filename, $tmp_name)) {
  $img = imagecreatefromgd($tmp_name);
  unlink($tmp_name);
  return $img;
 } return false;
} 

$filename= "foto.bmp";

imagecreatefrombmp($filename);

//imagejpeg($img, "test.jpg");  
//echo '<img src="test.jpg">';

Estudando o código... <_<

[Periscuelo 20]

Amigão, a função que você postou funciona.

 

Acabei de testa-la.

 

Basta mudar este trecho:

 

imagecreatefrombmp($filename);

//imagejpeg($img, "test.jpg");  
//echo '<img src="test.jpg">';

Para:

 

$img = imagecreatefrombmp($filename);

imagejpeg($img, "test.jpg");  
echo '<img src="test.jpg">';

Tendo um arquivo chamado foto.bmp junto ao script ele vai funcionar http://forum.imasters.com.br/public/style_emoticons/default/joia.gif

 

Abraços.

[GustavoMZ 1]

Que bom que funcionou ai, mas aqui retorna o erro:

Warning: imagejpeg(): supplied argument is not a valid Image resource in..

"Argumento fornecido não é um recurso de imagem válido..."

Quer dizer que a função imagecreatefrombmp() não retornou um arquivo válido para a função imagejpeg().

 

Continuo na briga... <_<

 

Consegui, o erro ocorria porque a variável com a imagem final não etava acessível de fora da função, então criei a imagem dentro da função e deu certo.

 

A qualidade da imagem gerada é meio ruim, mas para thumbnails está ótimo.

 

Para quem precisar ai vai o script funcionando:

 

<?php 
function ConvertBMP2GD($src, $dest = false) {

 
//-1-----Abre o arquivo para leitura e escrita-----------\\
 if(!($src_f = fopen($src, "rb"))) {
  echo "O arquivo não abriu para leitura";
	return false;
 }
 if(!($dest_f = fopen($dest, "wb"))) {
 	echo "O arquivo não abriu para escrita";
  return false;
 }
//--------------------------------------------------------\\


//-2-----Com o arquivo aberto joga os dados do mesmo em arrays-----------\\ 
 $header = unpack("vtype/Vsize/v2reserved/Voffset", fread($src_f,14));
 $info = unpack("Vsize/Vwidth/Vheight/vplanes/vbits/Vcompression/Vimagesize/Vxres/Vyres/Vncolor/Vimportant", fread($src_f, 40));
//--------------------------------------------------------\\


//-3-----Pega os arrays e joga em variáveis-----------\\ 
 extract($info);
 extract($header);
//debugando...
//  print_r($info);//Retorna isso: Array ( [size] => 40 [width] => 808 [height] => 559 [planes] => 1 [bits] => 24 [compression] => 0 [imagesize] => 1355016 [xres] => 3780 [yres] => 3780 [ncolor] => 0 [important] => 0 )
//  echo "<br />------------------------------------------<br />";
//  print_r($header);//Retorna isso: Array ( [type] => 19778 [size] => 1355070 [reserved1] => 0 [reserved2] => 0 [offset] => 54 ) 
//Esses dados retornados no degub são do arquivo foto.bmp que eu passei para a função imagecreatefrombmp();
//--------------------------------------------------------\\


//-4-----Verifica a variável $type que veio do extract() acima-----------\\
 if($type != 0x4D42) { // assinatura "BM"
  echo "I am here!!!!";//debugando... não entra aqui. significa que $type é igual a 0x4D42. Mas no debug type tem um valor diferente: [type] => 19778. Porque será?
  return false;
 }
//--------------------------------------------------------\\




//-5-----A partir daqui já existem as variáveis com as informações da imagem .bmp, então ele (o código) trabalha com essas variáveis e com a paleta de cores RGB para criar uma nova imagem na memória-----------\\
 $palette_size = $offset - 54;
 $ncolor = $palette_size / 4;
 $gd_header = "";

 // true-color vs. paleta
 $gd_header .= ($palette_size == 0) ? "\xFF\xFE" : "\xFF\xFF";
 $gd_header .= pack("n2", $width, $height);
 $gd_header .= ($palette_size == 0) ? "\x01" : "\x00";
 
 if($palette_size) {
  $gd_header .= pack("n", $ncolor);
 }
 // no transparency
 $gd_header .= "\xFF\xFF\xFF\xFF";

 fwrite($dest_f, $gd_header);

 if($palette_size) {
  $palette = fread($src_f, $palette_size);//lê o arquivo para uma string
  $gd_palette = "";
  $j = 0;
  
  while($j < $palette_size) {//contrói a paleta de cores RGB
   $b = $palette{$j++};
   $g = $palette{$j++};
   $r = $palette{$j++};
   $a = $palette{$j++};
   $gd_palette .= "$r$g$b$a";
  }

  $gd_palette .= str_repeat("\x00\x00\x00\x00", 256 - $ncolor);
  fwrite($dest_f, $gd_palette);
 }//Fecha o if

 $scan_line_size = (($bits * $width) + 7) >> 3;
 $scan_line_align = ($scan_line_size & 0x03) ? 4 - ($scan_line_size &0x03) : 0;

 for($i = 0, $l = $height - 1; $i < $height; $i++, $l--) {
  // BMP stores scan lines starting from bottom
  fseek($src_f, $offset + (($scan_line_size + $scan_line_align) *$l));
  $scan_line = fread($src_f, $scan_line_size);
  
  if($bits == 24) {
   $gd_scan_line = "";
   $j = 0;
   while($j < $scan_line_size) {
    $b = $scan_line{$j++};
    $g = $scan_line{$j++};
    $r = $scan_line{$j++};
    $gd_scan_line .= "\x00$r$g$b";
   }
  }
  else if($bits == 8) {
   $gd_scan_line = $scan_line;
  }
  else if($bits == 4) {
   $gd_scan_line = "";
   $j = 0;
   while($j < $scan_line_size) {
    $byte = ord($scan_line{$j++});
    $p1 = chr($byte >> 4);
    $p2 = chr($byte & 0x0F);
    $gd_scan_line .= "$p1$p2";
   } 
   $gd_scan_line = substr($gd_scan_line, 0, $width);
  }
  else if($bits == 1) {
   $gd_scan_line = "";
   $j = 0;
   while($j < $scan_line_size) {
    $byte = ord($scan_line{$j++});
    $p1 = chr((int) (($byte & 0x80) != 0));
    $p2 = chr((int) (($byte & 0x40) != 0));
    $p3 = chr((int) (($byte & 0x20) != 0));
    $p4 = chr((int) (($byte & 0x10) != 0));
    $p5 = chr((int) (($byte & 0x08) != 0));
    $p6 = chr((int) (($byte & 0x04) != 0));
    $p7 = chr((int) (($byte & 0x02) != 0));
    $p8 = chr((int) (($byte & 0x01) != 0));
    $gd_scan_line .= "$p1$p2$p3$p4$p5$p6$p7$p8";
   } 
   
   $gd_scan_line = substr($gd_scan_line, 0, $width);
  }

  fwrite($dest_f, $gd_scan_line);
 }
 fclose($src_f);
 fclose($dest_f);
 return true;
}
//- - - - - - - - - - - - - - - - - - - -Termina a função principal: aqui a imagem já está na memória - - - - - - - - - - - - - - - - - - - - - - - - - - - \\




//- - - - - Função que chama a função principal- - - - - \\
function imagecreatefrombmp($filename) {
 $tmp_name = tempnam("/tmp", "GD");
 ConvertBMP2GD($filename, $tmp_name);//chamada da função principal
 $img = imagecreatefromgd($tmp_name);//Pega a imagem da memória criada pela função principal e cria uma imagem GD.
 unlink($tmp_name);  
 imagejpeg($img, "fotos/miniaturas/test.jpg");//Fim: aqui apenas pega a imagem GD como parâmetro para criar uma imagem jpg, mas pode ser outro formato como gif, png, etc...
} 
//- - - - - - - - - - - - - - - - - - \\




//- - - - - Chama a função - - - - - \\
imagecreatefrombmp("foto.bmp");
//- - - - - - - - - - - - - - - - - - \\


  
echo '<img src="fotos/miniaturas/test.jpg">';//Mostra a imagem que passou de .bmp para .jpg, agora é só redimensionar para criar o thumbnail.
?>

Créditos para o criador do script:

http://excellent-coder.blogspot.com

[Periscuelo 20]

Graças a sua dúvida eu implementei o BMP a minha classe também.

 

Caso ache interessante o código já esta disponível no PHPBrasil.

 

Abraços.

[GustavoMZ 1]

É isso ai Periscuelo! sua classe ficou excelente! parabéns!

 

 

Mais um leão morto, pode marcar o tópico como resolvido :P