(41) 9225-6319
contato@felipemarques.com.br

CanvasRemote: Um breve update na famosa classe Canvas

Olá Pessoal,

Hoje vou postar aqui um script, em forma de agradecimento a comunidade PHP. Confesso que eu era bem egoísta no começo da minha humilde vida como programador, e todo o conhecimento que eu adquiria em blogs, fóruns ou até mesmo sozinho, não gostava muito de passar adiante.

O tempo passou e aprendi que ninguém cresce sozinho, sempre tem algum ajudando diretamente ou indiretamente, e desde que aprendi isso resolvi mudar minha opinião e então passei a divulgar todas minhas pequenas descobertas aqui neste blog.

Então chega de enrolar e vamos entender o seguitne cenário:

– Foi desenvolvido pela nossa equipe Web um sistema de MediaCenter para o site http://www.lumenoso.com.br/mediacenter.
– O mesmo é integrado com Youtube, Flickr e WordPress (através dos feeds).
– As imagens do mediacenter vem diretamente desses serviços externos e não havia uma forma de tratá-las, para redimensionar a imagem externa no tamanho equivalente ao layout.
– Pesquisando pela internet, chegamos ao excelente blog do Davi Ferreira, que possui diversos posts muito interessantes.
– Então verificamos os exemplos de utilização da classe Canvas e vimos que resolvia todos os nossos problemas de perca de qualidade de imagem após redimensionadas.
– Porém o problema estava nas imagens que vinham diretamente do Youtube e Flickr, ex: http://i.ytimg.com/vi/pnbHdt6DfCg/0.jpg.
– Eu até tentei usar o método $canvas->carregaUrl(‘http://i.ytimg.com/vi/pnbHdt6DfCg/0.jpg’); porém a função pathinfo não permite acessar arquivo externo em nossos servidores, então precisavamos modificar a classe.

Iniciei a construção de uma subclasse que herda os métodos da classe Canvas e reescreve apenas o método Carrega();

Vejam nesse link os exemplos com o resultado da modificação: Demonstração.

Download on GitHub

Como estava escrevendo uma subclasse, resolvi criar um nome pra ela e chamei-a de CanvasRemote.

Segue abaixo o código completo do arquivo thumb.php utilizado na página de demonstração:

<?php
/**
 * canvas.php
 *
 * Classe para manipulação de imagens
 * Interface para GD
 *
 * @author     Davi Ferreira <contato@daviferreira.com>
 * @version    1.0 $ 2010-05-21 19:56:33 $
 *
 * TODO:
*/

class Canvas {

	// arquivos
	private $origem, $img, $img_temp;
	// dimensões
	private $largura, $altura, $nova_largura, $nova_altura, $tamanho_html;
	// dados do arquivo
	private $formato, $extensao, $tamanho, $arquivo, $diretorio;
	// cor de fundo para preenchimento
	private $rgb;
	// posicionamento do crop
	private $posicao_crop;

	/**
	 * Construtor
	 * @param $string caminho da imagem a ser carregada
	 * @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
	 * @param
	 * @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
			{
				// pega dimensões
				$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
	 * @param
	 * @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
	 * @param
	 * @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
     * @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
	 * @param
	 * @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)
	 * @param
	 * @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
	 * @param
	 * @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
	 * @param
	 * @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;
		
		/**
		 * Verifica altura e largura
		 * Cálculo corrigido por Leonardo <leonardomascara@gmail.com>
		 */
		if ( $this->nova_largura >= $this->nova_altura )
		{
			$dif_w = ( ( $this->largura * $this->nova_altura ) / $this->altura );
		}
		else
		{
			$dif_h = ( ( $this->altura * $this->nova_largura ) / $this->largura );
		}

		// copia com o novo tamanho, centralizando
		$dif_x = ( $dif_x - $dif_w ) / 2;
		$dif_y = ( $dif_y - $dif_h ) / 2;
		imagecopyresampled( $this->img_temp, $this->img, $dif_x, $dif_y, 0, 0, $dif_w, $dif_h, $this->largura, $this->altura );
		$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
	 * @param
	 * @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
	
	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


//------------------------------------------------------------------------------
// gera imagem de saída

	/**
	 * 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&#91;'colors'&#93;, fread($f1,$BMP&#91;'colors'&#93;*4));
   }

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

   $res = imagecreatetruecolor($BMP&#91;'width'&#93;,$BMP&#91;'height'&#93;);
   $P = 0;
   $Y = $BMP&#91;'height'&#93;-1;
   while ($Y >= 0)
   {
	$X=0;
	while ($X < $BMP&#91;'width'&#93;)
	{
	 if ($BMP&#91;'bits_per_pixel'&#93; == 24)
		$COLOR = @unpack("V",substr($IMG,$P,3).$VIDE);
	 elseif ($BMP&#91;'bits_per_pixel'&#93; == 16)
	 {
		$COLOR = @unpack("n",substr($IMG,$P,2));
		$COLOR&#91;1&#93; = $PALETTE&#91;$COLOR&#91;1&#93;+1&#93;;
	 }
	 elseif ($BMP&#91;'bits_per_pixel'&#93; == 8)
	 {
		$COLOR = @unpack("n",$VIDE.substr($IMG,$P,1));
		$COLOR&#91;1&#93; = $PALETTE&#91;$COLOR&#91;1&#93;+1&#93;;
	 }
	 elseif ($BMP&#91;'bits_per_pixel'&#93; == 4)
	 {
		$COLOR = @unpack("n",$VIDE.substr($IMG,floor($P),1));
		if (($P*2)%2 == 0) $COLOR&#91;1&#93; = ($COLOR&#91;1&#93; >> 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

/**
 * Classe utilizada para manipular arquivos externos.
 * 
 * @author Felipe Marques
 * @email felipecaioba@gmail.com
 * @date 08/06/2011
 * @package CanvasRemove
 * @dependency Canvas
 * */
class CanvasRemote extends Canvas{

	private $_proxy;
	private $_cacheTime = 3600; // 1 hora
	private $_url;
	
	/**
	 * Método para setar o proxy
	 * 
	 *  @param $host,$port,$user,$pass
	 *  @return void
	 * */
	public function setProxy($host,$port,$user,$pass,$proxyAuth = CURLAUTH_NTLM){
		
		$this->_proxy = array(
			'host' => $host,
			'port' => $port,
			'user' => $user,
			'pass' => $pass,
			'proxyauth' => $proxyAuth
		);
		
	}

	/**
	 * Método verifica se há um cache do arquivo
	 * 
	 * */
	private function getCacheFile(){
		
		//Store URL data in local cache.
		$cacheFilename = $this->getCacheFilename();
		$data = '';
		
		if (file_exists($cacheFilename) && (time() - filemtime($cacheFilename)) < $this->_cacheTime) {
			if ($data = file_get_contents($cacheFilename)) {
				return $data;
			}
		}	
	}	
	
	/**
	 * Método responsável por retornar o diretorio temporario do servidor
	 * seja linux ou windows
	 * 
	 * @param void
	 * @return void
	 * */
	private function getCacheFilename() {
		
		$extension = end(explode('.',$this->_url));
		
		if(function_exists('sys_get_temp_dir')){
			return sys_get_temp_dir() . DIRECTORY_SEPARATOR . md5($this->_url) . '.CanvasRemote.cache.'.$extension;
		}else{
			$file = tempnam(false,false);
			$tmpdir = realpath(dirname($file));		
			return $tmpdir . DIRECTORY_SEPARATOR . md5($this->_url) . '.CanvasRemote.cache.'.$extension;
		}
	}
	
	/**
	 * Método responsavel por gravar um cache do arquivo na pasta temporaria do servidor
	 * 
	 * @param $fileName,$data
	 * @return bytes or FALSE  
	 * */
	private function setCacheFileName($fileName,$data){
		return file_put_contents($fileName,$data);
	}	
	
	/**
	 * Pega a imagem externamente e salva como um arquivo temporario
	 * 
	 * @param $urlImage
	 * @return (string)
	 * */
	private function saveImageTempFromUrl($url){
	
		$this->_url = $url;
		
		if($file = $this->getCacheFile()){
			
			return $file;
			
		}else{

			$ch = curl_init();
		    curl_setopt($ch, CURLOPT_HEADER, 0); // para mostrar o cabecalho o valor deve ser 1
			curl_setopt($ch, CURLOPT_VERBOSE, 0);
		    curl_setopt($ch, CURLOPT_POSTFIELDS, $request);
		    curl_setopt($ch, CURLOPT_URL, $this->_url);
		    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
		    curl_setopt($ch, CURLOPT_TIMEOUT, 1);
	
			if(!empty($this->_proxy))
			{
				curl_setopt($ch, CURLOPT_PROXY, $this->_proxy['host']);
				curl_setopt($ch, CURLOPT_PROXYPORT, $this->_proxy['port']);
				curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL,true);
				curl_setopt($ch, CURLOPT_PROXYUSERPWD, $this->_proxy['user'].":".$this->_proxy['pass']);
				curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_NTLM); # CURLAUTH_BASIC ou CURLAUTH_NTLM
			}		    
	
			$resource = curl_exec($ch);
			
			curl_close($ch);

			if(preg_replace('/\s+/','',$resource) == ''){
				return false;
			}
			
			// set a o arquivo em cache
			$this->setCacheFileName($this->getCacheFilename(),$resource);
		
			return $resource;
		}
		
		
	}

	/**
	 * Reescrevemos o método carrega para implementar o acesso externo.
	 * 
	 * @override
	 * @param $url
	 * @return (object) $this
	 * */
	public function carrega($pathRoot,$url){
		
		if(preg_match('/(http:\/\/)/mi',$url)){

			$this->saveImageTempFromUrl($url);
			$file = $this->getCacheFilename();
			return parent::carrega($file);
			
		}else{
			
			if(is_file($pathRoot . $url)){
				return parent::carrega($pathRoot . $url);
			}else{
				throw(new Exception('Arquivo não existe no servidor.'));
			}
			
			return parent::carrega($pathRoot . $url);
		}
	}

}



//////////////////////////////////
// Script adaptado por:
// @author Felipe Marques 
// @date 08/06/2011
// @email felipecaioba@gmail.com / contato@felipemarques.com.br
//////////////////////////////////


// Define o path para o root da app
defined('APPLICATION_ROOT')
    || define('APPLICATION_ROOT', realpath( dirname(__FILE__).'/../' ).DIRECTORY_SEPARATOR );

// Pegamos os parametros pela URL
$arquivo = (string) $_GET['arquivo'];
$largura = (int) $_GET['largura'];
$altura = (int) $_GET['altura'];

$obj = new CanvasRemote();


try{

	$obj->carrega(APPLICATION_ROOT,$arquivo);
	$obj->redimensiona($largura,$altura,'crop');
	$obj->grava();
	
}catch(Exception $e){
	echo $e->getMessage();
}
?>
Sobre o autor
Felipe Marques é Consultor e Analista de Sistemas Web e Mobile. Mais de 10 anos de experiência.

Faça um comentário

*

Facebook Auto Publish Powered By : XYZScripts.com