setRGB [RESOLVIDO]

BufferedImage imagem = new BufferedImage(800, 600, BufferedImage.TYPE_INT_RGB); Graphics2D g1 = imagem.createGraphics(); g1.setColor(new Color(255,255,255)); //BRANCO g1.fillRect(0, 0, 800, 600); imagem.setRgb(0,0, new Color(248, 248, 255).getRgb()); imagem.setRgb(20,20, new outraCor.getRgb());

Outra opção:

imagem.setRgb(0,0, (248 << 16 + 248 << 8 + 255));

Viny.. Vlw ae, mas agora eu não consigo entender um probleminha:

try {
			ImageIO.write(imagem, "jpg", new File("Imagens", "argh.jpg")); //aki eu gravo a imagem (argh.jpg)
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		System.out.println("___________________"); //Aki eu imprimo os pixels da imagem, só para saber
		System.out.println(imagem.getRGB(0, 0));
		System.out.println(imagem.getRGB(1, 0));
		System.out.println(imagem.getRGB(2, 0));
		
		try {
			img1gp = ImageIO.read(new File("Imagens", "argh.jpg")); //aki eu leio a mesma imagem gravada (argh.jpg)
		} catch (IOException e) {
			e.printStackTrace();
		}

		System.out.println("___________________"); //Aki eu imprimo os pixels da imagem lida (que deveria ser o mesmo da gravada)
		System.out.println(img1gp.getRGB(0, 0));
		System.out.println(img1gp.getRGB(1, 0));
		System.out.println(img1gp.getRGB(2, 0));

Só que dá diferença... Porque??

O jpg é um formato com compactação lossy, ou seja, existe perda de dados. O java ainda usa um nível de compactação bastante alto (é possível regular isso, como vc pode ver aqui).

Se você quiser fidelidade, precisa usar um formato com compactação lossless, como png ou sem compactação, como o bmp.

AEEEE
Mudei para png e deu certo mesmo!!

Eu precisava dessa fidelidade pois é uma brincadeira que estou fazendo de “criptografia” de texto…
Então ele transforma uma letra em uma cor, e grava em uma imagem…
Para fazer o reverso ele pega o pixel da imagem e compara o RGB…

Agora deu certinho, vlw dinovo ae =)

Mais legal é fazer esteganografia.

Ao invés de transformar cada letra numa cor, pegue uma imagem já pronta e limpe apenas os dois bits menos significativos de cada componente de cor (incluindo o alfa) e substitua-os pelos bits da letra.
Assim você terá uma imagem praticamente idêntica a original, mas com um texto escondido nela.

Por exemplo, vamos supor que você tenha a letra A, que representa o código 65, isso em binário é:
01[color=red"]00[/color][color=“green”]00[/color][color=“blue”]01[/color]

E sua primeira cor é 248, 248, 255, 255, ou seja, em binário:

11111000 11111000 11111111 11111111

Limpe os dois bits menos significativos:
11111000 11111000 11111100 11111100

E substitua pelos da letra:
11111001 111110[color=“red”]00[/color] 111111[color=“green”]00[/color] 111111[color=“blue”]01[/color]

Assim cada pixel “esconde” uma letra.

Se quiser gerar com mais fidelidade, você pode usar 2 pixels (8 bytes) para representar uma única letra (1 byte), apenas aproveitando o último bit de cada canal de cor.

NICE IDEAAAA

Amanhã vou fazer isso!!!
Me empolguei agora! xD

Tou tentando aki, mas não to conseguindo =X

Para fazer o programa, você não converte nada em Strings. Você precisa trabalhar com operadores bitwise. E tratar as variáveis inteiras como se fossem bits.

Por exemplo, imagine que você tem uma cor, lida da imagem original, definida por:

int r = 248;

int g = 248;

int b = 255;

int a = 255;

Cada número desses tem uma representação binária (use a calculadora do Windows para descobri-la, se quiser):
248 = 1111 1000
255 = 1111 1111

Agora, você pode usar aqueles operadores. Vamos usar o afastamento de bits, por exemplo, para zerar os dois últimos dígitos:

b = (b >> 2); //Afasta 2 bits para direita. b agora fica com 0011 1111 b = (b << 2); //Volta pro lugar. b fica com 1111 1100

Agora, considere a letra K. O valor dela é 75, em binário, pela calculadora, dá: 01001001
Vamos supor que você queira colocar os dois bits descatados em negrito em B. Você faria:

int bits = 'K'; //01001001 bits >> 2; //00010010 bits = bits & 3;

veja a última operação em detalhes (o & é um "e" bit a bit):
00010010 &
00000011

00000010

Agora. Falta combinar bits com B:

int novoB = b | bits;

Isso é um ou bit-a-bit. Veja em detalhes:
1111 1100 |
0000 0010

1111 1110

Entendeu? E por aí você vai trabalhando.

Dúvida 2)
Como que eu leio a cor de determinado pixel da imagem assim: “248, 248, 255, 255” ??
Com o getRGB(l, c) vem o número… Como que eu faço para sair “248,248, …” ?

