package tests;
/**
 * A class for testing JAI
 */

import uk.ac.leeds.ccg.grids.*;

import java.util.Enumeration;
import java.util.Hashtable;

import java.awt.Frame;
import java.awt.Rectangle;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.RenderingHints;

import java.awt.image.renderable.ParameterBlock;
import java.awt.image.Raster;
import java.awt.image.DataBuffer;
import java.awt.image.RenderedImage;
import java.awt.image.WritableRenderedImage;

import java.awt.image.SampleModel;
import java.awt.image.BandedSampleModel;
import java.awt.image.ComponentSampleModel;
import java.awt.image.MultiPixelPackedSampleModel;
import java.awt.image.PixelInterleavedSampleModel;
import java.awt.image.SinglePixelPackedSampleModel;

import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.PackedColorModel;

//import java.awt.image.BufferedImage;
//import java.awt.image.MemoryImageSource;

import java.io.IOException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedInputStream;

import javax.media.jai.Interpolation;
import javax.media.jai.JAI;
import javax.media.jai.RenderedOp;
import javax.media.jai.PlanarImage;
import javax.media.jai.widget.ScrollingImagePanel;
import javax.media.jai.iterator.RectIter;
import javax.media.jai.iterator.RectIterFactory;
import javax.media.jai.ImageLayout;
import javax.media.jai.TiledImage;
import javax.media.jai.Histogram;
import javax.media.jai.ROI;
import javax.media.jai.RasterFactory;
import javax.media.jai.operator.BandSelectDescriptor;
//import javax.media.jai.operator.*;

import javax.media.jai.remote.SerializableRenderedImage;

import com.sun.media.jai.codec.FileSeekableStream;
import com.sun.media.jai.codec.PNGEncodeParam;
import com.sun.media.jai.codec.ImageCodec;

public class TestJAI {
    
    double noDataValue;
    
    public TestJAI() {
    }
    
    public static void main(String[] args) {
        TestJAI testJAI = new TestJAI();
        testJAI.run();
    }
    
