[Resolvido] Classe Canvas - Colando uma imagem na outra

Daniel-Lopes · Julho 1, 2011

Pessoal peguei uma classe de tratamento de imagens muito boa. mas detectei um problema.

quando usava o redimensionamento com preechimento, ou seja:

tenho uma imagem 640 x480

quero redimensiona-la para 240 x 240

so que não a quero distorcida, então a classe deveria pegar a imagem 640 X 480 e redimensiona-la para para caber dentro de uma outra imagem criada no PHP com o fundo escolhido por mim

o problema da classe era que em vez de encaixar a uma imagem dentro da outra ela cortava parte da imagem original então eu modifiquei a classe para que fizesse o que fosse correto primeiramente redimensionava a imagem e depois para que a mesma coubesse dentro do tamanho estipulado tanto na altura quanto na largura

so que quando eu vou criar o tamanho final e vou colocar a imagem centralizada dentro da imagem criada no php a parte de cima fica na cor escolhida mas na parte de baixo fica preto.

vejam a classe se alguem souber o motivo e puder me ajudar ficaria muito grato.

o erro ocorre nesta parte da classe foi onde eu modifiquei


private function redimensionaPreenchimento()
    {
         // cria imagem de destino temporária
         $this->img_temp = imagecreatetruecolor( $this->nova_largura, $this->nova_altura );

         // adiciona cor de fundo à nova imagem
         $this->preencheImagem();

         // salva variáveis para centralização
         $dif_x = $dif_w = $this->nova_largura;
         $dif_y = $dif_h = $this->nova_altura;

         	//Calcula a porcentagem para verificar se usa a porcentagem de altura ou largura para que
		//toda imagem seja incluida no preenchimento
		$porcentagem_w = ($this->nova_largura)/$this->largura;
		$porcentagem_h = ($this->nova_altura)/$this->altura;

		if($porcentagem_w < $porcentagem_h){
			$novo_t_w = floor($this->largura * $porcentagem_w);
			$novo_t_h = floor($this->altura * $porcentagem_w);
		}else{
			$novo_t_w = floor($this->largura * $porcentagem_h);
			$novo_t_h = floor($this->altura * $porcentagem_h);
		}

		//diminui a imagem original para que ela se enchaixe no tamanho definido sem ser cordada
		$img_novo_tamanho = imagecreatetruecolor( $novo_t_w, $novo_t_h );
		imagecopyresampled( $img_novo_tamanho, $this->img, 0, 0, 0, 0, $novo_t_w, $novo_t_h, $this->largura, $this->altura );
		 $this->img     =  $img_novo_tamanho;


		// copia com o novo tamanho, centralizando
		$pos_x =  floor(($this->nova_largura - $novo_t_w)/2);
		$pos_y =  floor(($this->nova_altura - $novo_t_h)/2);

		imagecopymerge( 
							$this->img_temp,
							$img_novo_tamanho,
							$pos_x,
							$pos_y,
							0,
							0,
							$novo_t_w,
							$novo_t_w,
							100);
		$this->img     = $this->img_temp;

    } // fim redimensionaPreenchimento()

<?php
/**
*
* Classe para manipulação de imagens utilizando a extensão GD
* e recursos avançados de filtros. Requer PHP 5 ou superior.
*
* @author     Davi Ferreira <contato@daviferreira.com>
* @version    1.0 $ 2010-10-17 19:11:51 $
*/

class canvas {

   /**
    * Variáveis para armazenamento de arquivos/imgs
    **/
   private $origem, $img, $img_temp;

   /**
    * Armazenam as dimensões da imagem atual e da nova imagem caso exista
    **/
   private $largura, $altura, $nova_largura, $nova_altura, $tamanho_html;

   /**
    * Informações sobre o arquivo enviado e diretório
    **/
   private $formato, $extensao, $tamanho, $arquivo, $diretorio;

   /**
    * Array RGB para resize com preenchimendo do fundo
    **/
   private $rgb;

   /**
    * Coordenadas para posicionamento do crop
    **/
   private $posicao_crop;

   /**
    * Construtor
    * @param $string caminho da imagem a ser carregada [opcional]
    * @return void
    **/
    public function __construct( $origem = '' )
    {

         $this->origem = $origem;

         if ( $this->origem )
         {
              $this->dados();
         }

         // RGB padrão -> branco
    $this->rgb( 255, 255, 255 );
    } // fim construtor

    /**
     * Retorna dados da imagem
     * @return void
     **/
    private function dados()
    {

         // verifica se imagem existe
         if ( is_file( $this->origem ) )
         {

              // dados do arquivo
              $this->dadosArquivo();

              // verifica se é imagem
              if ( !$this->eImagem() )
              {
                   trigger_error( 'Erro: Arquivo '.$this->origem.' não é uma imagem!', E_USER_ERROR );
              }
              else
              {
                   // busca dimensões da imagem enviada
                   $this->dimensoes();

                   // cria imagem para php
                   $this->criaImagem();
              }
         }
         else
         {
              trigger_error( 'Erro: Arquivo de imagem não encontrado!', E_USER_ERROR );
         }

    } // fim dadosImagem