E qual operação que eu uso pra descubrir que ‘K’ = 01001001 ?

pedroroxd:

Como que eu leio a cor de determinado pixel da imagem assim: “248, 248, 255, 255” ??
Com o getRGB(l, c) vem o número… Como que eu faço para sair “248,248, …” ?

O getRGB vai te retornar os 4 bytes juntos, num único int. Essa cor irá retornar um número assim:

1111 1000 1111 1000 1111 1111 1111 1111
Sei lá que valor int é isso, mas provavelmente é um número negativo. Você pode passar esse valor para um color e usar os método getRed(), getGreen(), getBlue() e getAlpha() para le-los separadamente. Ou pode fazer ginásticas com operadores de bits.

Para descobrir você faz o seguinte:

1. Olhe o valor do caracter na tabela ascii. Você vai ver que o valor decimal dele é 75.
2. Abra a calculadora do windows e tecle 75.
3. No menu exibir, troque para o modo científico (ou programador, se for windows 7) e clique em “Bin”. Isso te retornará a representação binária do número.

Você pode fazer o oposto também, para converter para decimal. Ou converter para hexa, se for conveniente.

ViniGodoy:

Mais legal é fazer estenografia.

Ao invés de transformar cada letra numa cor, pegue uma imagem já pronta e limpe apenas os dois bits menos significativos de cada componente de cor (incluindo o alfa) e substitua-os pelos bits da letra.
Assim você terá uma imagem praticamente idêntica a original, mas com um texto escondido nela.

Por exemplo, vamos supor que você tenha a letra A, que representa o código 65, isso em binário é:
01[color=red"]00[/color][color=“green”]00[/color][color=“blue”]01[/color]

E o sua primeira cor é 248, 248, 255, 255, ou seja, em binário:

11111000 11111000 11111111 11111111

Limpe os dois bits menos significativos:
11111000 11111000 11111100 11111100

E substitua pelos da letra:
11111001 111110[color=“red”]00[/color] 111111[color=“green”]00[/color] 111111[color=“blue”]01[/color]

Assim cada pixel “esconde” uma letra.

Se quiser gerar com mais fidelidade, você pode usar 2 pixels (8 bytes) para representar uma única letra (1 byte), apenas aproveitando o último bit de cada canal de cor.

Cara… gostei disso ai…

pedroroxd:

Dúvida 2)
Como que eu leio a cor de determinado pixel da imagem assim: “248, 248, 255, 255” ??
Com o getRGB(l, c) vem o número… Como que eu faço para sair “248,248, …” ?

E qual operação que eu uso pra descubrir que ‘K’ = 01001001 ?

se não quiser ficar fazendo operações com bitwise para pegar pixels da imagem vc pode fazer isto atravez de um WritableRaster

