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