    /**
     * Carrega uma nova imagem, fora do construtor
     * @param String caminho da imagem a ser carregada
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function carrega( $origem = '' )
    {
         $this->origem = $origem;
         $this->dados();
         return $this;
    } // fim carrega

    /**
     * Busca dimensões e formato real da imagem
     * @return void
     **/
    private function dimensoes()
    {
   $dimensoes                  = getimagesize( $this->origem );
   $this->largura              = $dimensoes[0];
   $this->altura               = $dimensoes[1];
   /**
   * 1 = gif, 2 = jpeg, 3 = png, 6 = BMP
   * http://br2.php.net/manual/en/function.exif-imagetype.php
   **/
   $this->formato               = $dimensoes[2];
   $this->tamanho_html          = $dimensoes[3];
    } // fim dimensoes

    /**
     * Busca dados do arquivo
     * @return void
     **/
    private function dadosArquivo()
    {
         // imagem de origem
         $pathinfo            = pathinfo( $this->origem );
         $this->extensao      = strtolower( $pathinfo['extension'] );
         $this->arquivo       = $pathinfo['basename'];
         $this->diretorio     = $pathinfo['dirname'];
    } // fim dadosArquivo

    /**
     * Verifica se o arquivo indicado é uma imagem
     * @return Boolean true/false
     **/
    private function eImagem()
    {
         // filtra extensão
         $valida = getimagesize( $this->origem );
         if ( !is_array( $valida ) || empty( $valida ) )
         {
              return false;
         }
         else
         {
              return true;
         }
    } // fim validaImagem

    /**
     * Cria uma nova imagem para ser trabalhada com textos, etc.
     * OBS: a cor da imagem deve ser passada antes, via rgb() ou hex()
     * @param String $largura da imagem a ser criada
     * @param String $altura da imagem a ser criada
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function novaImagem( $largura, $altura )
    {
         $this->largura     = $largura;
         $this->altura     = $altura;
         $this->img = imagecreatetruecolor( $this->largura, $this->altura );
         $cor_fundo = imagecolorallocate( $this->img, $this->rgb[0], $this->rgb[1], $this->rgb[2] );
         imagefill( $this->img, 0, 0, $cor_fundo );
         $this->extensao = 'jpg';
         return $this;
   } // fim novaImagem

   /**
    * Carrega uma imagem via URL
    * OBS: depente das configurações do servidor para acesso remoto de arquivos
    * @param String $url endereço da imagem
     * @return Object instância atual do objeto, para métodos encadeados
    **/
    public function carregaUrl( $url )
    {
         $this->origem = $url;
         $pathinfo = pathinfo( $this->origem );
         $this->extensao = strtolower( $pathinfo['extension'] );
         switch( $this->extensao )
         {
              case 'jpg':
              case 'jpeg':
                   $this->formato = 2;
                   break;
              case 'gif':
                   $this->formato = 1;
                   break;
              case 'png':
                   $this->formato = 3;
                   break;
              case 'bmp':
                   $this->formato = 6;
                   break;
              default:
                   break;
    }
         $this->criaImagem();
    $this->largura     = imagesx( $this->img );
         $this->altura     = imagesy( $this->img );
         return $this;
    } // fim carregaUrl

    /**
     * Cria objeto de imagem para manipulação no GD
     * @return void
     **/
    private function criaImagem()
    {
         switch ( $this->formato )
         {
              case 1:
                   $this->img = imagecreatefromgif( $this->origem );
                   $this->extensao = 'gif';
                   break;
              case 2:
                   $this->img = imagecreatefromjpeg( $this->origem );
                   $this->extensao = 'jpg';
                   break;
              case 3:
                   $this->img = imagecreatefrompng( $this->origem );
                   $this->extensao = 'png';
                   break;
              case 6:
                   $this->img = imagecreatefrombmp( $this->origem );
                   $this->extensao = 'bmp';
                   break;
              default:
                   trigger_error( 'Arquivo inválido!', E_USER_ERROR );
                   break;
         }
    } // fim criaImagem

