package ch6;

import java.awt.*;
import java.awt.image.*;
import javax.swing.*;
import java.io.*;
import java.net.*;
import java.awt.image.renderable.ParameterBlock;
import javax.media.jai.RenderedOp;
import javax.media.jai.JAI;
import com.sun.media.jai.codec.SeekableStream;

/**
   ImageLoadTester -- loads an image using the JAI class' create method.
   This method uses 3 different operator names to load the image
   in 3 different manners, namely "stream", "fileload" and "url"

   It then prints out the properties of the loaded image
 */
public class ImageLoadTester extends JFrame {

    public ImageLoadTester(String filename) {
        SeekableStream stream = null;
        URL url = null;

        try {
            url = new URL("file:"+filename);
            stream = SeekableStream.wrapInputStream(url.openStream(),
                                                    false);
        }
        catch (IOException ioe) {
            System.err.println("IOException: " + ioe.getMessage());
        }

        params = new ParameterBlock();
        params.add(stream);
        RenderedOp streamImage = JAI.create("stream", params);

        params = new ParameterBlock();
        params.add(filename);
        RenderedOp fileImage = JAI.create("fileload", params);

        params = new ParameterBlock();
        params.add(url);
        RenderedOp urlImage = JAI.create("url", params);

        //Display Image Properties
        String[] props = streamImage.getPropertyNames();
        for (int i=0;i<props.length;i++) {
            System.out.print("Property: " + props[i] + ", ");
            System.out.println(streamImage.getProperty(props[i]));
        }

        getContentPane().setLayout(new GridLayout(1, 3));
        getContentPane().add(new ch6Display(streamImage));
        getContentPane().add(new ch6Display(fileImage));
        getContentPane().add(new ch6Display(urlImage));

        pack();
        show();
    }

    public static void main(String[] args) {
       if (args.length != 1)
            System.err.println("USAGE:  ImageLoadTester filename");
        else
            new ImageLoadTester(args[0]);
    }
    private ParameterBlock params;
}
						

package ch6;

import javax.media.jai.*;
import java.awt.*;
import java.awt.color.*;
import java.awt.image.*;
import java.awt.image.renderable.*;
import javax.swing.*;
import java.io.*;

/**
   FloatViewer.java - reads a image file composes of float values,
   scales it for display purposes and displays it.

   This image file can be composed of any number of different images
   as long as they are the same dimensions (referred to as tileWidth
   and tileHeight);
*/
public class FloatViewer extends JFrame {
    public FloatViewer(String filename, String tileWidth,
                       String tileHeight) {
        File f = new File(filename);
        if ( !(f.exists()) ) {
            System.err.println("File: " + filename + " does not exist ");
            System.exit(1);
        }
        this.tileWidth = Integer.parseInt(tileWidth);
        this.tileHeight = Integer.parseInt(tileHeight);

        float[][] dataArray = getData(f);
        PlanarImage inputImage = getTiledImage(dataArray);

        double scaleFactor = findScale(inputImage);
        ParameterBlock pb = new ParameterBlock();
        pb.addSource(inputImage);
        pb.add(new double[] {1.0/scaleFactor});
        pb.add(new double[] {0.0});

        RenderedOp scaledImage = JAI.create("rescale", pb);
        getContentPane().setLayout(new BorderLayout());
        getContentPane().add(new JScrollPane(new ch6Display(scaledImage)),
                             BorderLayout.CENTER);

        show();
        pack();
    }

    /**
       provides a scale factor for displaying the image data.
    */
    private double findScale(PlanarImage pi) {
        ParameterBlock pb = new ParameterBlock();
        pb.addSource(pi);
        PlanarImage pi2 = JAI.create("extrema", pb);
        double[] maximum = (double[])pi2.getProperty("maximum");
        double maxValue = maximum[0];
        return maxValue/2.0;
    }

    /**
       reads the image data from the file and stores it in an
       array of javax.media.jai.DataBufferFloat elements
       with each tile being stored in a
       separate javax.media.jai.DataBufferFloat element.
    */
    private float[][] getData(File file) {
        numberFloats = (int)(file.length()/4); //4 bytes per float
        numberFloatsPerTile = tileWidth*tileHeight;
        numberTiles = numberFloats/numberFloatsPerTile;

        float[][] floatArray = null;
        floatArray = new float[numberTiles][numberFloats];

        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedInputStream bis;
            bis = new BufferedInputStream(fis, numberFloatsPerTile*4);
            DataInputStream dis = new DataInputStream(bis);
            for (int i=0;i<numberTiles;i++) {
                for (int j=0;j<numberFloatsPerTile;j++)
                    floatArray[i][j] = dis.readFloat();
            }
            dis.close();
        }
        catch (IOException ioe) {
            System.err.println("IO Exception: " + ioe.getMessage());
            System.exit(1);
        }
        return floatArray;
    }

    /**
       creates a TiledImage from an array of
       javax.media.jai.DataBufferFloats
    */
    private PlanarImage getTiledImage(float[][] dataArray) {
        int numberHorizontalTiles;
        int numberVerticalTiles;

        // calculate number of tiles per column and per row
        double tmp = Math.sqrt((double)numberTiles);
        numberVerticalTiles = (int)tmp;
        numberHorizontalTiles = numberTiles/numberVerticalTiles;
        while (numberHorizontalTiles*numberVerticalTiles < numberTiles)
            numberHorizontalTiles++;

        imageWidth = numberHorizontalTiles*tileWidth;
        imageHeight = numberVerticalTiles*tileHeight;

        SampleModel inputImageSM;
        int dt = DataBuffer.TYPE_FLOAT;
        inputImageSM = RasterFactory.createBandedSampleModel(dt,
                                                             tileWidth,
                                                             tileHeight,
                                                             1);

        ColorModel inputImageCM;
        inputImageCM = PlanarImage.createColorModel(inputImageSM);

        /*
          create TiledImage -- note that the tile dimensions come from
          the SampleModel
        */
        TiledImage ti = new TiledImage(0, 0,
                                       imageWidth, imageHeight,
                                       0, 0,
                                       inputImageSM,
                                       inputImageCM);

        // now load the data into the TiledImage
        WritableRaster wr;
        int index = 0;
        for (int j=0;j<numberVerticalTiles;j++)
            for (int i=0;i<numberHorizontalTiles;i++)
                if (index < numberTiles) {
                    wr = ti.getWritableTile(i, j);
                    wr.setPixels(i*tileWidth, j*tileHeight,
                                 tileWidth, tileHeight,
                                 dataArray[index]);
                    index++;
                }
        return ti;
    }


    static public void main(String[] args) {
        if (args.length != 3) {
            System.err.print("USAGE:  FloatViewer ");
            System.err.println("floatImageFile tileWidth tileHeight");
        }
        else
            new FloatViewer(args[0], args[1], args[2]);
    }

    private int numberFloats;
    private int numberTiles;
    private int numberFloatsPerTile;
    private int tileWidth;
    private int tileHeight;
    private int imageWidth;
    private int imageHeight;
}