/*
 * $RCSfile: PiecewiseOpImage.java,v $
 *
 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
 *
 * Use is subject to license terms.
 *
 * $Revision: 1.1 $
 * $Date: 2005/02/11 04:56:40 $
 * $State: Exp $
 */
package com.lightcrafts.media.jai.opimage;

import com.lightcrafts.mediax.jai.ColormapOpImage;
import java.awt.Rectangle;
import java.awt.image.DataBuffer;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.WritableRaster;
import com.lightcrafts.mediax.jai.ImageLayout;
import com.lightcrafts.mediax.jai.LookupTableJAI;
import com.lightcrafts.mediax.jai.RasterAccessor;
import com.lightcrafts.mediax.jai.RasterFormatTag;
import java.util.Map;
import com.lightcrafts.media.jai.util.ImageUtil;

/**
 * An <code>OpImage</code> implementing the "Piecewise" operation.
 *
 * <p> The "Piecewise" operation maps the pixel values of an image using
 * a piecewise linear function represented by a set of breakpoints for each
 * band. The abscissa of each breakpoint is the source image gray level for
 * the band in question and the ordinate is the destination image gray level
 * to which it is mapped.
 *
 * @see com.lightcrafts.mediax.jai.operator.PiecewiseDescriptor
 * @see PiecewiseCRIF
 *
 *
 * @since EA4
 */
final class PiecewiseOpImage extends ColormapOpImage {
    /** The abscissas of the breakpoints. */
    private float[][] abscissas;

    /** The slope at each abscissa. */
    private float[][] slopes;

    /** The intercept at each abscissa. */
    private float[][] intercepts;

    /** The minimum values of the output per band. */
    private float[] minOrdinates;

    /** The maximum values of the output per band. */
    private float[] maxOrdinates;

    /** Flag indicating byte data. */
    private boolean isByteData = false;

    /** A lookup table for use in the case of byte data. */
    private LookupTableJAI lut;

    /**
     * Find the ordinate value for a given abscissa value.
     *
     * @param x The abscissa array.
     * @param minValue The minimum source gray level in the breakpoint set.
     * @param maxValue The maximum source gray level in the breakpoint set.
     * @param a The array of piecewise slopes.
     * @param b The array of piecewise ordinate intercepts.
     * @param value The source gray level.
     * @return The destination gray level.
     */
    private static float binarySearch(float[] x,
                                      float minValue, float maxValue,
                                      float[] a, float[] b,
                                      float value) {
        int highIndex = x.length - 1;

        if(value <= x[0]) {
            return minValue;
        } else if(value >= x[highIndex]) {
            return maxValue;
        }

        int lowIndex = 0;
        int deltaIndex = highIndex - lowIndex;

        while(deltaIndex > 1) {
            int meanIndex = lowIndex + deltaIndex/2;
            if(value >= x[meanIndex]) {
                lowIndex = meanIndex;
            } else {
                highIndex = meanIndex;
            }
            deltaIndex = highIndex - lowIndex;
        }

        return a[lowIndex]*value + b[lowIndex];
    }

    /**
     * Constructor.
     *
     * @param source       The source image.
     * @param layout       The destination image layout.
     * @param breakpoints  The piecewise mapping stored by reference. The
     * arrays breakpoints[b][0] and breakpoints[b][1] represent the abscissas
     * and ordinates of the breakpoints, respectively, for band <i>b</i>. The
     * number of sets of breakpoints must be one or equal to the number of
     * image bands.
     */
    public PiecewiseOpImage(RenderedImage source,
                            Map config,
                            ImageLayout layout,
                            float[][][] breakpoints) {
        super(source, layout, config, true);

        // Ensure that the number of sets of breakpoints is either unity
        // or equal to the number of bands.
        int numBands = sampleModel.getNumBands();

        // Initalize the instance variables.
        initFields(numBands, breakpoints);

        // Set the byte data flag.
        isByteData = sampleModel.getTransferType() == DataBuffer.TYPE_BYTE;

        // Perform byte-specific initialization.
        if(isByteData) {
            // Initialize the lookup table.
            createLUT();

            // Clear the other instance variables for the garbage collector.
            unsetFields();
        }

        // Set flag to permit in-place operation.
        permitInPlaceOperation();

        // Initialize the colormap if necessary.
        initializeColormapOperation();
    }