    /**
     * Armazena os valores RGB para redimensionamento com preenchimento
     * @param Valores R, G e B
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function rgb( $r, $g, $b )
    {
         $this->rgb = array( $r, $g, $b );
         return $this;
    } // fim rgb

    /**
     * Converte hexadecimal para RGB
     * @param String $cor cor hexadecimal
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function hexa( $cor )
    {
         $cor = str_replace( '#', '', $cor );

         if( strlen( $cor ) == 3 ) $cor .= $cor; // #fff, #000 etc.

         $this->rgb = array(
           hexdec( substr( $cor, 0, 2 ) ),
           hexdec( substr( $cor, 2, 2 ) ),
           hexdec( substr( $cor, 4, 2 ) ),
         );
         return $this;
    }  // fim hexa

    /**
     * Armazena posições x e y para crop
     * @param Array valores x e y
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function posicaoCrop( $x, $y )
    {
         $this->posicao_crop = array( $x, $y, $this->largura, $this->altura );
         return $this;
    } // fim posicao_crop

    /**
     * Redimensiona imagem
     * @param Int $nova_largura valor em pixels da nova largura da imagem
     * @param Int $nova_altura valor em pixels da nova altura da imagem
     * @param String $tipo método para redimensionamento (padrão [vazio], preenchimento ou crop)
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function redimensiona( $nova_largura = 0, $nova_altura = 0, $tipo = '' )
    {

         // seta variáveis passadas via parâmetro
         $this->nova_largura          = $nova_largura;
         $this->nova_altura          = $nova_altura;

         // verifica se passou altura ou largura como porcentagem
         // largura %
         $pos = strpos( $this->nova_largura, '%' );
         if( $pos !== false && $pos > 0 )
         {
              $porcentagem               = ( ( int ) str_replace( '%', '', $this->nova_largura ) ) / 100;
              $this->nova_largura          = round( $this->largura * $porcentagem );
         }
         // altura %
         $pos = strpos( $this->nova_altura, '%' );
         if( $pos !== false && $pos > 0 )
         {
              $porcentagem               = ( ( int ) str_replace( '%', '', $this->nova_altura ) ) / 100;
              $this->nova_altura          = $this->altura * $porcentagem;
         }

         // define se só passou nova largura ou altura
         if ( !$this->nova_largura && !$this->nova_altura )
         {
              return false;
         }
         // só passou altura
         elseif ( !$this->nova_largura )
         {
              $this->nova_largura = $this->largura / ( $this->altura/$this->nova_altura );
         }
         // só passou largura
         elseif ( !$this->nova_altura )
         {
              $this->nova_altura = $this->altura / ( $this->largura/$this->nova_largura );
         }

         // redimensiona de acordo com tipo
         switch( $tipo )
         {
              case 'crop':
                   $this->redimensionaCrop();
                   break;
              case 'preenchimento':
                   $this->redimensionaPreenchimento();
                   break;
              default:
                   $this->redimensionaSimples();
                   break;
         }

         // atualiza dimensões da imagem
         $this->altura     = $this->nova_altura;
         $this->largura     = $this->nova_largura;

         return $this;
    } // fim redimensiona

    /**
     * Redimensiona imagem, modo padrão, sem crop ou preenchimento
     * (distorcendo caso tenha passado ambos altura e largura)
     * @return void
     **/
    private function redimensionaSimples()
    {
         // cria imagem de destino temporária
         $this->img_temp = imagecreatetruecolor( $this->nova_largura, $this->nova_altura );

         imagecopyresampled( $this->img_temp, $this->img, 0, 0, 0, 0, $this->nova_largura, $this->nova_altura, $this->largura, $this->altura );
         $this->img     = $this->img_temp;
    } // fim redimensiona()

    /**
     * Adiciona cor de fundo à imagem
     * @return void
     **/
    private function preencheImagem()
    {
         $cor_fundo = imagecolorallocate( $this->img_temp, $this->rgb[0], $this->rgb[1], $this->rgb[2] );
         imagefill( $this->img_temp, 0, 0, $cor_fundo );
    } // fim preencheImagem

    /**
     * Redimensiona imagem sem cropar, proporcionalmente,
     * preenchendo espaço vazio com cor rgb especificada
     * @return void
     **/
    private function redimensionaPreenchimento()
    {
         // cria imagem de destino temporária
         $this->img_temp = imagecreatetruecolor( $this->nova_largura, $this->nova_altura );

         // adiciona cor de fundo à nova imagem
         $this->preencheImagem();

         // salva variáveis para centralização
         $dif_x = $dif_w = $this->nova_largura;
         $dif_y = $dif_h = $this->nova_altura;

         	//Calcula a porcentagem para verificar se usa a porcentagem de altura ou largura para que
		//toda imagem seja incluida no preenchimento
		$porcentagem_w = ($this->nova_largura)/$this->largura;
		$porcentagem_h = ($this->nova_altura)/$this->altura;

		if($porcentagem_w < $porcentagem_h){
			$novo_t_w = floor($this->largura * $porcentagem_w);
			$novo_t_h = floor($this->altura * $porcentagem_w);
		}else{
			$novo_t_w = floor($this->largura * $porcentagem_h);
			$novo_t_h = floor($this->altura * $porcentagem_h);
		}

		//diminui a imagem original para que ela se enchaixe no tamanho definido sem ser cordada
		$img_novo_tamanho = imagecreatetruecolor( $novo_t_w, $novo_t_h );
		imagecopyresampled( $img_novo_tamanho, $this->img, 0, 0, 0, 0, $novo_t_w, $novo_t_h, $this->largura, $this->altura );
		 $this->img     =  $img_novo_tamanho;


		// copia com o novo tamanho, centralizando
		$pos_x =  floor(($this->nova_largura - $novo_t_w)/2);
		$pos_y =  floor(($this->nova_altura - $novo_t_h)/2);

		imagecopymerge( 
							$this->img_temp,
							$img_novo_tamanho,
							$pos_x,
							$pos_y,
							0,
							0,
							$novo_t_w,
							$novo_t_w,
							100);
		$this->img     = $this->img_temp;

    } // fim redimensionaPreenchimento()

