Varrer os pixels de uma imagem

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.

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&#40; new BufferedImage&#40;this.getBiOriginal&#40;&#41;.getWidth&#40;&#41;, this.getBiOriginal&#40;&#41;.getHeight&#40;&#41;, this.getBiOriginal&#40;&#41;.getType&#40;&#41;&#41; &#41;;
    
	int xIni = 0;
	int xEnd = this.getBiOriginal&#40;&#41;.getHeight&#40;null&#41; - 1;			
	while&#40; true &#41; &#123;
	    if&#40; xEnd &lt; xIni &#41; &#123;
	        break;
	    &#125;
	    int yIni = 0;
		int yEnd = this.getBiOriginal&#40;&#41;.getWidth&#40;null&#41; - 1;
	    while&#40; true &#41; &#123;
	        if&#40; yEnd &lt; yIni &#41; &#123;
		        break;
		    &#125;
	        
	        //	calcula a nova cor do pixel
			Color colorSE = this.calcula&#40; yIni, xIni &#41;;
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yIni, xIni, colorSE.getRGB&#40;&#41; &#41;;
	        //	calcula a nova cor do pixel
			Color colorSD = this.calcula&#40; yIni, xEnd &#41;;
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yIni, xEnd, colorSD.getRGB&#40;&#41;&#41;;
	        //	calcula a nova cor do pixel
			Color colorIE = this.calcula&#40; yEnd, xIni &#41;;
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yEnd, xIni, colorIE.getRGB&#40;&#41; &#41;;
	        //	calcula a nova cor do pixel
			Color colorID = this.calcula&#40; yEnd, xEnd &#41;;
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yEnd, xEnd, colorID.getRGB&#40;&#41;&#41;;
			
	        /*
			// calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yIni, xIni, this.calcula2&#40; yIni, xIni &#41; &#41;;
	        //	calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yIni, xEnd, this.calcula2&#40; yIni, xEnd &#41; &#41;;
	        //	calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yEnd, xIni, this.calcula2&#40; yEnd, xIni &#41; &#41;;
	        //	calcula a nova cor do pixel
			// seta a nova cor do pixel para a imagem
			this.getBiResultado&#40;&#41;.setRGB&#40; yEnd, xEnd, this.calcula2&#40; yEnd, xEnd &#41; &#41;;
			*/
			
			yIni++;
	        yEnd--;
	    &#125;
	    xIni++;
	    xEnd--;
	&#125;
    
    return this.getBiResultado&#40;&#41;;
&#125;

// -----------------------------------------------------------
// 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&#40;this.getBiOriginal&#40;&#41;.getRGB&#40;x, y&#41;&#41;;
	int cinza = &#40;int&#41; &#40;0.2989*color.getRed&#40;&#41; + 0.5870*color.getGreen&#40;&#41; + 0.1140*color.getBlue&#40;&#41;&#41;; // Padrao NTSC
	return new Color&#40;cinza, cinza, cinza&#41;;
	
&#125;

/**
 * Método que calcula bits da cor
 * 
 * @param int x
 * @param int y
 * @return int cinza
 */
private int calcula2&#40; int x, int y &#41; &#123;        

	int rgb = this.getBiOriginal&#40;&#41;.getRGB&#40;x, y&#41;;
	
	int r = &#40;rgb &gt;&gt; 16&#41; &amp; 0xff;
	int g = &#40;rgb &gt;&gt; 8&#41; &amp; 0xff;
	int b = &#40;rgb &gt;&gt; 0&#41; &amp; 0xff;
	
	r = &#40;int&#41;&#40; r * 0.2989 &#41;;
	g = &#40;int&#41;&#40; g * 0.5870 &#41;;
	b = &#40;int&#41;&#40; b * 0.1140 &#41;;
	
	int cinza = r + g + g;
								// R				G				B
	rgb = &#40;rgb &amp; 0xff000000&#41;  | &#40; cinza &lt;&lt; 16 &#41; | &#40; cinza &lt;&lt; 8 &#41; | &#40; cinza &lt;&lt; 0 &#41;;
	
	return rgb;
	
&#125;

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

[]´s

[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]