    /**
     * Transform the colormap according to the rescaling parameters.
     */
    protected void transformColormap(byte[][] colormap) {

	byte byteTable[][] = lut.getByteData();

        for(int b = 0; b < 3; b++) {
            byte[] map = colormap[b];
	    byte[] luTable = byteTable[b >= byteTable.length ? 0 : b];
            int mapSize = map.length;

            for(int i = 0; i < mapSize; i++) {
                map[i] = luTable[(map[i] & 0xFF)];
            }
        }
    }

    /**
     * Initialize various instance variables from the array of breakpoints.
     * The principal derived values are the slope and ordinate-intercept of
     * each piecewise segment.
     *
     * @param numBands The number of bands in the image.
     * @param The breakpoints as breakpoints[numBands][0..1][numPoints].
     */
    private void initFields(int numBands, float[][][] breakpoints) {
        abscissas = new float[numBands][];
        slopes = new float[numBands][];
        intercepts = new float[numBands][];
        minOrdinates = new float[numBands];
        maxOrdinates = new float[numBands];

        for(int band = 0; band < numBands; band++) {
            abscissas[band] = breakpoints.length == 1 ?
                breakpoints[0][0] : breakpoints[band][0];
            int maxIndex = abscissas[band].length - 1;

            minOrdinates[band] = breakpoints.length == 1 ?
                breakpoints[0][1][0] : breakpoints[band][1][0];
            maxOrdinates[band] = breakpoints.length == 1 ?
                breakpoints[0][1][maxIndex] : breakpoints[band][1][maxIndex];

            slopes[band] = new float[maxIndex];
            intercepts[band] = new float[maxIndex];

            float[] x =  abscissas[band];
            float[] y =  breakpoints.length == 1 ?
                breakpoints[0][1] : breakpoints[band][1];
            float[] a = slopes[band];
            float[] b = intercepts[band];
            for(int i1 = 0; i1 < maxIndex; i1++) {
                int i2 = i1 + 1;
                a[i1] = (y[i2]-y[i1])/(x[i2] - x[i1]);
                b[i1] = y[i1] - x[i1]*a[i1];
            }
        }
    }

    
    /**
     * Clear all instance fields which are ununsed references so the GC
     * may clear them.
     */
    private void unsetFields() {
        abscissas = null;
        slopes = null;
        intercepts = null;
        minOrdinates = null;
        maxOrdinates = null;
    }

    /**
     * Create a lookup table to be used in the case of byte data.
     */
    private void createLUT() {
        // Allocate memory for the data array references.
        int numBands = abscissas.length;
        byte[][] data = new byte[numBands][];

        // Generate the data for each band.
        for(int band = 0; band < numBands; band++) {
            // Allocate memory for this band.
            data[band] = new byte[256];

            // Cache the references to avoid extra indexing.
            byte[] table = data[band];
            float[] x = abscissas[band];
            float[] a = slopes[band];
            float[] b = intercepts[band];
            float yL = minOrdinates[band];
            float yH = maxOrdinates[band];

            // Initialize the lookup table data.
            for(int value = 0; value < 256; value++) {
                table[value] =
                    ImageUtil.clampRoundByte(binarySearch(x, yL, yH, a, b, value));
            }
        }

        // Construct the lookup table.
        lut = new LookupTableJAI(data);
    }

    /**
     * Piecewises to the pixel values within a specified rectangle.
     *
     * @param sources   Cobbled sources, guaranteed to provide all the
     *                  source data necessary for computing the rectangle.
     * @param dest      The tile containing the rectangle to be computed.
     * @param destRect  The rectangle within the tile to be computed.
     */
    protected void computeRect(Raster[] sources,
                               WritableRaster dest,
                               Rectangle destRect) {
        // Retrieve format tags.
        RasterFormatTag[] formatTags = getFormatTags();

        if(isByteData) {
            computeRectByte(sources, dest, destRect);
        } else {
            RasterAccessor dst =
                new RasterAccessor(dest, destRect, formatTags[1],
                                   getColorModel());
            RasterAccessor src =
                new RasterAccessor(sources[0], destRect, formatTags[0],
                                   getSource(0).getColorModel());

            switch (dst.getDataType()) {
            case DataBuffer.TYPE_USHORT:
                computeRectUShort(src, dst);
                break;
            case DataBuffer.TYPE_SHORT:
                computeRectShort(src, dst);
                break;
            case DataBuffer.TYPE_INT:
                computeRectInt(src, dst);
                break;
            case DataBuffer.TYPE_FLOAT:
                computeRectFloat(src, dst);
                break;
            case DataBuffer.TYPE_DOUBLE:
                computeRectDouble(src, dst);
                break;
            }

            dst.copyDataToRaster();
        }
    }

