Varrer os pixels de uma imagem

[lauroguerraPJ]

Alguém aí teria alguma coisa em java…um algoritmo que varre os pixels de uma imagem monocromática…com linhas de varredura…ou seja, ele varre uma linha da imagem e verifica por exemplo dois pixels acesos (1) ou apagados (0) e guarda isso em uma matriz? Se puderem me dar uma luz eu agradeço.

[ErkoPJ]

opa beleza?

bom primeiro uma pergunta tu tem uma imagem com apenas 2 valores,
ou essa sua imagem monocromatica é uma imagens em tons de cinza?

caso seja uma imagem em tons de cinza então digamos que tu assuma
que metade do máximo 256 :arrow: 128 para mais, seria o equivalente ao
seu 1 e abaixo de 128 seria equivalente ao seu 0…

bom segue alguns links sobre java 2D:
Code sample - Java 2D API Sample Programs

qualquer coisa segue um código que transforma uma imagem para escala de cinza, acredito que vendo ela talvez ajude em algo :razz:

[code]/*

• Created on 27/09/2005
  */
  package bridee.erko.PID.processamento;

import java.awt.Color;
import java.awt.image.BufferedImage;

/**

• @author Erko Bridee de Almeida Cabrera
• <br><br>
• <b>Descrição:</b><br>
• Classe responsável pela conversão de uma imagem para a escala de cinza
  */
  public class EscalaCinza {

// -----------------------------------------------------------
// Atributos da classe
// -----------------------------------------------------------
/**
* Imagem original enviada para a classe
/
private BufferedImage biOriginal;
/*
* Imagem resultado da aplicação da mascara
*/
private BufferedImage biResultado;
// -----------------------------------------------------------
// Fim dos atributos da classe
// -----------------------------------------------------------

// -----------------------------------------------------------
// Construtores da classe
// -----------------------------------------------------------
/**
* Construtor da classe sem parametros
*/
public EscalaCinza() { this.init(); }
// -----------------------------------------------------------
// Fim dos construtores da classe
// -----------------------------------------------------------

// -----------------------------------------------------------
// Métodos de acesso aos atributos da classe
// -----------------------------------------------------------
/**
* @return BufferedImage biOriginal.
/
public BufferedImage getBiOriginal() {
return biOriginal;
}
/*
* @param BufferedImage biOriginal
/
public void setBiOriginal(BufferedImage biOriginal) {
this.biOriginal = biOriginal;
}
/*
* @return BufferedImage biResultado.
/
public BufferedImage getBiResultado() {
return biResultado;
}
/*
* @param BufferedImage biResultado
*/
public void setBiResultado(BufferedImage biResultado) {
this.biResultado = biResultado;
}
// -----------------------------------------------------------
// Fim dos métodos de acesso ao atributos da classe
// -----------------------------------------------------------

// -----------------------------------------------------------
// Métodos de serviços da classe
// -----------------------------------------------------------
/**
* Método que percorre a imagem e realiza os calculos
* para converter uma imagem RGB para escala de cinza
*/
public BufferedImage doWork() {

    // criando um novo buffer para saida do resultado
    this.setBiResultado( new BufferedImage(this.getBiOriginal().getWidth(), this.getBiOriginal().getHeight(), this.getBiOriginal().getType()) );
    
	int xIni = 0;
	int xEnd = this.getBiOriginal().getHeight(null) - 1;			
	while( true ) {
	    if( xEnd < xIni ) {
	        break;
	    }
	    int yIni = 0;
		int yEnd = this.getBiOriginal().getWidth(null) - 1;
	    while( true ) {
	        if( yEnd < yIni ) {
		        break;
		    }
	        
	        //	calcula a nova cor do pixel
			Color colorSE = this.calcula( yIni, xIni );
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yIni, xIni, colorSE.getRGB() );
	        //	calcula a nova cor do pixel
			Color colorSD = this.calcula( yIni, xEnd );
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yIni, xEnd, colorSD.getRGB());
	        //	calcula a nova cor do pixel
			Color colorIE = this.calcula( yEnd, xIni );
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yEnd, xIni, colorIE.getRGB() );
	        //	calcula a nova cor do pixel
			Color colorID = this.calcula( yEnd, xEnd );
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yEnd, xEnd, colorID.getRGB());
			
	        /*
			// calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yIni, xIni, this.calcula2( yIni, xIni ) );
	        //	calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yIni, xEnd, this.calcula2( yIni, xEnd ) );
	        //	calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yEnd, xIni, this.calcula2( yEnd, xIni ) );
	        //	calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado().setRGB( yEnd, xEnd, this.calcula2( yEnd, xEnd ) );
			*/
			
			yIni++;
	        yEnd--;
	    }
	    xIni++;
	    xEnd--;
	}
    
    return this.getBiResultado();
}

// -----------------------------------------------------------
// Fim dos métodos de serviços da classe
// -----------------------------------------------------------

// -----------------------------------------------------------
// Métodos auxiliares da classe
// -----------------------------------------------------------
/**
* Método de inicialização dos atributos da classe
/
private void init() {
this.setBiOriginal( null );
this.setBiResultado( null );
}
/*
* Método que calcula a cor correspondente em cinza
* @param x
* @param y
* @return
*/
private Color calcula( int x, int y ) {

    Color color = new Color(this.getBiOriginal().getRGB(x, y));
	int cinza = (int) (0.2989*color.getRed() + 0.5870*color.getGreen() + 0.1140*color.getBlue()); // Padrao NTSC
	return new Color(cinza, cinza, cinza);
	
}

/**
 * Método que calcula bits da cor
 * 
 * @param int x
 * @param int y
 * @return int cinza
 */
private int calcula2( int x, int y ) {        

	int rgb = this.getBiOriginal().getRGB(x, y);
	
	int r = (rgb >> 16) & 0xff;
	int g = (rgb >> 8) & 0xff;
	int b = (rgb >> 0) & 0xff;
	
	r = (int)( r * 0.2989 );
	g = (int)( g * 0.5870 );
	b = (int)( b * 0.1140 );
	
	int cinza = r + g + g;
								// R				G				B
	rgb = (rgb & 0xff000000)  | ( cinza << 16 ) | ( cinza << 8 ) | ( cinza << 0 );
	
	return rgb;
	
}

// -----------------------------------------------------------
// Fim dos métodos auxiliares de classe
// -----------------------------------------------------------
}
[/code]

[]´s

[lauroguerraPJ]

[b]Seriam imagens relativamente pequenas…o que estou tentado iniciar é um esquema onde eu pego minhas imagens…elas são varridas e são geradas essas matrizes com suas características…e as mando para um banco mysql (imagem e matriz) …só que não vem na minha cabeça uma forma de fazer isso…

uma vez que as imagens e suas respectivas matrizes estejam no banco vou querer realizar a busca por essa imagem através dessas matrizes, ou seja, vou desenhar um croquí de uma imagem, digamos uma cadeira, e meu programa varrerá a imagem criando sua matriz correspondente e enviando essa matriz como forma de consulta para o banco o qual buscará a matriz mais similiar e recuperando a imagem de uma forma mais rápida, penso eu.[/b]