    /**
     * Calcula a posição do crop
     * Os índices 0 e 1 correspondem à posição x e y do crop na imagem
     * Os índices 2 e 3 correspondem ao tamanho do crop
     * @return void
     **/
    private function calculaPosicaoCrop()
    {
         // média altura/largura
         $hm     = $this->altura / $this->nova_altura;
         $wm     = $this->largura / $this->nova_largura;

         // 50% para cálculo do crop
         $h_height = $this->nova_altura / 2;
         $h_width  = $this->nova_largura / 2;

         // calcula novas largura e altura
         if( !is_array( $this->posicao_crop ) )
         {
              if ( $wm > $hm )
              {
                   $this->posicao_crop[2]     = $this->largura / $hm;
                   $this->posicao_crop[3]     = $this->nova_altura;
                   $this->posicao_crop[0]     = ( $this->posicao_crop[2] / 2 ) - $h_width;
                   $this->posicao_crop[1]     = 0;
              }
              // largura <= altura
              elseif ( ( $wm <= $hm ) )
              {
                   $this->posicao_crop[2]     = $this->nova_largura;
                   $this->posicao_crop[3]     = $this->altura / $wm;
                   $this->posicao_crop[0]     = 0;
                   $this->posicao_crop[1]     = ( $this->posicao_crop[3] / 2 ) - $h_height;
              }
         }
    } // fim calculaPosicaoCrop

    /**
     * Redimensiona imagem, cropando para encaixar no novo tamanho, sem sobras
     * baseado no script original de Noah Winecoff
     * http://www.findmotive.com/2006/12/13/php-crop-image/
     * atualizado para receber o posicionamento X e Y do crop na imagem
     * @return void
     **/
    private function redimensionaCrop()
    {
         // calcula posicionamento do crop
         $this->calculaPosicaoCrop();

         // cria imagem de destino temporária
         $this->img_temp = imagecreatetruecolor( $this->nova_largura, $this->nova_altura );

         // adiciona cor de fundo à nova imagem
         $this->preencheImagem();

         imagecopyresampled( $this->img_temp, $this->img, -$this->posicao_crop[0], -$this->posicao_crop[1], 0, 0, $this->posicao_crop[2], $this->posicao_crop[3], $this->largura, $this->altura );

         $this->img     = $this->img_temp;
    } // fim redimensionaCrop

    /**
     * flipa/inverte imagem
     * baseado no script original de Noah Winecoff
     * http://www.php.net/manual/en/ref.image.php#62029
     * @param String $tipo tipo de espelhamento: h - horizontal, v - vertical
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function flip( $tipo = 'h' )
    {
         $w = imagesx( $this->img );
         $h = imagesy( $this->img );

         $this->img_temp = imagecreatetruecolor( $w, $h );

         // vertical
         if ( 'v' == $tipo )
         {
              for ( $y = 0; $y < $h; $y++ )
              {
                   imagecopy( $this->img_temp, $this->img, 0, $y, 0, $h - $y - 1, $w, 1 );
              }
         }
         // horizontal
         elseif ( 'h' == $tipo )
         {
              for ( $x = 0; $x < $w; $x++ )
              {
                   imagecopy( $this->img_temp, $this->img, $x, 0, $w - $x - 1, 0, 1, $h );
              }
         }

         $this->img     = $this->img_temp;

         return $this;
    } // fim flip

    /**
     * gira imagem
     * @param Int $graus grau para giro
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function gira( $graus )
    {
         $cor_fundo     = imagecolorallocate( $this->img, $this->rgb[0], $this->rgb[1], $this->rgb[2] );
         $this->img     = imagerotate( $this->img, $graus, $cor_fundo );
         imagealphablending( $this->img, true );
         imagesavealpha( $this->img, true );
         $this->largura = imagesx( $this->img );
         $this->altura = imagesx( $this->img );
         return $this;
    } // fim girar

    /**
     * adiciona texto à imagem
     * @param String $texto texto a ser inserido
     * @param Int $tamanho tamanho da fonte
     *            Ver: http://br2.php.net/imagestring
     * @param Int $x posição x do texto na imagem
     * @param Int $y posição y do texto na imagem
     * @param Array/String $cor_fundo array com cores RGB ou string com cor hexadecimal
     * @param Boolean $truetype true para utilizar fonte truetype, false para fonte do sistema
     * @param String $fonte nome da fonte truetype a ser utilizada
     * @return void
     **/
    public function legenda( $texto, $tamanho = 5, $x = 0, $y = 0, $cor_fundo = '', $truetype = false, $fonte = '' )
    {
         $cor_texto = imagecolorallocate( $this->img, $this->rgb[0], $this->rgb[1], $this->rgb[2] );

         /**
          * Define tamanho da legenda para posições fixas e fundo da legenda
          **/
         if( $truetype  === true )
         {
              $dimensoes_texto     = imagettfbbox( $tamanho, 0, $fonte, $texto );
              $largura_texto          = $dimensoes_texto[4];
              $altura_texto          = $tamanho;
         }
         else
         {
              if( $tamanho > 5 ) $tamanho = 5;
              $largura_texto     = imagefontwidth( $tamanho ) * strlen( $texto );
              $altura_texto     = imagefontheight( $tamanho );
         }

         if( is_string( $x ) && is_string( $y ) )
         {
              list( $x, $y ) = $this->calculaPosicaoLegenda( $x . '_' . $y, $largura_texto, $altura_texto );
         }

         /**
          * Cria uma nova imagem para usar de fundo da legenda
          **/
         if( $cor_fundo )
         {
              if( is_array( $cor_fundo ) )
              {
                   $this->rgb = $cor_fundo;
              }
              elseif( strlen( $cor_fundo ) > 3 )
              {
                   $this->hexa( $cor_fundo );
              }

              $this->img_temp = imagecreatetruecolor( $largura_texto, $altura_texto );
              $cor_fundo = imagecolorallocate( $this->img_temp, $this->rgb[0], $this->rgb[1], $this->rgb[2] );
              imagefill( $this->img_temp, 0, 0, $cor_fundo );

              imagecopy( $this->img, $this->img_temp, $x, $y, 0, 0, $largura_texto, $altura_texto );
         }

         // truetype ou fonte do sistema?
         if ( $truetype === true )
         {
              $y = $y + $tamanho;
              imagettftext( $this->img, $tamanho, 0, $x, $y, $cor_texto, $fonte, $texto );
         }
         else
         {
              imagestring( $this->img, $tamanho, $x, $y, $texto, $cor_texto );
         }
         return $this;
    } // fim legenda