    private void computeRectByte(Raster[] sources,
                                 WritableRaster dest,
                                 Rectangle destRect) {
        lut.lookup(sources[0], dest, destRect);
    }

    private void computeRectUShort(RasterAccessor src,
                                   RasterAccessor dst) {
        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();

        int dstLineStride = dst.getScanlineStride();
        int dstPixelStride = dst.getPixelStride();
        int[] dstBandOffsets = dst.getBandOffsets();
        short[][] dstData = dst.getShortDataArrays();

        int srcLineStride = src.getScanlineStride();
        int srcPixelStride = src.getPixelStride();
        int[] srcBandOffsets = src.getBandOffsets();
        short[][] srcData = src.getShortDataArrays();

        for (int b = 0; b < dstBands; b++) {
            short[] d = dstData[b];
            short[] s = srcData[b];

            int dstLineOffset = dstBandOffsets[b];
            int srcLineOffset = srcBandOffsets[b];

            // Cache the references to avoid extra indexing.
            float[] x = abscissas[b];
            float[] gain = slopes[b];
            float[] bias = intercepts[b];
            float yL = minOrdinates[b];
            float yH = maxOrdinates[b];

            for (int h = 0; h < dstHeight; h++) {
                int dstPixelOffset = dstLineOffset;
                int srcPixelOffset = srcLineOffset;

                dstLineOffset += dstLineStride;
                srcLineOffset += srcLineStride;

                for (int w = 0; w < dstWidth; w++) {
                    d[dstPixelOffset] =
                        ImageUtil.clampRoundUShort(binarySearch(x, yL, yH, gain, bias,
                                                      s[srcPixelOffset] &
                                                      0xFFFF));

                    dstPixelOffset += dstPixelStride;
                    srcPixelOffset += srcPixelStride;
                }
            }
        }
    }

    private void computeRectShort(RasterAccessor src,
                                  RasterAccessor dst) {
        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();

        int dstLineStride = dst.getScanlineStride();
        int dstPixelStride = dst.getPixelStride();
        int[] dstBandOffsets = dst.getBandOffsets();
        short[][] dstData = dst.getShortDataArrays();

        int srcLineStride = src.getScanlineStride();
        int srcPixelStride = src.getPixelStride();
        int[] srcBandOffsets = src.getBandOffsets();
        short[][] srcData = src.getShortDataArrays();

        for (int b = 0; b < dstBands; b++) {
            short[] d = dstData[b];
            short[] s = srcData[b];

            int dstLineOffset = dstBandOffsets[b];
            int srcLineOffset = srcBandOffsets[b];

            // Cache the references to avoid extra indexing.
            float[] x = abscissas[b];
            float[] gain = slopes[b];
            float[] bias = intercepts[b];
            float yL = minOrdinates[b];
            float yH = maxOrdinates[b];

            for (int h = 0; h < dstHeight; h++) {
                int dstPixelOffset = dstLineOffset;
                int srcPixelOffset = srcLineOffset;

                dstLineOffset += dstLineStride;
                srcLineOffset += srcLineStride;

                for (int w = 0; w < dstWidth; w++) {
                    d[dstPixelOffset] =
                        ImageUtil.clampRoundShort(binarySearch(x, yL, yH, gain, bias,
                                                     s[srcPixelOffset]));

                    dstPixelOffset += dstPixelStride;
                    srcPixelOffset += srcPixelStride;
                }
            }
        }
    }

