Pra quem tem facilidade com matemática

12 de junho de 2005 7 respostas

saoj 12 de junho de 2005

Tenho uma tela de 1024 por 768, ou seja, 786432 pixels de um byte cada um.

Estes pixels estão todos num byte array unidensional:

ponto (0,0) = pixels[0]
ponto (1,0) = pixels[1]
ponto (2,0) = pixels[2]
…
ponto(1023,767) = pixels[786431]

Eu preciso dividir a minha tela em quadradinhos de 16 x 16 o que dá 3072 quadradinhos. (3072 = 786431 / (16 x 16))

Tenho um objeto Quadradinho que encapsula um byte array bidimensional de 16 x 16 representando os pixels de um quadradinho da tela:

public class Quadradinho {
	
	private byte [][] data = new byte[16][16];
	
	public Qudradinho() { }
	
	public byte get(int x, int y) {
		return data[x][y];
	}
	
	public void set(int x, int y, byte b) {
		data[x][y] = b;
	}
}

Tudo que eu preciso é uma função que pegue meu array de pixels unidimensional e me retorna um array com 3072 Quadradinhos.

Quadradinho [] quadradinhos = divideTelaQuadradinhos(pixels);

Eu achava que era bom em matemática…

7 Respostas

danieldestro 12 de jun. de 2005

Quadradinho[] divideTelaQuadradinhos(byte[] pixels, int len) { Quadradinho[] q = new Quadradinho[pixels.length/(len*len)]; int row=0, col=0; for(int i=0; i<q.length; i++) { q[i] = new Quadradinho(); for(int j=(i*len); j><((i+1)*len); j++) { q[i].set(row,col,pixels[j]); col++; if( col >= len ) { col =0; row++; } } row = 0; col = 0; } return q; }

Acho que é isso!

danieldestro 12 de jun. de 2005

A po%$# do JForum coloca caracter a mais aí.

Ao invés de

j><((i+1)*len)

j<((i+1)*len)

fmeyer 12 de jun. de 2005

Hum não fala assim nao daniel … o Rafael pode ficar sentido … :mrgreen:

saoj 12 de jun. de 2005

Valeu pela ajuda Daniel, já deu pra sair do chão, mas ainda está errado:

Vc só tá pegando 16 bytes por vês, quando tem que pegar 16 x 16 bytes por vez, isto é, por quadradinho.

Acho que tá faltando mais um loop dentro de:

for(int j=(i*len); j<((i+1)*len); j++) {

danieldestro 12 de jun. de 2005

É verdade!

Isso não resolve?

for(int j=(i*len*len); j<((i+1)*len*len); j++) { //... }

saoj 12 de jun. de 2005

Infelizmente não. O problema é que tu não pode percorrer numa sequencia, pois haverão saltos.

Por exemplo o primeiro qudrado vai ser:

0 a 16 e 1024 a 1040 e 2048 a 2072 etc e tal

Acho que passando pixels para duas dimensões fica mais fácil, apesar de gastar processamento.

Sami_Koivu 12 de jun. de 2005

Humm… que tal assim. Os parametros sendo o array de pixels, tamanho horizontal(1024 no seu caso) e tamanho vertical(768 no seu caso).

Optando pelo processar os pixel em ordem original e determinar de qual Quadradinho eles fazem parte.

Abraços,
Sami

public static Quadradinho[] getQuadradinhos(byte[] pixels, int width,
                                                int height) {
        int columns = width / 16;
        int rows = height / 16;
        Quadradinho[] qs = new Quadradinho[columns * rows];
        for (int i = 0; i < qs.length; i++) {
            qs[i] = new Quadradinho();
        }
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                int qindex = (y / 16) * columns + (x / 16);
                int pindex = (y * width) + x;
                qs[qindex].set(x % 16, y % 16, pixels[pindex]);
            }
        }
        return qs;
    }

Criado 12 de junho de 2005

Ultima resposta 12 de jun. de 2005

Respostas 7

Participantes 4

7 Respostas

Topicos relacionados