imagewrapper.java

iage compression DWT en java

/*
 * Created on 16 f関r. 2005
 *
 */
package wavelet_compressor;
import java.awt.*;
import java.awt.image.*;
/**
 * 
 *
 * Encapsulate an image with possibly multiple channels
 */
public class ImageWrapper {

	private float[][] ChannelR;
	private float[][] ChannelG;
	private float[][] ChannelB;
	private int nb_channels;
	private int n;

	public ImageWrapper( int n_ ) 
	{
		n = n_;
		ChannelR = new float[n][n];
		ChannelG = new float[n][n];
		ChannelB = new float[n][n];
	}
	
	public int GetSize()
	{
		return n;
	}
	
	/**
	 * Read the values from the image
	 */
	public void SetPixels(Image img)
	{
		int[] b = new int[n*n];
		PixelGrabber pg = new PixelGrabber(img, 0, 0, n, n, b, 0, n);
		// grab values
		try {
		    pg.grabPixels();
		} catch (InterruptedException e) {
		    System.err.println("interrupted waiting for pixels!");
		    return;
		}
		if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
		    System.err.println("image fetch aborted or errored");
		    return;
		}
		/* copy the value */
		for( int i=0; i<n; ++i )
			for( int j=0; j<n; ++j )
			{
				float[] v = assign_int2rgb( b[i+n*j] );
				ChannelR[i][j] = v[0];
				ChannelG[i][j] = v[1];
				ChannelB[i][j] = v[2];
			}
	}
	
	
	
	/**
	 * Write the values back to the image
	 */
	public int[] GetPixels(boolean is_wavelet, int nb_j )
	{
		float[][] ChannelR1 = null;
		float[][] ChannelG1 = null;
		float[][] ChannelB1 = null;
		if( is_wavelet )
		{
			ChannelR1 = WaveletCompressor.rescale_wavelet( WaveletCompressor.abs_matrix(ChannelR,n), n, nb_j, 255, 0 );
			ChannelG1 = WaveletCompressor.rescale_wavelet( WaveletCompressor.abs_matrix(ChannelG,n), n, nb_j, 255, 0 );
			ChannelB1 = WaveletCompressor.rescale_wavelet( WaveletCompressor.abs_matrix(ChannelB,n), n, nb_j, 255, 0 );
		}
		else
		{
			ChannelR1 = WaveletCompressor.truncate( WaveletCompressor.abs_matrix(ChannelR,n), n, 0, 255 );
			ChannelG1 = WaveletCompressor.truncate( WaveletCompressor.abs_matrix(ChannelG,n), n, 0, 255 );
			ChannelB1 = WaveletCompressor.truncate( WaveletCompressor.abs_matrix(ChannelB,n), n, 0, 255 );
		}
		/* then flush back */
		int[] pix = new int[n*n];
		for( int i=0; i<n; ++i )
			for( int j=0; j<n; ++j )
				pix[i+n*j] = assign_rgb2int( ChannelR1[i][j], ChannelG1[i][j], ChannelB1[i][j] );
		return pix;
	}
	
	public void PerformWaveletTransform( ImageWrapper I, WaveletCompressor WC, int nb_j )
	{
		// transform each channel
		ChannelR = WC.perform_wavelet_transform_direct( I.ChannelR, n, nb_j);
		ChannelG = WC.perform_wavelet_transform_direct( I.ChannelG, n, nb_j);
		ChannelB = WC.perform_wavelet_transform_direct( I.ChannelB, n, nb_j);
	}
	public void PerformWaveletTransformInv( ImageWrapper I, WaveletCompressor WC, int nb_j )
	{
		// transform each channel
		ChannelR = WC.perform_wavelet_transform_inverse( I.ChannelR, n, nb_j);
		ChannelG = WC.perform_wavelet_transform_inverse( I.ChannelG, n, nb_j);
		ChannelB = WC.perform_wavelet_transform_inverse( I.ChannelB, n, nb_j);
	}
	public void PerformKeepCoefs( ImageWrapper I, float T )
	{
		// transform each channel
		ChannelR = WaveletCompressor.threshold( I.ChannelR, n, T);
		ChannelG = WaveletCompressor.threshold( I.ChannelG, n, T);
		ChannelB = WaveletCompressor.threshold( I.ChannelB, n, T);
	}
	
	public float[] ComputeThreshList(int nb)
	{
		float[] val = new float[3*n*n];
		int k = 0;
		for( int i=0; i<n; ++i )
			for( int j=0; j<n; ++j )
			{
				val[k] = Math.abs( ChannelR[i][j] );
				k++;
			}
		for( int i=0; i<n; ++i )
			for( int j=0; j<n; ++j )
			{
				val[k] = Math.abs( ChannelG[i][j] );
				k++;
			}
		for( int i=0; i<n; ++i )
			for( int j=0; j<n; ++j )
			{
				val[k] = Math.abs( ChannelB[i][j] );
				k++;
			}
		java.util.Arrays.sort(val);
		// set up the threshold
		float[] ThreshList = new float[nb+1];
		float nb_coef = (float) 3*n*n;
		for( int i=0; i<=nb; ++i )
		{
			int num = (int) ( ((float) 1.0 - ((float)i)/((float)nb) )*( nb_coef-1.0 ) );
			ThreshList[i] = val[num]; 
		}
		// little hack to keep at leas one coef 
		return ThreshList;
	}

	 private float[] assign_int2rgb(int pixel) 
	 {
	 	float[] v = new float[3];
		int alpha = (pixel >> 24) & 0xff;
		v[0]   = (pixel >> 16) & 0xff;
		v[1] = (pixel >>  8) & 0xff;
		v[2]  = (pixel      ) & 0xff;
		return v;
	 }
	 private int assign_rgb2int(float r, float g, float b) 
	 {
	 	int red = (int) r;
	 	int green = (int) g;
	 	int blue = (int) b;
	 	int alpha = 255;
	 	return (alpha << 24) | (red << 16) | (green << 8) | blue;
	 }
	
}