    public void run() {
        
        String dataDirectory0 = "d:/andyt/src/tests/data/";
        String dataDirectory1 = dataDirectory0 + "ESRIasciigrids/";
        String parent = "test_160x230_1.";
        //String parent = "test_400x400_1.";
        //String parent = "test_603x378_1.";
        String type = "asc";
        
        // Initialise an AbstractGrid2DSquareCellDouble grid0
        //AbstractGrid2DSquareCellDouble grid0 = ( new Grid2DSquareCellDoubleFileFactory( new File( dataDirectory0 + "Grids/" + parent + "grd" ) ) ).createGrid2DSquareCellDouble( new File( dataDirectory1 + parent + type ) );
        AbstractGrid2DSquareCellDouble grid0 = new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( new File( dataDirectory1 + parent + type ) );
        System.out.println( "grid0" );
        System.out.println( grid0.toString() );
        noDataValue = grid0.getNoDataValue();
        AbstractGrid2DSquareCellDouble grid1 = Grid2DSquareCellDoubleProcessor.geometricDensity( grid0, 8.0d * grid0.getCellsize() );
        System.out.println( "grid1" );
        System.out.println( grid1.toString() );
        grid0 = grid1;
        
        // Create an image from scratch and copy in data from AbstractGrid2DSquareCellDouble grid0
        int numBands = 1;
        //int dataType = DataBuffer.TYPE_BYTE;
        int dataType = DataBuffer.TYPE_DOUBLE;    // ImageEncoder not available
        //int dataType = DataBuffer.TYPE_FLOAT;     // ImageEncoder not available
        //int dataType = DataBuffer.TYPE_INT;       // ImageEncoder not available
        //int dataType = DataBuffer.TYPE_SHORT;     // Image Canvas unable to display
        //int dataType = DataBuffer.TYPE_UNDEFINED; // Unsupported
        //int dataType = DataBuffer.TYPE_USHORT;
        int tileWidth = 10;
        int tileHeight = 10;
        int width = grid0.getNcols();
        int height = grid0.getNrows();
        int minX = 0;
        int minY = 0;
        int tileGridXOffset = 0;
        int tileGridYOffset = 0;
        double double0;
        //ColorModel colorModel0 = PlanarImage.getDefaultColorModel( dataType, numBands );
        //SampleModel sampleModel0 = colorModel0.createCompatibleSampleModel( tileWidth, tileHeight );
        SampleModel sampleModel0 = RasterFactory.createBandedSampleModel( dataType, tileWidth, tileHeight, numBands );
        ColorModel colorModel0 = PlanarImage.createColorModel( sampleModel0 );
        //ColorModel colorModel0 = RasterFactory.createColorModel( sampleModel0 );
        RenderedImage image1 = new TiledImage( minX, minY, width, height, tileGridXOffset, tileGridYOffset, sampleModel0, colorModel0 );
        TiledImage image2 = ( TiledImage ) image1;
        int numYTiles = image1.getNumYTiles();
        int numXTiles = image1.getNumXTiles();
        double min = Double.MAX_VALUE;
        double max = Double.MIN_VALUE;
        for ( int y = 0; y < ( numYTiles * tileHeight ); y ++ ) {
            for ( int x = 0; x < ( numXTiles * tileWidth ); x ++ ) {
                for ( int band = 0; band < numBands; band ++ ) {
                    double0 = grid1.getCell( grid1.getCellID( y, x ) );
                    if ( double0 != noDataValue ) {
                        min = Math.min( min, double0 );
                        max = Math.max( max, double0 );
                    }
                    image2.setSample( x, y, band, double0 );
                }
            }
        }
        System.out.println( "min " + min );
        System.out.println( "max " + max );
        
        // Describe image2
        reportProperties( image2 );
        double[] extrema = getExtrema( image2 );
        System.out.println( "Extrema min " + extrema[ 0 ] );
        System.out.println( "Extrema max " + extrema[ 1 ] );
        
        // Write out image1 to filename
        dataDirectory1 = dataDirectory0 + "Images/";
        type = "jai";
        writeObject( image1, dataDirectory1 + parent + type );
        
        // Read object from filename
        image1 = ( RenderedImage ) readObject( dataDirectory1 + parent + type );
        
        // Test Some Values
        int row = 100;
        int col = 100;
        double[] pixel = new double[ 1 ];
        Raster raster0;
        System.out.println( "grid0 " + grid0.getCell( row, col ) );
        raster0 = image1.getData( new Rectangle( col, row, 1, 1 ) );
        pixel = raster0.getPixel( col, row, pixel );
        System.out.println( "image2 " + pixel[ 0 ] );
        row = 0;
        col = 0;
        System.out.println( "grid0 " + grid0.getCell( row, col ) );
        raster0 = image1.getData( new Rectangle( col, row, 1, 1 ) );
        pixel = raster0.getPixel( col, row, pixel );
        System.out.println( "image2 " + pixel[ 0 ] );
        
        // Iterate through the values using a RectIter
        //RectIter rectIter = RectIterFactory.create( tiledImage0, tiledImage.getBounds() );
        RectIter rectIter = RectIterFactory.create( image1, new Rectangle( image1.getMinX(), image1.getMinY(), image1.getWidth(), image1.getHeight() ) );
        int pixelCounter = 0;
        int lineCounter = 0;
        min = Double.MAX_VALUE;
        max = Double.MIN_VALUE;
        rectIter.startLines();
        while ( ! rectIter.finishedLines() ) {
            rectIter.startPixels();
            while ( ! rectIter.finishedPixels() ) {
                //System.out.println("pixelCounter " + pixelCounter );
                double0 = rectIter.getSampleDouble( 0 );
                rectIter.nextPixel();
                min = Math.min( min, double0 );
                max = Math.max( max, double0 );
                pixelCounter ++;
            }
            rectIter.nextLine();
            lineCounter ++;
            pixelCounter = 0;
        }
        System.out.println( "min " + min );
        System.out.println( "max " + max );
        
        // Rescale
        //image1 = rescaleAsShort( image1 );
        System.out.println( Short.MAX_VALUE );
        image1 = rescaleAsShort( image1, min , max  );
        
        // Describe image1
        reportProperties( image1 );
        extrema = getExtrema( image1 );
        System.out.println( "min " + extrema[ 0 ] );
        System.out.println( "max " + extrema[ 1 ] );
        
        // Display image3
        displayRenderedImage( image1 );
        
        
        /*
        // Create a RenderedImage from file
        //RenderedImage image0 = readImageFile( dataDirectory0 + "test0.png" );
         
        // Iterate through the values using a RectIter
        //RectIter rectIter = RectIterFactory.create( tiledImage0, tiledImage.getBounds() );
        RectIter rectIter = RectIterFactory.create( image1, new Rectangle( image1.getMinX(), image1.getMinY(), image1.getWidth(), image1.getHeight() ) );
        int pixelCounter = 0;
        int lineCounter = 0;
        min = Double.MAX_VALUE;
        max = Double.MIN_VALUE;
        rectIter.startLines();
        while ( ! rectIter.finishedLines() ) {
            rectIter.startPixels();
            while ( ! rectIter.finishedPixels() ) {
                System.out.println("pixelCounter " + pixelCounter );
                double0 = rectIter.getSampleDouble( band );
                rectIter.nextPixel();
                min = Math.min( min, double0 );
                max = Math.max( max, double0 );
                pixelCounter ++;
            }
            rectIter.nextLine();
            lineCounter ++;
            pixelCounter = 0;
        }
         
        // Iterate through each Tile
        for ( int thisYTile = 0; thisYTile < numYTiles; thisYTile ++ ) {
            for ( int thisXTile = 0; thisXTile < numXTiles; thisXTile ++ ) {
                raster0 = image0.getTile( thisXTile, thisYTile );
                width = raster0.getWidth();
                height = raster0.getHeight();
                minX = raster0.getMinX();
                minY = raster0.getMinY();
                for ( int thisY = minY ; thisY < minY + height; thisY ++ ) {
                    for ( int thisX = minX; thisX < minX + width; thisX ++ ) {
                        double0 = raster0.getSampleDouble( thisX, thisY, 0 );
                    }
                }
            }
        }
        
        // Test some values
        int[] nearestValuesCellIDs = grid0.getNearestValuesCellIDs( 100, 100 );
        int row;
        int col;
        double[] cellBounds;
        double cellsize = grid0.getCellsize();
        Raster raster0;
        int band = 0;
        for ( int i = 0; i < nearestValuesCellIDs.length; i ++ ) {
            row = grid0.getRowIndex( nearestValuesCellIDs[ i ] );
            col = grid0.getColIndex( nearestValuesCellIDs[ i ] );
            cellBounds = grid0.getCellBounds( row, col );
            System.out.println( "grid0 " + grid0.getCell( row, col ) );
            System.out.println( "image2 " + image2.getSampleDouble( col, row, band ) );
            //raster0 = image1.getData( new Rectangle( bounds[ 0 ], bounds[ 3 ], cellsize, cellsize ) );
            //raster0.g
        }
        
         */
        
    }
    