   /**
    * Calcula a posição da legenda de acordo com string passada via parâmetro
    *
    * @param String $posicao valores pré-definidos (topo_esquerda, meio_centro etc.)
    * @param Integer $largura largura da imagem
    * @param Integer $altura altura da imagem
    * @return void
    **/
    private function calculaPosicaoLegenda( $posicao, $largura, $altura )
    {
         // define X e Y para posicionamento
         switch( $posicao )
         {
              case 'topo_esquerda':
                   $x = 0;
                   $y = 0;
                   break;
              case 'topo_centro':
                   $x = ( $this->largura - $largura ) / 2;
                   $y = 0;
                   break;
              case 'topo_direita':
                   $x = $this->largura - $largura;
                   $y = 0;
                   break;
              case 'meio_esquerda':
                   $x = 0;
                   $y = ( $this->altura / 2 ) - ( $altura / 2 );
                   break;
              case 'meio_centro':
                   $x = ( $this->largura - $largura ) / 2;
                   $y = ( $this->altura - $altura ) / 2 ;
                   break;
              case 'meio_direita':
                   $x = $this->largura - $largura;
                   $y = ( $this->altura / 2) - ( $altura / 2 );
                   break;
              case 'baixo_esquerda':
                   $x = 0;
                   $y = $this->altura - $altura;
                   break;
              case 'baixo_centro':
                   $x = ( $this->largura - $largura ) / 2;
                   $y = $this->altura - $altura;
                   break;
              case 'baixo_direita':
                   $x = $this->largura - $largura;
                   $y = $this->altura - $altura;
                   break;
              default:
                   return false;
                   break;
         } // end switch posicao

         return array( $x, $y );
    } // fim calculaPosicaoLegenda

    /**
     * adiciona imagem de marca d'água
     * @param String $imagem caminho da imagem de marca d'água
     * @param Int/String $x posição x da marca na imagem ou constante para marcaFixa()
     * @param Int/Sring $y posição y da marca na imagem ou constante para marcaFixa()
     * @return Boolean true/false dependendo do resultado da operação
     * @param Int $alfa valor para transparência (0-100)
     *                 -> se utilizar alfa, a função imagecopymerge não preserva
     *                 -> o alfa nativo do PNG
     * @return Object instância atual do objeto, para métodos encadeados
     **/
    public function marca( $imagem, $x = 0, $y = 0, $alfa = 100 )
    {
         // cria imagem temporária para merge
         if ( $imagem ) {

              if( is_string( $x ) && is_string( $y ) )
              {
                   return $this->marcaFixa( $imagem, $x . '_' . $y, $alfa );
              }

              $pathinfo = pathinfo( $imagem );
              switch( strtolower( $pathinfo['extension'] ) )
              {
                   case 'jpg':
                   case 'jpeg':
                        $marcadagua = imagecreatefromjpeg( $imagem );
                        break;
                   case 'png':
                        $marcadagua = imagecreatefrompng( $imagem );
                        break;
                   case 'gif':
                        $marcadagua = imagecreatefromgif( $imagem );
                        break;
                   case 'bmp':
                        $marcadagua = imagecreatefrombmp( $imagem );
                        break;
                   default:
                        trigger_error( 'Arquivo de marca d\'água inválido.', E_USER_ERROR );
                        return false;
              }
         }
         else
         {
              return false;
         }
         // dimensões
         $marca_w     = imagesx( $marcadagua );
         $marca_h     = imagesy( $marcadagua );
         // retorna imagens com marca d'água
         if ( is_numeric( $alfa ) && ( ( $alfa > 0 ) && ( $alfa < 100 ) ) ) {
              imagecopymerge( $this->img, $marcadagua, $x, $y, 0, 0, $marca_w, $marca_h, $alfa );
         } else {
              imagecopy( $this->img, $marcadagua, $x, $y, 0, 0, $marca_w, $marca_h );
         }
         return $this;
    } // fim marca