WritableRaster raster = bufferedimagem.getRaster();
		int[] pixels = new int[3];

		for (int x = 0; x < bufferedimagem.getWidth(); x++) {
			for (int y = 0; y < bufferedimagem.getHeight(); y++) {
				raster.getPixel(x, y, pixels);
				pixels[0] //r
                                pixels[1] //g
                                pixels[2] //b
			}
		}

entendeu…

[EDIT]
Esqueça!! Agora q entendi… Eu não preciso saber o binário… ele precisa apenas existir! =)

Boiei no comentário…

Color m = new Color(imagem.getRGB(line, colum));
int a = m.getRed(); //A
a = a>>2;
a = a<<2;
int b = m.getGreen(); //B
b = b>>2;
b = b<<2;
int c = m.getBlue(); //C
c = c>>2;
c = c<<2;
int d = m.getAlpha(); //D
d = d>>2;
d = d<<2;

				
			      //a  b  c  d
int bits = letras[x];  //01 00 10 01
			 
int novoD = d | bits;
				 
bits = bits >> 2; 
bits = bits & 3;  
int novoC = c | bits; 
 
				 
bits = letras[x];
bits = bits >>4;
bits = bits & 3;
int novoB = b | bits;
			     
bits = letras[x];
bits = bits >>6;
bits = bits & 3;
int novoA = a | bits;

Se isso estiver certo, eu consegui criptografar... Eu comparo os RGB das imagens e os que eu troquei realmente dão diferença...
Agora para descriptografar que é o foda!

int what = img1gp.getRGB(x, c);
				Color m = new Color(what);
				int A = m.getRed();
				int B = m.getGreen();
				int C = m.getBlue();
				int D = m.getAlpha();

Deu tudo certo o negosso da Criptografia lá... Mas mais uma vez os dados gravados não estão batendo totalmente com os dados lidos... Mais precisamente: Somente o getAlpha() não está dando certo... E eu preciso dessa fidelidade de informação para ler os bits..

Color newColorr = new Color(novoA,novoB,novoC,novoD); 
System.out.println(novoA+ " " + novoB+ " " +novoC+ " " +novoD);
imagem.setRGB(line, colum, newColorr.getRGB());

//GRAVADO, AGORA EU VOU LER OS DADOS GRAVADOS NO MESMO PIXEL, PARA VER SE TEM FIDELIDADE NO GRAVADO E NO LIDO.

Color kkk = new Color(imagem.getRGB(line, colum));
System.out.println(kkk.getRed()+ " " + kkk.getGreen() + " " + kkk.getBlue() + " " + kkk.getAlpha());

Olha só a saída (em cima é o novoA, novoB, novoC, novoD e em baixo são os lidos):
33 24 48 253
33 24 48 255

33 29 52 255
33 29 52 255

33 29 52 255
33 29 52 255

29 28 48 253
29 28 48 255

20 26 44 252
20 26 44 255

O getAlpha() sempre está retornando 255.. Estou trabalhando com imagens .png... Onde será que estou falhando?

Todos estão dando certo, menos o Alpha... A primeira letra é um E. Com o meu método, ele retorna 01000011 sendo que era para os 2 ultimos dígitos serem 01. Ele sempre está retornando 11, por causa do 255 (ele pega os 2 ultimos bits de cada cor).

Só uma dúvida, o valor convertido para inteiro:

newColorr.getRGB()

É diferente do valor convertido para inteiro lido?

E como vc fez para criar o PNG de saída? Você fez:

BufferedImage novaImagem = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

Pq se o tipo for só RGB, aí vai desprezar o alfa mesmo.

Fiz assim:
o filetxt.getParent() é pq eu criptografo um documento de texto, ae eu gravo no mesmo local…

try { ImageIO.write(imagem, "png", new File(filetxt.getParent(), "Imagem Criptografada.png")); } catch (IOException e) { e.printStackTrace(); }

E sim, são diferentes
A letra que é ‘criptografada’ é o E (69) = 01000101
A saída é G (71) = 01000111