    /**
     * Returns a RenderedImage
     */
    public RenderedImage readImageFile( String filename ) {
        RenderedImage result = null;
        try {
            result = JAI.create( "stream", new FileSeekableStream( filename ) );
        } catch ( IOException e ) {
            e.printStackTrace();
            System.exit( 0 );
        }
        return result;
    }
    
    /**
     * Reports properties of image
     */
    public void reportProperties( RenderedImage image ) {
        String[] propertyNames = image.getPropertyNames();
        if ( propertyNames != null ) {
            for ( int property = 0; property < propertyNames.length; property ++ ) {
                System.out.println( propertyNames[ property ] + " " + ( image.getProperty( propertyNames[ property ] ) ).toString() );
            }
        }
    }
    public void reportProperties( RenderedOp op ) {
        String[] propertyNames = op.getPropertyNames();
        if ( propertyNames != null ) {
            for ( int property = 0; property < propertyNames.length; property ++ ) {
                System.out.println( propertyNames[ property ] + " " + ( op.getProperty( propertyNames[ property ] ) ).toString() );
            }
        }
    }
    
    /**
     * Display a RenderedImage
     */
    public void displayRenderedImage( RenderedImage image ) {
        ScrollingImagePanel panel = new ScrollingImagePanel( image, image.getWidth(), image.getHeight() );
        Frame window = new Frame( "Image" );
        window.add( panel );
        window.pack();
        window.show();
    }
    
    /**
     * Returns a TiledImage - a rescaled version of image to fit into range [ 0 - Short.MAX_VALUE ]
     */
    public RenderedImage rescaleAsShort( RenderedImage image ) {
        double[] extrema = getExtrema( image );
        return rescaleAsShort( image, extrema[ 0 ], extrema[ 1 ] );
    }
    
