Aula 49 - Tensores 0D, 1D e 2D

O que são Pixels?

Os pixels são uma coleção de pequenos pontos ou quadradinhos que formam uma imagem digital. Cada pixel pode ter um valor que representa sua cor ou intensidade.

Tensor 0D - Um Único Número

Um Tensor 0D é simplesmente um número. No contexto de imagens, representa a intensidade de um único pixel em tons de cinza.

public class Tensor0D {
    public static void main(String[] args) {
        // Tensor 0D: um único valor de intensidade
        int pixel = 128;
        
        System.out.println("Intensidade do pixel: " + pixel);
        
        // Interpretando a intensidade
        if (pixel == 0) {
            System.out.println("Tom: Preto");
        } else if (pixel == 255) {
            System.out.println("Tom: Branco");
        } else {
            System.out.println("Tom: Cinza (intensidade " + pixel + ")");
        }
    }
}

Tensor 1D - Vetor (Fileira de Números)

Um Tensor 1D é uma fileira ou coluna de números. No contexto de imagens, representa uma linha de pixels com suas intensidades.

public class Tensor1D {
    public static void main(String[] args) {
        // Tensor 1D: vetor com intensidades de tons de cinza
        int[] linha = {0, 32, 64, 96, 128, 160, 192, 224};
        
        System.out.println("=== TENSOR 1D - LINHA DE PIXELS ===");
        for (int i = 0; i < linha.length; i++) {
            System.out.println("Pixel " + i + ": intensidade " + linha[i]);
        }
    }
}

Tensor 2D - Matriz (Imagem em Tons de Cinza)

Um Tensor 2D é uma matriz (conjunto de fileiras e colunas). Representa uma imagem completa em tons de cinza, onde cada elemento é a intensidade de um pixel.

public class Tensor2D {
    public static void main(String[] args) {
        // Tensor 2D: matriz representando imagem 4x8 em tons de cinza
        int[][] imagem = {
            {0, 32, 64, 96, 128, 160, 192, 224},
            {32, 64, 96, 128, 160, 192, 224, 255},
            {64, 96, 128, 160, 192, 224, 255, 192},
            {96, 128, 160, 192, 224, 255, 192, 160}
        };
        
        System.out.println("=== TENSOR 2D - IMAGEM EM TONS DE CINZA ===");
        System.out.println("Dimensões: " + imagem.length + " linhas x " + imagem[0].length + " colunas");
        System.out.println();
        
        // Exibindo a matriz
        for (int i = 0; i < imagem.length; i++) {
            System.out.print("Linha " + i + ": ");
            for (int j = 0; j < imagem[i].length; j++) {
                System.out.print(imagem[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

Criando Tensor 1D com Loop

public class CriarTensor1D {
    public static void main(String[] args) {
        // Criando um vetor de 256 posições (0 a 255)
        int[] tonsCinza = new int[256];
        
        // Preenchendo com valores de 0 a 255
        for (int i = 0; i < tonsCinza.length; i++) {
            tonsCinza[i] = i;
        }
        
        // Exibindo alguns valores
        System.out.println("Primeiro tom: " + tonsCinza[0]);
        System.out.println("Tom médio: " + tonsCinza[128]);
        System.out.println("Último tom: " + tonsCinza[255]);
        System.out.println("Total de tons: " + tonsCinza.length);
    }
}

Criando Tensor 2D com Loop Aninhado

public class CriarTensor2D {
    public static void main(String[] args) {
        // Criando uma imagem 8x8 em tons de cinza
        int[][] imagemGradiente = new int[8][8];
        
        // Preenchendo com gradiente horizontal
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                imagemGradiente[i][j] = j * 32;  // 0, 32, 64, 96...
            }
        }
        
        // Exibindo a matriz
        System.out.println("=== IMAGEM COM GRADIENTE HORIZONTAL ===");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.print(imagemGradiente[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

Tensor 3D - Imagem Colorida (RGB)

Um Tensor 3D representa uma imagem colorida. Cada pixel tem três valores: um para Red (vermelho), um para Green (verde) e um para Blue (azul).

public class Tensor3D {
    public static void main(String[] args) {
        // Tensor 3D: imagem 2x2 colorida (RGB)
        // Cada pixel tem 3 valores: [R, G, B]
        int[][][] imagemColorida = {
            {
                {255, 0, 0},    // Pixel [0][0] = Vermelho puro
                {0, 255, 0}     // Pixel [0][1] = Verde puro
            },
            {
                {0, 0, 255},    // Pixel [1][0] = Azul puro
                {255, 255, 0}   // Pixel [1][1] = Amarelo (R+G)
            }
        };
        
        System.out.println("=== IMAGEM COLORIDA 2x2 (RGB) ===");
        for (int i = 0; i < imagemColorida.length; i++) {
            for (int j = 0; j < imagemColorida[i].length; j++) {
                System.out.print("Pixel [" + i + "][" + j + "]: ");
                System.out.println("R=" + imagemColorida[i][j][0] + 
                                   " G=" + imagemColorida[i][j][1] + 
                                   " B=" + imagemColorida[i][j][2]);
            }
        }
    }
}

Comparação: Tons de Cinza vs Colorida

Exemplo Prático: Analisando Imagem

public class AnalisarImagem {
    public static void main(String[] args) {
        // Imagem 4x4 em tons de cinza
        int[][] imagem = {
            {50, 100, 150, 200},
            {60, 110, 160, 210},
            {70, 120, 170, 220},
            {80, 130, 180, 230}
        };
        
        // Calculando a intensidade média
        int soma = 0;
        int totalPixels = 0;
        
        for (int i = 0; i < imagem.length; i++) {
            for (int j = 0; j < imagem[i].length; j++) {
                soma += imagem[i][j];
                totalPixels++;
            }
        }
        
        double media = (double) soma / totalPixels;
        
        System.out.println("=== ANÁLISE DA IMAGEM ===");
        System.out.println("Dimensões: " + imagem.length + "x" + imagem[0].length);
        System.out.println("Total de pixels: " + totalPixels);
        System.out.println("Intensidade média: " + media);
        
        // Contando pixels escuros (< 128) e claros (>= 128)
        int escuros = 0;
        int claros = 0;
        
        for (int i = 0; i < imagem.length; i++) {
            for (int j = 0; j < imagem[i].length; j++) {
                if (imagem[i][j] < 128) {
                    escuros++;
                } else {
                    claros++;
                }
            }
        }
        
        System.out.println("Pixels escuros (< 128): " + escuros);
        System.out.println("Pixels claros (>= 128): " + claros);
    }
}

Resumo da Aula