Agora que entendi o que vc perguntou se era diferente…
É sim:

imagem.setRGB(line, colum, newColorr.getRGB()); System.out.println("Antes" + newColorr.getRGB()); Color kkk = new Color(imagem.getRGB(line, colum)); System.out.println("Depois" + imagem.getRGB(line, colum));
Saída:
Antes-48162767
Depois-14608335

Perguntei como vc cria a variável imagem

A variável imagem é passada através de um método para ser criptografada…

private File fileimg;
Ae no filechooser:

fileimg = fc.getSelectedFile();

Ae na hora de chamar para criptografar (filetxt é o documento de texto com o texto a ser criptografado):

new Faztudo().criptografa(filetxt,fileimg);

Ae na hora que o criptografa recebe a imagem:

public void criptografa(File filetxt, File fileimg) { System.out.println("Criptografando..."); BufferedImage imagem = null; try { imagem = ImageIO.read(fileimg); } catch (IOException e2) { e2.printStackTrace(); }

Provavelmente a imagem que você leu não tem canal alpha. O ideal mesmo é criar um BufferedImage para conter a cópia, com o canal alfa.

Ou gravar apenas nos componentes de cor RGB. Mas aí vc terá que usar 2 pixels para representar apenas 1 byte.

É… eu tava pensando em fazer para usar 2 pixels mesmo…
Mas se for para criar o BufferedImage com o canal alpha eu faço aonde? Quando eu recebo a imagem ou quando eu vou passar ela?

Na hora que você lè.

System.out.println(“Criptografando…”);

BufferedImage novaImagem = null; try { BufferedImage imagem = ImageIO.read(fileimg); novaImagem = new BufferedImage(imagem.getWidth(), imagem.getHeight(), BufferedImage.TYPE_INT_ARGB); } catch (IOException e2) { e2.printStackTrace(); }

Se você for usar 2 pixels, aí pode melhorar muito a qualidade da imagem final.

Use o seguinte esquema:

Pixel 1:

R: 2 bits
G: 1 bit
B: 1 bit

Pixel 2:
R: 2 bits
G: 1 bit
B: 1 bit

Fica virtualmente impossível perceber a diferença de duas imagens usando esse esquema.

Ah, vou fazer para gravar em 2 pixels mesmo…

Agora uma dúvida…
Eu gravo no Red e Green ou no Green e Blue?
Qual promove menos variação na cor da imagem?

Vlws !

Para extrair os valores dos 4 últimos bits de um byte:

int ch = 'B'; int lowch = B & 0x0F; //4 bits menos significativos int highch = (B & 0xF0) >> 4; //4 bits mais significativos

Aí, para sua solução ficar 100% perfeita, basta rodar compactação no texto antes de passa-lo para a imagem.
E descompactação depois de lê-lo novamente. Isso aumenta brutalmente a quantidade de caracteres que uma imagem pode conter.

Existe uma maneira mais fácil de simplesmente limpar bits, veja:

Color pixel1 = new Color(imagem.getRGB(line, column)); int r1 = pixel1.getRed() & 0xFC; //Limpa os dois ultimos bit. FC=1111 1100 int g1 = pixel1.getGreen() & 0xFE; //Limpa o ultimo bit. FE=1111 1110 int b1 = pixel1.getBlue() & 0xFE;

Para voltar, os bytes que forem com o bit você fará & com 1. Os que foram 2 bits vc faz & com 3. Veja os valores em binário:

1 = 00000001
3 = 00000011

Note que você simplesmente deixa 1 nas casas que você quer pegar.

Opa!
Deu certo =)

Depois que eu pego o valor do byte, tipo 69, como que eu volto ele pra letra?

Ah..
Consegui assim:

public String toBinaryString(int value)  
	 {  
	    String str = Integer.toBinaryString((byte) value);  
	   
	    StringBuilder sb = new StringBuilder();  
	       
	    for (int i = 0; i < 8 - str.length(); i++) {  
	       sb.append("0");       
	    }  
	    return sb.append(str).toString();  
	 }