    /**
     * Returns a TiledImage - a rescaled version of image to fit into range [ 0 - Short.MAX_VALUE ]
     */
    public RenderedImage rescaleAsShort( RenderedImage image, double min, double max ) {
        Raster raster0 = null;
        double double0;
        int tileWidth = image.getTileWidth();
        int tileHeight = image.getTileHeight();
        int numYTiles = image.getNumYTiles();
        int numXTiles = image.getNumXTiles();
        int band = 0;
        int numBands = 1;
        int dataType = DataBuffer.TYPE_USHORT;
        int width = image.getWidth();
        int height = image.getHeight();
        int minX = image.getMinX();
        int minY = image.getMinY();
        int tileGridXOffset = 0;
        int tileGridYOffset = 0;
        SampleModel sampleModel = RasterFactory.createBandedSampleModel( dataType, tileWidth, tileHeight, numBands );
        ColorModel colorModel = PlanarImage.createColorModel( sampleModel );
        TiledImage result = new TiledImage( minX, minY, width, height, tileGridXOffset, tileGridYOffset, sampleModel, colorModel );
        for ( int thisYTile = 0; thisYTile < numYTiles; thisYTile ++ ) {
            for ( int thisXTile = 0; thisXTile < numXTiles; thisXTile ++ ) {
                raster0 = image.getTile( thisXTile, thisYTile );
                width = raster0.getWidth();
                height = raster0.getHeight();
                minX = raster0.getMinX();
                minY = raster0.getMinY();
                for ( int thisY = minY ; thisY < minY + height; thisY ++ ) {
                    for ( int thisX = minX; thisX < minX + width; thisX ++ ) {
                        double0 = raster0.getSampleDouble( thisX, thisY, 0 );
                        if ( double0 == min ) {
                            result.setSample( thisX, thisY, band, ( short ) 0 );
                        } else {
                            if ( double0 != noDataValue ) {
                                result.setSample( thisX, thisY, band, ( ( double0 - ( double ) min ) / ( double ) ( max - min ) ) * ( double ) Short.MAX_VALUE );
                            } else {
                                result.setSample( thisX, thisY, band, 0 );
                            }
                        }
                    }
                }
            }
        }
        return result;
    }
    
    /**
     * Returns Extrema of RenderedImage
     */
    public double[] getExtrema( RenderedImage image ) {
        double[] result = new double[ 2 ];
        ParameterBlock pb = new ParameterBlock();
        pb.addSource( image );
        pb.add( new ROI( image ) );        // Region of interest
        pb.add( 1 );                       // Horizontal sampling rate
        pb.add( 1 );                       // Vertical sampling rate
        RenderedOp renderedOp = JAI.create( "extrema", pb );
        //reportProperties( renderedOp );
        double[][] extrema = ( double[][] ) renderedOp.getProperty( "extrema" );
        result[ 0 ] = extrema[0][0];
        result[ 1 ] = extrema[1][0];
        return result;
    }
    
    /**
     *
     * imageType - image file format ("jpeg", "tiff", "png", "bmp", and others)
     */
    public void writeImageFile( RenderedImage image, String filename, String imageType ) {
        // Check codecs
        //Enumeration codecs = ImageCodec.getCodecs();
        //while ( codecs.hasMoreElements() ) {
        //    System.out.println( codecs.nextElement().toString() );
        //}
        ParameterBlock parameterBlock = new ParameterBlock();
        parameterBlock.addSource( image );
        parameterBlock.add( filename );
        parameterBlock.add( imageType );
        RenderingHints renderingHints = new RenderingHints( JAI.KEY_IMAGE_LAYOUT, new ImageLayout() );
        JAI.create( "filestore", parameterBlock, renderingHints );
    }
    
    
    /**
     * Write to jai object
     */
    public void writeObject( RenderedImage image, String filename ) {
        SerializableRenderedImage serializableRenderedImage = new SerializableRenderedImage( image );
        try {
            ObjectOutputStream oos = new ObjectOutputStream( new BufferedOutputStream( new FileOutputStream( filename ) ) );
            oos.writeObject( serializableRenderedImage );
            oos.flush();
            oos.close();
        } catch ( Exception e ) {
            e.printStackTrace();
            System.exit( -1 );
        }
    }
    
    /**
     * Read from jai object
     */
    public RenderedImage readObject( String filename ) {
        RenderedImage result = null;
        try {
            ObjectInputStream ois = new ObjectInputStream( new BufferedInputStream( new FileInputStream( filename ) ) );
            result = ( RenderedImage ) ois.readObject();
        } catch ( Exception e ) {
            e.printStackTrace();
            System.exit( -1 );
        }
        return result;
    }
    
}