    /**
     * adiciona imagem de marca d'água, com valores fixos
     * ex: topo_esquerda, topo_direita etc.
     * Implementação original por Giolvani <inavloig@gmail.com>
     * @param String $imagem caminho da imagem de marca d'água
     * @param String $posicao posição/orientação fixa da marca d'água
     *       [topo, meio, baixo] + [esquerda, centro, direita]
     * @param Int $alfa valor para transparência (0-100)
     * @return void
     **/
    private function marcaFixa( $imagem, $posicao, $alfa = 100 )
    {

         // dimensões da marca d'água
         list( $marca_w, $marca_h ) = getimagesize( $imagem );

         // define X e Y para posicionamento
         switch( $posicao )
         {
              case 'topo_esquerda':
                   $x = 0;
                   $y = 0;
                   break;
              case 'topo_centro':
                   $x = ( $this->largura - $marca_w ) / 2;
                   $y = 0;
                   break;
              case 'topo_direita':
                   $x = $this->largura - $marca_w;
                   $y = 0;
                   break;
              case 'meio_esquerda':
                   $x = 0;
                   $y = ( $this->altura / 2 ) - ( $marca_h / 2 );
                   break;
              case 'meio_centro':
                   $x = ( $this->largura - $marca_w ) / 2;
                   $y = ( $this->altura / 2 ) - ( $marca_h / 2 );
                   break;
              case 'meio_direita':
                   $x = $this->largura - $marca_w;
                   $y = ( $this->altura / 2) - ( $marca_h / 2 );
                   break;
              case 'baixo_esquerda':
                   $x = 0;
                   $y = $this->altura - $marca_h;
                   break;
              case 'baixo_centro':
                   $x = ( $this->largura - $marca_w ) / 2;
                   $y = $this->altura - $marca_h;
                   break;
              case 'baixo_direita':
                   $x = $this->largura - $marca_w;
                   $y = $this->altura - $marca_h;
                   break;
              default:
                   return false;
                   break;
         } // end switch posicao

         // cria marca
         $this->marca( $imagem, $x, $y, $alfa );
         return $this;
    } // fim marcaFixa