int i = Integer.parseInt(toBinaryString(byteValue), 2);          
				  System.out.println((char)i);

Tem que repensar em como vc tá empurrando esses bits:

int byteValue = ((R & 3) << 6) | ((G & 1) << 5) | ((B & 1) << 4) | (R & 3) << 3 | ((G2 & 1) << 1) | (B2 & 1));

Era isso mesmo!!!
Maneira certa:

int byteValue = ((R & 3)) | ((G & 1) << 2) | ((B & 1) <<3 | ((R2 & 3) << 5) | ((G2 & 1) << 6) | ((B2 & 1) << 7));

Agora foi bizarro…

Olha a entrada:
GINASTICA VAI SER ESTENOGRAFADO EM UMA IMAGEM.

Olha a saída:
GINACDICA FAI CEB ECDENOGBAFADO EM EMA IMAGEM.

Umas letras sairam erradas…
S vira C
T vira D
V vira F
R vira B
U vira E

Mandei Criptografar o alfabeto…

Entrada:
ABCDEFGHIJKLMNOPQRSTUVWXYZ,.?

Saída:
ABCDEFGHIJKLMNO@ABCDEFGHIJ,./l

Axo que o erro é quando eu faço isso:

String str = Integer.toBinaryString((byte) byteValue);
int i = Integer.parseInt(str, 2);
System.out.println((char) i);

O Alfabeto Criptografado Antes:

Entrada:
ABCDEFGHIJKLMNOPQRSTUVWXYZ,.?

Saída:
ABCDEFGHIJKLMNO@ABCDEFGHIJ,./l

Ae fikei encabulado..
Só a partir do "P" que tá errado?!?!

Ae colokei só o P para criptografar (letras[x] é o 'P')

int bits = letras[x];
				bits = bits & 3;  
				int novoRED1 = r1 | bits; 
							 
								 
				bits = letras[x];
				bits = bits >>2;
				bits = bits & 1;
				int novoGREEN1 = g1 | bits;
							     
				bits = letras[x];
				bits = bits >>3;
				bits = bits & 1;
				int novoBLUE1 = b1 | bits;
							     
							     
				/////////////////////
				bits = letras[x];
				bits = bits >>5;
				bits = bits & 3;
				int novoRED2 = r2|bits;
							     
				bits = letras[x];
				bits = bits >>6;
				bits = bits & 1;
				int novoGREEN2 = g2|bits;
							     
				bits = letras[x];
				bits = bits >>7;
				bits = bits & 1;
				int novoBLUE2 = b2 |bits;
					

//PRESTEM ATENÇÃO AKI! ! ! ! ! !
int byteValueAntes = letras[x];
System.out.println("ByTE ANTES! ! " + byteValueAntes);

int byteValue= ((novoRED1 & 3)) | ((novoGREEN1 & 1) << 2) | ((novoBLUE1 & 1) <<3 | ((novoRED2 & 3) << 5) | ((novoGREEN2 & 1) << 6) | ((novoBLUE2 & 1) << 7));
System.out.println("ByTE ! ! " + byteValue);

A saída foi:
[color=red]ByTE ANTES! ! 80
ByTE ! ! 64[/color]
Eu vi e revi... É realmente o inverso que estou fazendo..

Ele está igualando o
Q no A: "01010001" no "01000001"
R no B: "01010010" no "01000010"
S no C: "01010011" no "01000011"
Está ocorrendo a perda desses 2 bits do meio...

Consegui…

bits = letras[x]; bits = bits >>4; //EM VEZ DE 5 bits = bits & 3; int novoRED2 = r2|bits; //E na hora de voltar <<4!

Agora tá dando tudo certo… Menos uma coisa:
Posso colocar qualquer texto lá…
Mas ele não reconhece coisas como à á â ã , etc…
Porque será?

Deixei um exemplo funcional no seu outro tópico:
http://www.guj.com.br/posts/list/221679.java#1134695