Visualizar imagem .raw

[Guest --marcjr --]

Eu preciso exibir uma imagem .RAW que processei no código abaixo. Alguém pode me ajudar?

Eu coloquei a imagem raw no atributo fileIn usando a classe RandomAcessFile. Depois, li o arquivo fileIn através do método readUnsignedByte() e coloquei os dados em uma matriz de inteiros: int img[ ][ ] para serem manipulados.

Alguém possui algum código para exibir uma imagem raw a partir de uma matriz de inteiros?

import java.awt.image.*;
import javax.imageio.*;
import java.io.*;

public class ConvolutionHighPassFilter
{
    public int i, j, m, n;
    public int pixel,correctSum;
    public int filterDim, lenFilterDim;
    public int bound,height = -1, width = -1;
    public int img[][];
    public String source, destination;
    RandomAccessFile fileIn,fileOut;

    public ConvolutionHighPassFilter(String source, String height, String width, 
            String filterDim, String destination){
        try{ 

                this.height = Integer.parseInt(height);
                this.width = Integer.parseInt(width);
                
                this.filterDim = Integer.parseInt(filterDim);
                this.source = source;
                this.destination = destination;
                fileIn = new RandomAccessFile (this.source,"r");
                fileOut = new RandomAccessFile (this.destination,"rw");
             
                i = j = m = n = 0;
                pixel = correctSum = 0;

                img = new int[this.width][this.height];
                bound = 0;
         }
            catch(Exception e){System.out.println("Error constructor");}   
     }//End Constructor
    

    //coeficiente calculado
    public void highPassFilter(){
     try {

            int Tmp[][] = new int[width][height];
            int Filter[][] = new int[filterDim][filterDim];

            lenFilterDim = filterDim*filterDim;
            bound = filterDim/2;

            //Lê imagem e preenche img e Tmp com seus valores
            for(i = 0; i < width; i++)
                for(j = 0; j < height; j++)
                    img[i][j] = Tmp[i][j] = fileIn.readUnsignedByte();

            //CRIAR CLASSE OU MÉTODO PARA O FILTRO
            for(i = 0; i < filterDim; i++)
                for(j = 0; j < filterDim; j++)
                    Filter[i][j] = i - bound; //coeficiente = ...-2 -1 0 1 2...

            for(i = bound; i < width - bound; i++){
                for(j = bound; j < (height - bound); j++)
                {
                    pixel = 0;
                    for(m = 0; m < filterDim; m++)
                        for(n = 0; n < filterDim; n++)
                            pixel += Filter[m][n] * 
                                    Tmp[m + i - bound][n + j - bound];

                    pixel = pixel/lenFilterDim;
                    correctSum = ((pixel >= 0) && (pixel < 256) ? pixel : 255);
                    img[i][j] = correctSum;
                }
            }

            for(i = 0; i < width; i++)
                for(j = 0; j < height; j++)
                    fileOut.writeByte(img[i][j]);

            fileOut.close();
            
        }
        catch (Exception e) {
            System.out.println("Error convolution");}
    
   
    }//End highPassFilter() Method
    
    

    public static void main(String[] args) 
    {
        System.out.println("Begin...");
                               
        ConvolutionHighPassFilter test = 
//                new ConvolutionHighPassFilter(args[0],args[1],args[2],args[3],args[4]);
                new ConvolutionHighPassFilter(“c:/512.raw”,”512”,”512”,”5”,”c:/512Processed.raw”);

        test.highPassFilter();
        
                
        System.out.println("Finish...");
    }
} //public class Convolucao

[iSoron]

Aqui um exemplo:

import javax.swing.*;
import java.awt.*;
import java.util.*;

public class Imagem extends JFrame
{
    boolean raw[][];
    
    public Imagem()
    {
        setSize(512, 512);
        raw = new boolean[512][512];
        setResizable(false);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Preenche o vetor raw com uma imagem qualquer
        Random r = new Random();
        for(int i=0; i<512; i++) {
            for(int j=0; j<512; j++) {
                raw[i][j] = i > j;
                if(r.nextInt(100) > 90) raw[i][j] = !raw[i][j];
            }
        }
    }

    public void paint(Graphics g) {
        for(int i=0; i<512; i++) {
            for(int j=0; j<512; j++) {
                if(raw[i][j]) g.fillRect(i, j, 1, 1);
            }
        }
    }

    public static void main(String args[]) {
        Imagem i = new Imagem();
        i.setVisible(true);
    }
}