    private void computeRectInt(RasterAccessor src,
                                RasterAccessor dst) {
        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();

        int dstLineStride = dst.getScanlineStride();
        int dstPixelStride = dst.getPixelStride();
        int[] dstBandOffsets = dst.getBandOffsets();
        int[][] dstData = dst.getIntDataArrays();

        int srcLineStride = src.getScanlineStride();
        int srcPixelStride = src.getPixelStride();
        int[] srcBandOffsets = src.getBandOffsets();
        int[][] srcData = src.getIntDataArrays();

        for (int b = 0; b < dstBands; b++) {
            int[] d = dstData[b];
            int[] s = srcData[b];

            int dstLineOffset = dstBandOffsets[b];
            int srcLineOffset = srcBandOffsets[b];

            // Cache the references to avoid extra indexing.
            float[] x = abscissas[b];
            float[] gain = slopes[b];
            float[] bias = intercepts[b];
            float yL = minOrdinates[b];
            float yH = maxOrdinates[b];

            for (int h = 0; h < dstHeight; h++) {
                int dstPixelOffset = dstLineOffset;
                int srcPixelOffset = srcLineOffset;

                dstLineOffset += dstLineStride;
                srcLineOffset += srcLineStride;

                for (int w = 0; w < dstWidth; w++) {
                    d[dstPixelOffset] =
                        ImageUtil.clampRoundInt(binarySearch(x, yL, yH, gain, bias,
                                                   s[srcPixelOffset]));

                    dstPixelOffset += dstPixelStride;
                    srcPixelOffset += srcPixelStride;
                }
            }
        }
    }

    private void computeRectFloat(RasterAccessor src,
                                  RasterAccessor dst) {
        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();

        int dstLineStride = dst.getScanlineStride();
        int dstPixelStride = dst.getPixelStride();
        int[] dstBandOffsets = dst.getBandOffsets();
        float[][] dstData = dst.getFloatDataArrays();

        int srcLineStride = src.getScanlineStride();
        int srcPixelStride = src.getPixelStride();
        int[] srcBandOffsets = src.getBandOffsets();
        float[][] srcData = src.getFloatDataArrays();

        for (int b = 0; b < dstBands; b++) {
            float[] d = dstData[b];
            float[] s = srcData[b];

            int dstLineOffset = dstBandOffsets[b];
            int srcLineOffset = srcBandOffsets[b];

            // Cache the references to avoid extra indexing.
            float[] x = abscissas[b];
            float[] gain = slopes[b];
            float[] bias = intercepts[b];
            float yL = minOrdinates[b];
            float yH = maxOrdinates[b];

            for (int h = 0; h < dstHeight; h++) {
                int dstPixelOffset = dstLineOffset;
                int srcPixelOffset = srcLineOffset;

                dstLineOffset += dstLineStride;
                srcLineOffset += srcLineStride;

                for (int w = 0; w < dstWidth; w++) {
                    d[dstPixelOffset] =
                        binarySearch(x, yL, yH, gain, bias,
                                     s[srcPixelOffset]);

                    dstPixelOffset += dstPixelStride;
                    srcPixelOffset += srcPixelStride;
                }
            }
        }
    }

    private void computeRectDouble(RasterAccessor src,
                                   RasterAccessor dst) {
        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();

        int dstLineStride = dst.getScanlineStride();
        int dstPixelStride = dst.getPixelStride();
        int[] dstBandOffsets = dst.getBandOffsets();
        double[][] dstData = dst.getDoubleDataArrays();

        int srcLineStride = src.getScanlineStride();
        int srcPixelStride = src.getPixelStride();
        int[] srcBandOffsets = src.getBandOffsets();
        double[][] srcData = src.getDoubleDataArrays();

        for (int b = 0; b < dstBands; b++) {
            double[] d = dstData[b];
            double[] s = srcData[b];

            int dstLineOffset = dstBandOffsets[b];
            int srcLineOffset = srcBandOffsets[b];

            // Cache the references to avoid extra indexing.
            float[] x = abscissas[b];
            float[] gain = slopes[b];
            float[] bias = intercepts[b];
            float yL = minOrdinates[b];
            float yH = maxOrdinates[b];

            for (int h = 0; h < dstHeight; h++) {
                int dstPixelOffset = dstLineOffset;
                int srcPixelOffset = srcLineOffset;

                dstLineOffset += dstLineStride;
                srcLineOffset += srcLineStride;

                for (int w = 0; w < dstWidth; w++) {
                    d[dstPixelOffset] =
                        binarySearch(x, yL, yH, gain, bias,
                                     (float)s[srcPixelOffset]);

                    dstPixelOffset += dstPixelStride;
                    srcPixelOffset += srcPixelStride;
                }
            }
        }
    }
}