   /**
     * Aplica filtros avançados como brilho, contraste, pixelate, blur
     * Requer o GD compilado com a função imagefilter()
     * http://br.php.net/imagefilter
     * @param String $filtro constante/nome do filtro
     * @param Integer $quantidade número de vezes que o filtro deve ser aplicado
     *            utilizado em blur, edge, emboss, pixel e rascunho
     * @param $arg1, $arg2 e $arg3 - ver manual da função imagefilter
     * @return Object instância atual do objeto, para métodos encadeados
    **/
   public function filtra( $filtro, $quantidade = 1, $arg1 = NULL, $arg2 = NULL, $arg3 = NULL, $arg4 = NULL )
   {
        switch( $filtro )
        {
            case 'blur':
               if( is_numeric( $quantidade ) && $quantidade > 1 )
               {
                   for( $i = 1; $i <= $quantidade; $i++ )
                   {
                       imagefilter( $this->img, IMG_FILTER_GAUSSIAN_BLUR );
                   }
               }
               else
               {
                   imagefilter( $this->img, IMG_FILTER_GAUSSIAN_BLUR );
               }
               break;
           case 'blur2':
               if( is_numeric( $quantidade ) && $quantidade > 1 )
               {
                   for( $i = 1; $i <= $quantidade; $i++ )
                   {
                       imagefilter( $this->img, IMG_FILTER_SELECTIVE_BLUR );
                   }
               }
               else
               {
                   imagefilter( $this->img, IMG_FILTER_SELECTIVE_BLUR );
               }
               break;
           case 'brilho':
               imagefilter( $this->img, IMG_FILTER_BRIGHTNESS, $arg1 );
               break;
           case 'cinzas':
               imagefilter( $this->img, IMG_FILTER_GRAYSCALE );
               break;
           case 'colorir':
               imagefilter( $this->img, IMG_FILTER_COLORIZE, $arg1, $arg2, $arg3, $arg4 );
               break;
           case 'contraste':
               imagefilter( $this->img, IMG_FILTER_CONTRAST, $arg1 );
               break;
           case 'edge':
               if( is_numeric( $quantidade ) && $quantidade > 1 )
               {
                   for( $i = 1; $i <= $quantidade; $i++ )
                   {
                       imagefilter( $this->img, IMG_FILTER_EDGEDETECT );
                   }
               }
               else
               {
                   imagefilter( $this->img, IMG_FILTER_EDGEDETECT );
               }
               break;
           case 'emboss':
               if( is_numeric( $quantidade ) && $quantidade > 1 )
               {
                   for( $i = 1; $i <= $quantidade; $i++ )
                   {
                       imagefilter( $this->img, IMG_FILTER_EMBOSS );
                   }
               }
               else
               {
                   imagefilter( $this->img, IMG_FILTER_EMBOSS );
               }
               break;
           case 'negativo':
               imagefilter( $this->img, IMG_FILTER_NEGATE );
               break;
           case 'ruido':
               if( is_numeric( $quantidade ) && $quantidade > 1 )
               {
                   for( $i = 1; $i <= $quantidade; $i++ )
                   {
                       imagefilter( $this->img, IMG_FILTER_MEAN_REMOVAL );
                   }
               }
               else
               {
                   imagefilter( $this->img, IMG_FILTER_MEAN_REMOVAL );
               }
               break;
           case 'suave':
               if( is_numeric( $quantidade ) && $quantidade > 1 )
               {
                   for( $i = 1; $i <= $quantidade; $i++ )
                   {
                       imagefilter( $this->img, IMG_FILTER_SMOOTH, $arg1 );
                   }
               }
               else
               {
                   imagefilter( $this->img, IMG_FILTER_SMOOTH, $arg1 );
               }
               break;
           // SOMENTE 5.3 ou superior
           case 'pixel':
               if( is_numeric( $quantidade ) && $quantidade > 1 )
               {
                   for( $i = 1; $i <= $quantidade; $i++ )
                   {
                       imagefilter( $this->img, IMG_FILTER_PIXELATE, $arg1, $arg2 );
                   }
               }
               else
               {
                   imagefilter( $this->img, IMG_FILTER_PIXELATE, $arg1, $arg2 );
               }
               break;
           default:
               break;
        }
         return $this;
   } // fim filtrar

    /**
     * retorna saída para tela ou arquivo
     * @param String $destino caminho e nome do arquivo a serem criados
     * @param Int $qualidade qualidade da imagem no caso de JPEG (0-100)
     * @return void
     **/
    public function grava( $destino='', $qualidade = 100 )
    {
         // dados do arquivo de destino
         if ( $destino )
         {
              $pathinfo               = pathinfo( $destino );
              $dir_destino          = $pathinfo['dirname'];
              $extensao_destino     = strtolower( $pathinfo['extension'] );

              // valida diretório
              if ( !is_dir( $dir_destino ) )
              {
                   trigger_error( 'Diretório de destino inválido ou inexistente', E_USER_ERROR );
              }
         }

         if ( !isset( $extensao_destino ) )
         {
              $extensao_destino = $this->extensao;
         }

         switch( $extensao_destino )
         {
              case 'jpg':
              case 'jpeg':
              case 'bmp':
                   if ( $destino )
                   {
                        imagejpeg( $this->img, $destino, $qualidade );
                   }
                   else
                   {
                        header( "Content-type: image/jpeg" );
                        imagejpeg( $this->img, NULL, $qualidade );
                        imagedestroy( $this->img );
                        exit;
                   }
                   break;
              case 'png':
                   if ( $destino )
                   {
                        imagepng( $this->img, $destino );
                   }
                   else
                   {
                        header( "Content-type: image/png" );
                        imagepng( $this->img );
                        imagedestroy( $this->img );
                        exit;
                   }
                   break;
              case 'gif':
                   if ( $destino )
                   {
                        imagegif( $this->img, $destino );
                   }
                   else
                   {
                        header( "Content-type: image/gif" );
                        imagegif( $this->img );
                        imagedestroy( $this->img );
                        exit;
                   }
                   break;
              default:
                   return false;
                   break;
         }

    } // fim grava

} // fim da classe


//------------------------------------------------------------------------------
// suporte para a manipulação de arquivos BMP

/*********************************************/
/* Function: ImageCreateFromBMP              */
/* Author:   DHKold                          */
/* Contact:  admin@dhkold.com                */
/* Date:     The 15th of June 2005           */
/* Version:  2.0B                            */
/*********************************************/

function imagecreatefrombmp($filename) {
//Ouverture du fichier en mode binaire
  if (! $f1 = fopen($filename,"rb")) return FALSE;

//1 : Chargement des ent?tes FICHIER
  $FILE = unpack("vfile_type/Vfile_size/Vreserved/Vbitmap_offset", fread($f1,14));
  if ($FILE['file_type'] != 19778) return FALSE;

//2 : Chargement des ent?tes BMP
  $BMP = unpack('Vheader_size/Vwidth/Vheight/vplanes/vbits_per_pixel'.
                    '/Vcompression/Vsize_bitmap/Vhoriz_resolution'.
                    '/Vvert_resolution/Vcolors_used/Vcolors_important', fread($f1,40));
  $BMP['colors'] = pow(2,$BMP['bits_per_pixel']);
  if ($BMP['size_bitmap'] == 0) $BMP['size_bitmap'] = $FILE['file_size'] - $FILE['bitmap_offset'];
  $BMP['bytes_per_pixel'] = $BMP['bits_per_pixel']/8;
  $BMP['bytes_per_pixel2'] = ceil($BMP['bytes_per_pixel']);
  $BMP['decal'] = ($BMP['width']*$BMP['bytes_per_pixel']/4);
  $BMP['decal'] -= floor($BMP['width']*$BMP['bytes_per_pixel']/4);
  $BMP['decal'] = 4-(4*$BMP['decal']);
  if ($BMP['decal'] == 4) $BMP['decal'] = 0;

//3 : Chargement des couleurs de la palette
  $PALETTE = array();
  if ($BMP['colors'] < 16777216)
  {
    $PALETTE = unpack('V'.$BMP['colors'], fread($f1,$BMP['colors']*4));
  }

//4 : Cr?ation de l'image
  $IMG = fread($f1,$BMP['size_bitmap']);
  $VIDE = chr(0);

  $res = imagecreatetruecolor($BMP['width'],$BMP['height']);
  $P = 0;
  $Y = $BMP['height']-1;
  while ($Y >= 0)
  {
    $X=0;
    while ($X < $BMP['width'])
    {
     if ($BMP['bits_per_pixel'] == 24)
         $COLOR = @unpack("V",substr($IMG,$P,3).$VIDE);
     elseif ($BMP['bits_per_pixel'] == 16)
     {
         $COLOR = @unpack("n",substr($IMG,$P,2));
         $COLOR[1] = $PALETTE[$COLOR[1]+1];
     }
     elseif ($BMP['bits_per_pixel'] == 8)
     {
         $COLOR = @unpack("n",$VIDE.substr($IMG,$P,1));
         $COLOR[1] = $PALETTE[$COLOR[1]+1];
     }
     elseif ($BMP['bits_per_pixel'] == 4)
     {
         $COLOR = @unpack("n",$VIDE.substr($IMG,floor($P),1));
         if (($P*2)%2 == 0) $COLOR[1] = ($COLOR[1] >> 4) ; else $COLOR[1] = ($COLOR[1] & 0x0F);
         $COLOR[1] = $PALETTE[$COLOR[1]+1];
     }
     elseif ($BMP['bits_per_pixel'] == 1)
     {
         $COLOR = @unpack("n",$VIDE.substr($IMG,floor($P),1));
         if     (($P*8)%8 == 0) $COLOR[1] =  $COLOR[1]          >>7;
         elseif (($P*8)%8 == 1) $COLOR[1] = ($COLOR[1] & 0x40)>>6;
         elseif (($P*8)%8 == 2) $COLOR[1] = ($COLOR[1] & 0x20)>>5;
         elseif (($P*8)%8 == 3) $COLOR[1] = ($COLOR[1] & 0x10)>>4;
         elseif (($P*8)%8 == 4) $COLOR[1] = ($COLOR[1] & 0x8)>>3;
         elseif (($P*8)%8 == 5) $COLOR[1] = ($COLOR[1] & 0x4)>>2;
         elseif (($P*8)%8 == 6) $COLOR[1] = ($COLOR[1] & 0x2)>>1;
         elseif (($P*8)%8 == 7) $COLOR[1] = ($COLOR[1] & 0x1);
         $COLOR[1] = $PALETTE[$COLOR[1]+1];
     }
     else
         return FALSE;
     imagesetpixel($res,$X,$Y,$COLOR[1]);
     $X++;
     $P += $BMP['bytes_per_pixel'];
    }
    $Y--;
    $P+=$BMP['decal'];
  }

//Fermeture du fichier
  fclose($f1);

return $res;

} // fim function image from BMP

para usa-la:


<?php
require( 'canvas.php' );
$img = new canvas();
$img->carrega( 'imagem.jpg' )->hexa( '#777777' )->redimensiona( 240, 240, 'preenchimento' )->grava();
exit;

Daniel-Lopes · Julho 2, 2011

podem fechar.. já consegui resolver... quem quiser saber como é só entrar em contato.

Entrar

Arquivado

[Resolvido] Classe Canvas - Colando uma imagem na outra

Recommended Posts

Daniel-Lopes 1

Compartilhar este post

Link para o post

Compartilhar em outros sites

Daniel-Lopes 1

Compartilhar este post

Link para o post

Compartilhar em outros sites

PHP+Codeigniter - Dúvida em Relação a Teclas

Conexão mysql com outro domínio

[Resolvido] JavaScript - Exibir logo dentro da Tabela html

Este projeto é apoiado pelas empresas

Fóruns

Tempo Real

Informação importante