Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.lib.legend.impl;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.raster.api.legend.ChangeColorInterpretationEvent;

import org.gvsig.fmap.mapcontext.raster.api.legend.ChangePaletteBandEvent;

import org.gvsig.fmap.mapcontext.raster.api.legend.ChangePaletteEvent;

import org.gvsig.fmap.mapcontext.raster.api.legend.RasterLegendEvent;

import org.gvsig.fmap.mapcontext.raster.api.legend.listeners.RasterLegendChangedListener;

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendContentsChangedListener;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.FilterList;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.raster.lib.legend.api.RasterLegend;

import org.gvsig.raster.lib.legend.api.Transparency;

import org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation;

import org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretationNotification;

import org.gvsig.raster.lib.legend.api.colortable.ColorTable;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

/**

 * Default implementation of {@link RasterLegend}. This object can draw buffers

 * with a {@link ColorInterpretation}, {@link ColorTable} and {@link FilterList}

 *

 *

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class DefaultRasterLegend implements RasterLegend {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultRasterLegend.class);

    private ColorInterpretation colorInterpretation;

    private Transparency transparency;

    private FilterList filters;

    private boolean transparentNoData;

    private List<RasterLegendChangedListener> listeners =

        new ArrayList<RasterLegendChangedListener>();

    /**

     * Persistence definition name

     */

    public static final String PERSISTENT_NAME = "RasterLegendPersistence";

    /**

     * Description of persistence definition

     */

    public static final String PERSISTENT_DESCRIPTION = "Persistence definition of raster legend";

    private final static String COLOR_INTERPRETATION_PERSISTENCE_FIELD = "colorInterpretation";

    private final static String FILTERS_PERSISTENCE_FIELD = "filters";

    /**

     * Empty constructor

     */

    public DefaultRasterLegend() {

    }

    /**

     * Default {@link RasterLegend} constructor

     *

     * @param colorInterpretation

     *            Color interpretation of legend

     */

    public DefaultRasterLegend(ColorInterpretation colorInterpretation) {

        setColorInterpretation(colorInterpretation);

    }

    /**

     * Default {@link RasterLegend} constructor

     *

     * @param colorTable

     *            Color table of legend

     * @param colorInterpretation

     *            Color interpretation of legend

     * @param transparency

     *            Transparency of legend

     * @param filters

     *            Filters of legend

     */

    public DefaultRasterLegend(ColorInterpretation colorInterpretation,

        Transparency transparency, FilterList filters) {

        this(colorInterpretation);

        this.transparency = transparency;

        this.filters = filters;

    }

    @Override

    public void draw(Graphics graphics, Buffer buffer, ViewPort viewPort,

        SimpleTaskStatus taskStatus) {

        boolean isMyTask = false;

        if (taskStatus == null) {

            TaskStatusManager taskStatusManager = ToolsLocator.getTaskStatusManager();

            taskStatus =

                taskStatusManager.createDefaultSimpleTaskStatus("_drawing_buffer_XxellipsisxX");

            taskStatus.setAutoremove(true);

            taskStatus.add();

            isMyTask = true;

        } else {

            taskStatus.push();

        }

        taskStatus.setIndeterminate();

        if (this.colorInterpretation == null || !this.colorInterpretation.hasInterpretation()

            || this.colorInterpretation.isUndefined()) {

            taskStatus.abort();

            throw new IllegalStateException(

                "To draw buffer, raster legend has to have a color interpretation");

        }

        // Check if viewport projection is the same as buffer projection

        Buffer clip = null;

        Buffer interpolated = null;

        Buffer converted = null;

        Buffer interpolated2 = null;

        Buffer bufferToDraw = buffer;

        try {

            if (bufferToDraw != null && bufferToDraw.getColumns()>0 && bufferToDraw.getRows()>0) {

                if (!viewPort.getProjection().equals(bufferToDraw.getProjection())) {

                    // Convert extension to check if envelopes intersect

                    ICoordTrans coordTrans = viewPort.getProjection().getCT(bufferToDraw.getProjection());

                    ICoordTrans invertedCoordTrans = bufferToDraw.getProjection().getCT(viewPort.getProjection());

                    Envelope convertedEnvelope = viewPort.getAdjustedEnvelope().convert(coordTrans);

                    double viewPortPixelSizeX = viewPort.getAdjustedEnvelope().getLength(0) / viewPort.getImageWidth();

                    double viewPortPixelSizeY = viewPort.getAdjustedEnvelope().getLength(1) / viewPort.getImageHeight();

                    if (!convertedEnvelope.intersects(bufferToDraw.getEnvelope())) {

                        return;

                    }

                    try {

                        // Clip buffer with doubled converted envelope

                        clip = bufferToDraw.clip(convertedEnvelope);

                        Envelope bufferEnvelopeInViewPortCoords = clip.getEnvelope().convert(invertedCoordTrans);

                        double widthPixel = bufferEnvelopeInViewPortCoords.getLength(0) / viewPortPixelSizeX;

                        double heightPixel = bufferEnvelopeInViewPortCoords.getLength(1) / viewPortPixelSizeY;

                        interpolated =

                            clip.createInterpolated((int) Math.floor(heightPixel), (int) Math.floor(widthPixel),

                                Buffer.INTERPOLATION_NearestNeighbour, taskStatus);

                        // Convert interpolated clipped buffer

                        converted = interpolated.convert(invertedCoordTrans, taskStatus);

                        widthPixel = getWidthPixel(converted.getEnvelope(), viewPortPixelSizeX);

                        heightPixel = getHeightPixel(converted.getEnvelope(), viewPortPixelSizeY);

                        interpolated2 =

                            converted.createInterpolated((int) Math.floor(heightPixel), (int) Math.floor(widthPixel),

                                Buffer.INTERPOLATION_NearestNeighbour, taskStatus);

                        bufferToDraw = interpolated2;

                    } catch (BufferException | LocatorException | CreateEnvelopeException e) {

                        LOG.warn("Buffer can not be clipped, converted or interpolated", e);

                        taskStatus.abort();

                        return;

                    }

                } else if (viewPort.getAdjustedEnvelope().intersects(bufferToDraw.getEnvelope())) {

                    double widthPixel = 0;

                    double heightPixel = 0;

                    try {

                        // Clip and interpolate buffer with view port envelope

                        if (!bufferToDraw.getEnvelope().equals(viewPort.getAdjustedEnvelope())) {

                            clip = bufferToDraw.clip(viewPort.getAdjustedEnvelope());

                            bufferToDraw = clip;

                        }

                        widthPixel =

                            getWidthPixel(bufferToDraw.getEnvelope(), viewPort.getAdjustedEnvelope().getLength(0)

                                / viewPort.getImageWidth());

                        heightPixel =

                            getHeightPixel(bufferToDraw.getEnvelope(), viewPort.getAdjustedEnvelope().getLength(1)

                                / viewPort.getImageHeight());

                        interpolated =

                            bufferToDraw.createInterpolated((int) Math.floor(heightPixel),

                                (int) Math.floor(widthPixel), Buffer.INTERPOLATION_NearestNeighbour, taskStatus);

                        bufferToDraw = interpolated;

                    } catch (BufferException e) {

                        LOG.warn(

                            "Buffer can not be interpolated with [rows: {} , columns: {}, method: {}]",

                            new String[] { String.valueOf((int) Math.floor(heightPixel)),

                                String.valueOf((int) Math.floor(widthPixel)),

                                String.valueOf(Buffer.INTERPOLATION_NearestNeighbour) });

                        taskStatus.abort();

                        return;

                    }

                } else {

                    // Do nothing view port envelope does not intersect with

                    // buffer

                    return;

                }

            }

            if (bufferToDraw != null && bufferToDraw.getColumns()>0 && bufferToDraw.getRows()>0) {

                // Draw buffer

                Image image = null;

                if (this.colorInterpretation.isPalette()) {

                    // Draw buffer with table color

                    image = drawPaletteBuffer(graphics, bufferToDraw, colorInterpretation, transparency, filters);

                } else if (this.colorInterpretation.hasAnyGrayBand()) {

                    // Draw buffer with gray scale

                    image = drawGrayBuffer(graphics, bufferToDraw, transparency, filters);

//                } else if (this.colorInterpretation.isRGBA() || this.colorInterpretation.isRGB()

//                    || this.colorInterpretation.isBGR() || this.colorInterpretation.hasRGBBands()) {

                } else if (this.colorInterpretation.hasAnyRGBBand()) {

                    // Draw RGB, RGBA or BGR buffer without color table

                    image = drawRGBBuffer(graphics, bufferToDraw, colorInterpretation, transparency, filters);

                } else if (this.colorInterpretation.hasAnyHSLBand()) {

                    // Draw HSL buffer without color table

                    image = drawHSLBuffer(graphics, bufferToDraw, colorInterpretation, transparency, filters);

                } else if (this.colorInterpretation.hasAnyCMYKBand()) {

                    // Draw CMYK buffer without color table

                    image = drawCMYKBuffer(graphics, bufferToDraw, colorInterpretation, transparency, filters);

                } else if (this.colorInterpretation.hasAnyYCBCRBand()) {

                    // Draw YCBCR buffer without color table

                    image = drawYCBCRBuffer(graphics, bufferToDraw, colorInterpretation, transparency, filters);

                }

                // Calculate where image has to be drawn

                double x = bufferToDraw.getEnvelope().getMinimum(0);

                double y = bufferToDraw.getEnvelope().getMaximum(1);

                AffineTransform affineTransform =

                    calculateAffineTransform(viewPort.getAdjustedEnvelope(), viewPort.getImageWidth(),

                        viewPort.getImageHeight());

                Point point;

                try {

                    point = GeometryLocator.getGeometryManager().createPoint(x, y, SUBTYPES.GEOM2D);

                    point.transform(affineTransform.createInverse());

                    graphics.drawImage(image, (int) Math.floor(point.getX()), (int) Math.floor(point.getY()), null);

                } catch (CreateGeometryException | NoninvertibleTransformException e) {

                    LOG.warn("Can not calculate the point of buffer in viewport image", e);

                    taskStatus.abort();

                    return;

                }

            }

        } catch (LocatorException | CreateEnvelopeException e1) {

            LOG.warn("Can not calculate the envelope of buffer", e1);

            taskStatus.abort();

            return;

        } finally {

            if (clip != null) {

                DisposeUtils.dispose(clip);

                clip = null;

            }

            if (interpolated != null) {

                DisposeUtils.dispose(interpolated);

                interpolated = null;

            }

            if (converted != null) {

                DisposeUtils.dispose(converted);

                converted = null;

            }

            if (interpolated2 != null) {

                DisposeUtils.dispose(interpolated2);

                interpolated2 = null;

            }

            if (bufferToDraw == null && bufferToDraw != buffer) {

                DisposeUtils.dispose(bufferToDraw);

                bufferToDraw = null;

            }

            if (!isMyTask) {

                taskStatus.pop();

            }

        }

    }

    private AffineTransform calculateAffineTransform(Envelope envelope, double imageWidth,

        double imageHeight) {

        double pixelSizeX = envelope.getLength(0) / imageWidth;

        double rotationX = 0;

        double x = envelope.getMinimum(0);

        double rotationY = 0;

        double pixelSizeY = -envelope.getLength(1) / imageHeight;

        double y = envelope.getMaximum(1);

        return new AffineTransform(pixelSizeX, rotationY, rotationX, pixelSizeY, x, y);

    }

    private double getWidthPixel(Envelope envelope, double dist1pixel) {

        double widthEnvelope = envelope.getLength(0);

        return widthEnvelope / dist1pixel;

    }

    private double getHeightPixel(Envelope envelope, double dist1pixel) {

        double heightEnvelope = envelope.getLength(1);

        return heightEnvelope / dist1pixel;

    }

    private Image drawRGBBuffer(Graphics graphics, Buffer buffer,

        ColorInterpretation colorInterpretation, Transparency transparency, FilterList filters) {

        BufferedImage image = null;

        if (colorInterpretation.isRGB() || colorInterpretation.isRGBA() || colorInterpretation.hasAnyRGBBand()) {

            image = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(buffer.getColumns(), buffer.getRows(),

                    BufferedImage.TYPE_INT_ARGB);

        } else if (colorInterpretation.isBGR()) {

            image = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(buffer.getColumns(), buffer.getRows(),

                BufferedImage.TYPE_INT_BGR);

        }

        if (image == null) {

            throw new IllegalStateException(

                "Color interpretation is not RGB,RGBA or BGR and buffer was be drawn without color table");

        }

        int redBandIndex = colorInterpretation.getBand(ColorInterpretation.RED_BAND);

        int greenBandIndex = colorInterpretation.getBand(ColorInterpretation.GREEN_BAND);

        int blueBandIndex = colorInterpretation.getBand(ColorInterpretation.BLUE_BAND);

        Band redBand = null;

        if(redBandIndex>=0){

            redBand = buffer.getBand(redBandIndex);

        }

        Band greenBand = null;

        if(greenBandIndex>=0){

            greenBand = buffer.getBand(greenBandIndex);

        }

        Band blueBand = null;

        if(blueBandIndex>=0){

            blueBand = buffer.getBand(blueBandIndex);

        }

        Band alphaBand = null;

        if (colorInterpretation.hasAlphaBand()) {

            int alphaBandIndex =

                colorInterpretation.getBand(ColorInterpretation.ALPHA_BAND);

            alphaBand = buffer.getBand(alphaBandIndex);

        }

//        Statistics statistics = buffer.getStatistics(null);

//        double[] max = statistics.getMax(); //Para pruebas con el rango de cada banda

//        double[] min = statistics.getMin(); //Para pruebas con el rango de cada banda

//        double maximum = statistics.getMaximun();  //Para pruebas con el rango conjunto de todas las bandas

//        double minimum = statistics.getMinimun(); //Para pruebas con el rango conjunto de todas las bandas

        for (int i = 0; i < buffer.getRows(); i++) {

            for (int j = 0; j < buffer.getColumns(); j++) {

//                Number redValue = (Number) redBand.get(i, j);

//                Number greenValue = (Number) greenBand.get(i, j);

//                Number blueValue = (Number) blueBand.get(i, j);

                /*FIXME:

                 * Aqu? necesitamos pasar los valores originales de la capa al rango de valores del tipo byte.

                 * Para hacer esto tendr?amos varias opciones:

                 *

                 * 1.- Como hace el raster viejo, una conversi?n lineal entre el rango de valores de la capa [MIN, MAX]

                 *     y el rango de valores de tipo byte [0 - 255] para lo cual necesitar?amos llamar aqu? a las estad?sticas.

                 *

                 * 2.- Una conversi?n lineal entre el rango de valores del tipo del Number concreto (p. ej. Short [-32768 - 32767],

                 *     Int [-2^31 - 2^31-1], etc...) y el rango de valores de tipo byte [0 - 255], pero cuando los valores

                 *     fueran relativamente peque?os se concentrar?an todos en el 0 y la capa saldr?a completamente negra.

                 *

                 * 3.- Una conversi?n logaritmica entre el rango de valores del tipo del Number concreto (p. ej. Short [-32768 - 32767],

                 *     Int [-2^31 - 2^31-1], etc...) y el rango de valores de tipo byte [0 - 255], esto evitar?a la

                 *     concentraci?n de la mayor?a de valores en el 0.

                 *

                 * 4.- Y una mejor opci?n ser?a la conversi?n (linear o logaritm?tca, por decidir) entre el rango de valores

                 *     del "sensor" con el que se han tomado los datos y el rango de valores de tipo byte [0 - 255], pero

                 *     , por lo menos por ahora, no tenemos informaci?n sobre el sensor.

                 *

                 * Hago pruebas de las tres primeras opciones, comentarizando dos y dejando activa la otra,

                 * pero es algo a pensar con detenimiento.

                 */

                int alphaByteValue = 255;

                int redByteValue = 0;

                if(redBand!=null){

                    Number redValue = (Number) redBand.get(i, j);

                    NoData noData = redBand.getNoData();

                    if(noData != null){

                        if(redValue.equals(noData.getValue())){

                            alphaByteValue = 0;

                            redByteValue = 0;

                        } else {

                            alphaByteValue = 255;

                            redByteValue = logarithmicConversionToByteRange(redValue);

                        }

                    } else {

                        redByteValue = logarithmicConversionToByteRange(redValue);

                    }

//                byte redByteValue = logarithmicConversionToByte(redValue,max[redBandIndex]);

//                byte redByteValue = linearConversionToByte(redValue);

//                    redByteValue = proportionalConversionToByte(redValue, max[redBandIndex], min[redBandIndex]);

//                byte redByteValue = proportionalConversionToByte(redValue, maximum, minimum); //1

                }

                int greenByteValue = 0;

                if(greenBand!=null){

                    Number greenValue = (Number) greenBand.get(i, j);

                    NoData noData = greenBand.getNoData();

                    if(noData != null){

                        if(greenValue.equals(noData.getValue())){

                            alphaByteValue = 0;

                            greenByteValue = 0;

                        } else {

                            alphaByteValue = 255;

                            greenByteValue = logarithmicConversionToByteRange(greenValue);

                        }

                    } else {

                        greenByteValue = logarithmicConversionToByteRange(greenValue);

                    }

//                byte greenByteValue = logarithmicConversionToByte(greenValue,max[greenBandIndex]);

//                byte greenByteValue = linearConversionToByte(greenValue);

//                    greenByteValue = proportionalConversionToByte(greenValue, max[greenBandIndex], min[greenBandIndex]);

//                byte greenByteValue = proportionalConversionToByte(greenValue, maximum, minimum);

                }

                int blueByteValue = 0;

                if(blueBand!=null){

                    Number blueValue = (Number) blueBand.get(i, j);

                    NoData noData = blueBand.getNoData();

                    if(noData != null){

                        if(blueValue.equals(noData.getValue())){

                            alphaByteValue = 0;

                            blueByteValue = 0;

                        } else {

                            alphaByteValue = 255;

                            blueByteValue = logarithmicConversionToByteRange(blueValue);

                        }

                    } else {

                        blueByteValue = logarithmicConversionToByteRange(blueValue);

                    }

//                byte blueByteValue = logarithmicConversionToByte(blueValue,max[blueBandIndex]);

//                byte blueByteValue = linearConversionToByte(blueValue);

//                    blueByteValue = proportionalConversionToByte(blueValue, max[blueBandIndex], min[blueBandIndex]);

//                byte blueByteValue = proportionalConversionToByte(blueValue, maximum, minimum);

                }

                if (alphaByteValue!=0 && alphaBand != null) {

                    Number alphaValue = (Number) alphaBand.get(i, j);

                    int alphaBandIndex = colorInterpretation.getBand(ColorInterpretation.ALPHA_BAND);

//                    alphaByteValue = logarithmicConversionToByte(alphaValue);

                    NoData noData = alphaBand.getNoData();

                    if(noData != null){

                        if(alphaValue.equals(noData.getValue())){

                            alphaByteValue = 0;

                        } else {

                            alphaByteValue = logarithmicConversionToByteRange(alphaValue);

                        }

                    } else {

                        alphaByteValue = logarithmicConversionToByteRange(alphaValue);

                    }

//                    alphaByteValue = logarithmicConversionToByte(alphaValue,max[alphaBandIndex]);

//                    alphaByteValue = linearConversionToByte(alphaValue);

//                    alphaByteValue = proportionalConversionToByte(alphaValue, max[alphaBandIndex], min[alphaBandIndex]);

//                    alphaByteValue = proportionalConversionToByte(alphaValue, maximum, minimum);

//                    LOG.info("alphaValue = "+alphaValue+ " alphaByteValue = "+alphaByteValue);

                }

                if (alphaByteValue!=0 && transparency != null) {

                    // Apply defined transparency ranges

                    int newAlpha =

                        transparency.getTransparencyRangeAlpha(redByteValue,

                            greenByteValue, blueByteValue);

                    alphaByteValue = getNewAlpha(alphaByteValue, newAlpha);

                    // Apply general transparency

                    int transparencyValue = transparency.getAlpha();

                    alphaByteValue = getNewAlpha(alphaByteValue, transparencyValue);

                }

                if (filters != null) {

                    // TODO Apply filters

                }

                int intRGB = 0;

                if (colorInterpretation.hasAnyRGBBand()) {//colorInterpretation.isRGB() || colorInterpretation.isRGBA()) {

                    intRGB = (((byte)alphaByteValue & 0xFF) << 24) | // alpha

                        (((byte)redByteValue & 0xFF) << 16) | // red

                        (((byte)greenByteValue & 0xFF) << 8) | // green

                        (((byte)blueByteValue & 0xFF)); // blue String.format("%X", b)

//                    intRGB = ((alphaByteValue & 0xFF) << 24) | // alpha

//                        ((redByteValue & 0xFF) << 16) | // red

//                        ((greenByteValue & 0xFF) << 8) | // green

//                        ((blueByteValue & 0xFF) << 0); // blue String.format("%X", b)

                } else if (colorInterpretation.isBGR()) {

                    intRGB = (((byte)blueByteValue & 0xFF) << 16 | // blue

                        (((byte)greenByteValue & 0xFF) << 8) | // green

                        (((byte)redByteValue & 0xFF))); // red

                }

                image.setRGB(j, i, intRGB);

            }

        }

        return image;

    }

    /**

     * Conversi?n logaritmica de los valores del dominio de entrada a valores del dominio de BYTE

     * para poder ser representados en RGB.

     *

     * @param n

     * @return

     */

    private int logarithmicConversionToByteRange(Number n) {

        int b = 0;

        if (n instanceof Byte) {

            b = n.byteValue();

            if(b<0){

                b=256+b;

            }

        } else if (n instanceof Short) {

            // Because Math.log(Short.MAX_VALUE-Short.MIN_VALUE)/Math.log(256) = 2;

            b = (new Double(Math.round(Math.pow(n.shortValue(), 1d / 2d)))).intValue();

        } else if (n instanceof Integer) {

            // Because

            // Math.log(Integer.MAX_VALUE/256-Integer.MIN_VALUE/256)/Math.log(256) = 4;

            b = (new Double(Math.round(Math.pow(n.intValue(), 1d / 4d)))).intValue();

        } else if (n instanceof Float) {

            // Because Math.log(Float.MAX_VALUE-Float.MIN_VALUE)/Math.log(256) = 16;

            double root = 16d; // Math.log(Float.MAX_VALUE-Float.MIN_VALUE)/Math.log(256);

            b = (new Double(Math.round(Math.pow(n.floatValue(), 1d / root)))).intValue();

        } else if (n instanceof Double) {

            // Because Math.log(Double.MAX_VALUE-Double.MIN_VALUE)/Math.log(256) = 128;

            double root = 128d;

            b = (new Double(Math.round(Math.pow(n.doubleValue(), 1d / root)))).intValue();

        }

        return b;

    }

    /**

     * Conversi?n logaritmica de los valores del dominio de entrada a valores del dominio de BYTE

     * para poder ser representados en RGB.

     * Aplica un factor de correcci?n que depende de los valores de entrada.

     *

     * @param n

     * @param max

     * @return

     */

    private int logarithmicConversionToByteRange(Number n, double max) {

        int b = 0;

        if (n instanceof Byte) {

            b = n.byteValue();

            if(b<0){

                b=256+b;

            }

        } else if (n instanceof Short) {

            short value = n.shortValue();

            double factor = Short.MAX_VALUE / max;

            // Because Math.log(Short.MAX_VALUE-Short.MIN_VALUE)/Math.log(256) = 2;

            double root = 2d;

            b = (new Double(Math.round(Math.pow(value, 1d / root)*factor))).intValue();

        } else if (n instanceof Integer) {

            int value = n.intValue();

            double factor = Integer.MAX_VALUE / max;

            // Because Math.log(Integer.MAX_VALUE/256-Integer.MIN_VALUE/256)/Math.log(256) = 4;

            double root = 4d;

            b = (new Double(Math.round(Math.pow(value, 1d / root)*factor))).intValue();

        } else if (n instanceof Float) {

            float value = n.floatValue();

            double factor = Float.MAX_VALUE / max;

            // Because Math.log(Float.MAX_VALUE-Float.MIN_VALUE)/Math.log(256) = 16;

            double root = 16d;

            b = (new Double(Math.round(Math.pow(value, 1d / root)*factor))).intValue();

        } else if (n instanceof Double) {

            double value = n.doubleValue();

            double factor = Double.MAX_VALUE / max;

            // Because Math.log(Double.MAX_VALUE-Double.MIN_VALUE)/Math.log(256) = 128;

            double root = 128d;

            b = (new Double(Math.round(Math.pow(value, 1d / root)*factor))).intValue();

        }

        return b;

    }

    /**

     * Conversi?n lineal de los valores del dominio de entrada a valores del dominio de BYTE

     * para poder ser representados en RGB.

     *

     * @param n

     * @return

     */

    private int linearConversionToByteRange(Number n){

        int b=0;

        if(n instanceof Byte){

            b = n.byteValue();

            if(b<0){

                b=256+b;

            }

        } else if(n instanceof Short){

            // 65536/256 = 256

            b = (new Double(n.shortValue()/256)).intValue();

        } else if(n instanceof Integer){

            //  (Integer.MAX_VALUE-Integer.MIN_VALUE)/256 = 16777215

            b = (new Double(n.intValue()/16777215)).intValue();

        } else if(n instanceof Float){

            //  (Float.MAX_VALUE-Float.MIN_VALUE)/256 = 1.3292279E36

            b = (new Double(n.floatValue()/1.3292279E36)).intValue();

        } else if(n instanceof Double){

            //  (Double.MAX_VALUE-Double.MIN_VALUE)/256 = 7.022238808055921E305;

            b = (new Double(n.doubleValue()/7.022238808055921E305)).intValue();

        }

        return b;

    }

    /**

     * Conversi?n lineal de los valores de entrada a valores del dominio de BYTE

     * para poder ser representados en RGB.

     * Depende del rango de valores del buffer a representar.

     *

     * @param n

     * @param maximum

     * @param minimum

     * @return

     */

    private int proportionalConversionToByteRange(Number n, double maximum, double minimum){

        int b=0;

        double ratio = (maximum-minimum)/256;

        if(n instanceof Byte){

            b = n.byteValue();

            if(b<0){

                b=256+b;

            }

        } else if(n instanceof Short){

            // 65536/256 = 256

            b = (new Double((n.shortValue()-minimum)/ratio)).intValue();

        } else if(n instanceof Integer){

            //  (Integer.MAX_VALUE-Integer.MIN_VALUE)/256 = 16777215

            b = (new Double((n.intValue()-minimum)/ratio)).intValue();

        } else if(n instanceof Float){

            //  (Float.MAX_VALUE-Float.MIN_VALUE)/256 = 1.3292279E36

            b = (new Double((n.floatValue()-minimum)/ratio)).intValue();

        } else if(n instanceof Double){

            //  (Double.MAX_VALUE-Double.MIN_VALUE)/256 = 7.022238808055921E305;

            b = (new Double((n.doubleValue()-minimum)/ratio)).intValue();

        }

        return b;

    }

    private Image drawHSLBuffer(Graphics graphics, Buffer buffer,

        ColorInterpretation colorInterpretation,Transparency transparency,

        FilterList filters) {

        BufferedImage image = null;

        image = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(buffer.getColumns(), buffer.getRows(),

            BufferedImage.TYPE_INT_ARGB);

        int hueBandIndex = colorInterpretation.getBand(ColorInterpretation.HUE_BAND);

        int saturationBandIndex = colorInterpretation.getBand(ColorInterpretation.SATURATION_BAND);

        int lightBandIndex = colorInterpretation.getBand(ColorInterpretation.LIGHTNESS_BAND);

        Band hueBand = buffer.getBand(hueBandIndex);

        Band saturationBand = buffer.getBand(saturationBandIndex);

        Band lightBand = buffer.getBand(lightBandIndex);

        for (int i = 0; i < buffer.getRows(); i++) {

            for (int j = 0; j < buffer.getColumns(); j++) {

                Number hueValue = (Number) hueBand.get(i, j);

                Number saturationValue = (Number) saturationBand.get(i, j);

                Number lightValue = (Number) lightBand.get(i, j);

                Number[] rgbaValues=ColorUtils.fromHSLtoRGBA(hueValue.floatValue(), saturationValue.floatValue(), lightValue.floatValue());

                Integer alphaValue =rgbaValues[3].intValue();

                if (transparency != null) {

                    // Apply defined transparency ranges

                    alphaValue = alphaValue.byteValue() & 0xFF;

                    int newAlpha =

                        transparency.getTransparencyRangeAlpha(rgbaValues[0].byteValue(),

                            rgbaValues[1].byteValue(), rgbaValues[2].byteValue());

                    alphaValue = getNewAlpha(alphaValue.intValue(), newAlpha);

                    // Apply general transparency

                    int transparencyValue = transparency.getAlpha();

                    alphaValue = getNewAlpha(alphaValue.intValue(), transparencyValue);

                }

                if (filters != null) {

                    // TODO Apply filters

                }

                int intRGB = 0;

                intRGB = ((alphaValue.byteValue() & 0xFF) << 24) | // alpha

                    ((rgbaValues[0].byteValue() & 0xFF) << 16) | // red

                    ((rgbaValues[1].byteValue() & 0xFF) << 8) | // green

                    ((rgbaValues[2].byteValue() & 0xFF) << 0); // blue

                image.setRGB(j, i, intRGB);

            }

        }

        return image;

    }

    private Image drawCMYKBuffer(Graphics graphics, Buffer buffer,

        ColorInterpretation colorInterpretation,Transparency transparency,

        FilterList filters) {

        BufferedImage image = null;

        image = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(buffer.getColumns(), buffer.getRows(),

            BufferedImage.TYPE_INT_ARGB);

        int cyanBandIndex = colorInterpretation.getBand(ColorInterpretation.CYAN_BAND);

        int magentaBandIndex = colorInterpretation.getBand(ColorInterpretation.MAGENTA_BAND);

        int yellowBandIndex = colorInterpretation.getBand(ColorInterpretation.YELLOW_BAND);

        int blackBandIndex = colorInterpretation.getBand(ColorInterpretation.BLACK_BAND);

        Band cyanBand = buffer.getBand(cyanBandIndex);

        Band magentaBand = buffer.getBand(magentaBandIndex);

        Band yellowBand = buffer.getBand(yellowBandIndex);

        Band blackBand = buffer.getBand(blackBandIndex);

        for (int i = 0; i < buffer.getRows(); i++) {

            for (int j = 0; j < buffer.getColumns(); j++) {

                Number cyanValue = (Number) cyanBand.get(i, j);

                Number magentaValue = (Number) magentaBand.get(i, j);

                Number yellowValue = (Number) yellowBand.get(i, j);

                Number blackValue = (Number) blackBand.get(i, j);

                Number[] rgbValues=ColorUtils.fromCMYKtoRGB(

                    cyanValue.floatValue(),

                    magentaValue.floatValue(),

                    yellowValue.floatValue(),

                    blackValue.floatValue()

                    );

                Integer alphaValue =255;

                if (transparency != null) {

                    // Apply defined transparency ranges

                    alphaValue = alphaValue.byteValue() & 0xFF;

                    int newAlpha =

                        transparency.getTransparencyRangeAlpha(rgbValues[0].byteValue(),

                            rgbValues[1].byteValue(), rgbValues[2].byteValue());

                    alphaValue = getNewAlpha(alphaValue.intValue(), newAlpha);

                    // Apply general transparency

                    int transparencyValue = transparency.getAlpha();

                    alphaValue = getNewAlpha(alphaValue.intValue(), transparencyValue);

                }

                if (filters != null) {

                    // TODO Apply filters

                }

                int intRGB = 0;

                intRGB = ((alphaValue.byteValue() & 0xFF) << 24) | // alpha

                    ((rgbValues[0].byteValue() & 0xFF) << 16) | // red

                    ((rgbValues[1].byteValue() & 0xFF) << 8) | // green

                    ((rgbValues[2].byteValue() & 0xFF) << 0); // blue

                image.setRGB(j, i, intRGB);

            }

        }

        return image;

    }

    private Image drawYCBCRBuffer(Graphics graphics, Buffer buffer,

        ColorInterpretation colorInterpretation,Transparency transparency,

        FilterList filters) {

        BufferedImage image = null;

        image = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(buffer.getColumns(), buffer.getRows(),

            BufferedImage.TYPE_INT_ARGB);

        int yIndex = colorInterpretation.getBand(ColorInterpretation.YCBCR_Y_BAND);

        int cbBandIndex = colorInterpretation.getBand(ColorInterpretation.YCBCR_CB_BAND);

        int crBandIndex = colorInterpretation.getBand(ColorInterpretation.YCBCR_CR_BAND);

        Band yBand = buffer.getBand(yIndex);

        Band cbBand = buffer.getBand(cbBandIndex);

        Band crBand = buffer.getBand(crBandIndex);

        for (int i = 0; i < buffer.getRows(); i++) {

            for (int j = 0; j < buffer.getColumns(); j++) {

                Number yValue = (Number) yBand.get(i, j);

                Number cbValue = (Number) cbBand.get(i, j);

                Number crValue = (Number) crBand.get(i, j);

                Number[] rgbValues=ColorUtils.fromYCBCRtoRGB(

                    yValue.floatValue(),

                    cbValue.floatValue(),

                    crValue.floatValue()

                    );

                Integer alphaValue =255;

                if (transparency != null) {

                    // Apply defined transparency ranges

                    alphaValue = alphaValue.byteValue() & 0xFF;

                    int newAlpha =

                        transparency.getTransparencyRangeAlpha(rgbValues[0].byteValue(),

                            rgbValues[1].byteValue(), rgbValues[2].byteValue());

                    alphaValue = getNewAlpha(alphaValue.intValue(), newAlpha);

                    // Apply general transparency

                    int transparencyValue = transparency.getAlpha();

                    alphaValue = getNewAlpha(alphaValue.intValue(), transparencyValue);

                }

                if (filters != null) {

                    // TODO Apply filters

                }

                int intRGB = 0;

                intRGB = ((alphaValue.byteValue() & 0xFF) << 24) | // alpha

                    ((rgbValues[0].byteValue() & 0xFF) << 16) | // red

                    ((rgbValues[1].byteValue() & 0xFF) << 8) | // green

                    ((rgbValues[2].byteValue() & 0xFF) << 0); // blue

                image.setRGB(j, i, intRGB);

            }

        }

        return image;

    }

    /**

     * Method to draw gray buffers

     * @param graphics

     * @param buffer

     * @param filters

     * @return

     */

    private Image drawGrayBuffer(Graphics graphics, Buffer buffer, Transparency transparency, FilterList filters) {

        BufferedImage image = null;

        image = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(buffer.getColumns(), buffer.getRows(),

            BufferedImage.TYPE_INT_ARGB);

        Band greyBand = buffer.getBand(0);

//        Statistics statistics = buffer.getStatistics(null);

//        double maximum = statistics.getMaximun();// ver drawRGBBuffer

//        double minimum = statistics.getMinimun();

        for (int i = 0; i < buffer.getRows(); i++) {

            for (int j = 0; j < buffer.getColumns(); j++) {

                int greyByteValue = 0;

                int alphaByteValue = (byte)255;

                Number greyValue = (Number) greyBand.get(i, j);

                NoData noData = greyBand.getNoData();

                if(noData != null){

                    if(greyValue.equals(noData.getValue())){

                        alphaByteValue = 0;

                        greyByteValue = 0;

                    } else {

                        alphaByteValue = 255;

                        greyByteValue = logarithmicConversionToByteRange(greyValue);

                    }

                } else {

                    greyByteValue = logarithmicConversionToByteRange(greyValue);

                }

//                byte greyByteValue = linearConversionToByte(greyValue);

//                byte greyByteValue = proportionalConversionToByte(greyValue, maximum, minimum); // 1

//                byte greyByteValue = logarithmicConversionToByte(greyValue);

//                byte greyByteValue = logarithmicConversionToByte(greyValue, maximum);

                if (alphaByteValue != 0 && transparency != null) {

                    // Apply defined transparency ranges

//                    alphaByteValue = alphaValue.byteValue() & 0xFF;

                    int newAlpha = transparency.getTransparencyRangeAlpha(greyByteValue, greyByteValue, greyByteValue);

                    alphaByteValue = getNewAlpha(alphaByteValue, newAlpha);

                    // Apply general transparency

                    int transparencyValue = transparency.getAlpha();

                    alphaByteValue = getNewAlpha(alphaByteValue, transparencyValue);

                }

                if (filters != null) {

                    // TODO Apply filters

                }

                int intARGB = (((byte)alphaByteValue & 0xFF) << 24) | // alpha

                    (((byte)greyByteValue & 0xFF)<< 16) | // red

                    (((byte)greyByteValue & 0xFF)<< 8) | // green

                    (((byte)greyByteValue & 0xFF)); // blue

                image.setRGB(j, i, intARGB);

            }

        }

        return image;

    }

    private Image drawPaletteBuffer(Graphics graphics, Buffer buffer, ColorInterpretation colorInterpretation,

        Transparency transparency, FilterList filters) {

        BufferedImage image = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(buffer.getColumns(), buffer.getRows(),

            BufferedImage.TYPE_INT_ARGB);

        for (int i = 0; i < buffer.getRows(); i++) {

            for (int j = 0; j < buffer.getColumns(); j++) {

                Object value = buffer.getBand(colorInterpretation.getPaletteBand()).get(i, j);

                byte[] rgba = colorInterpretation.getPalette().getRGBA(value);

                if (transparency != null) {

                    // Apply defined transparency ranges

                    int alpha = rgba[3] & 0xFF;

                    int newAlpha =

                        transparency.getTransparencyRangeAlpha(rgba[0], rgba[1], rgba[2]);

                    alpha = getNewAlpha(alpha, newAlpha);

                    // Apply general transparency

                    int transparencyValue = transparency.getAlpha();

                    rgba[3] = (byte) getNewAlpha(alpha, transparencyValue);

                }

                if (filters != null) {

                    // TODO Apply filters

                }

                int intARGB = ((rgba[3] & 0xFF) << 24) | // alpha

                    ((rgba[0] & 0xFF) << 16) | // red

                    ((rgba[1] & 0xFF) << 8) | // green

                    ((rgba[2] & 0xFF) << 0); // blue

                image.setRGB(j, i, intARGB);

            }

        }

        return image;

    }

    private int getNewAlpha(int alpha, int newAlpha) {

        return (int) Math.round(alpha * (newAlpha / 255d));

    }

    @Override

    public ColorInterpretation getColorInterpretation() {

        return this.colorInterpretation;

    }

    @Override

    public void setColorInterpretation(ColorInterpretation colorInterpretation) {

        if(this.colorInterpretation!=null){

            this.colorInterpretation.deleteObserver(this);

        }

        this.colorInterpretation = colorInterpretation;

        this.colorInterpretation.addObserver(this);

    }

    @Override

    public FilterList getFilters() {

        return this.filters;

    }

    @Override

    public void setFilters(FilterList filterList) {

        this.filters = filterList;

    }

    /**

     *

     */

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

        if (definition == null) {

            definition =

                manager.addDefinition(DefaultRasterLegend.class, PERSISTENT_NAME,

                    PERSISTENT_DESCRIPTION, null, null);

            definition.addDynFieldObject(COLOR_INTERPRETATION_PERSISTENCE_FIELD).setMandatory(false)

                .setClassOfValue(ColorInterpretation.class);

            definition.addDynFieldObject(FILTERS_PERSISTENCE_FIELD).setMandatory(false)

                .setClassOfValue(FilterList.class);

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(COLOR_INTERPRETATION_PERSISTENCE_FIELD, this.getColorInterpretation());

        state.set(FILTERS_PERSISTENCE_FIELD, this.filters);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.setColorInterpretation((ColorInterpretation) state

            .get(COLOR_INTERPRETATION_PERSISTENCE_FIELD));

        this.setFilters((FilterList) state.get(FILTERS_PERSISTENCE_FIELD));

    }

    @Override

    public void setTransparency(Transparency transparency) {

        this.transparency = transparency;

    }

    @Override

    public Transparency getTransparency() {

        return this.transparency;

    }

    @Override

    public ISymbol getDefaultSymbol() {

        return null;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultRasterLegend cloned = (DefaultRasterLegend) super.clone();

        ColorInterpretation clonedColorInterpretation = (ColorInterpretation)this.getColorInterpretation().clone();

        cloned.setColorInterpretation(clonedColorInterpretation);

        //FIXME:

        //cloned.setTransparency((Transparency)this.getTransparency().clone());

        //cloned.setFilters(getFilters());

        return cloned;

    }

    @Override

    public ILegend cloneLegend() {

        try {

            return (RasterLegend)this.clone();

        } catch (Exception e) {

            throw new RuntimeException("Can't clone the legend", e);

        }

    }

    @Override

    public void fireDefaultSymbolChangedEvent(SymbolLegendEvent event) {

        for (int i = 0; i < listeners.size(); i++) {

            ((LegendContentsChangedListener) listeners.get(i))

                    .symbolChanged(event);

        }

    }

    @Override

    public LegendContentsChangedListener[] getListeners() {

        return (LegendContentsChangedListener[]) listeners

                .toArray(new LegendContentsChangedListener[listeners.size()]);

    }

    @Override

    public void setTransparentNoData(boolean noDataTransparent) {

        this.transparentNoData=noDataTransparent;

    }

    @Override

    public boolean areTransparentNoData() {

        return this.transparentNoData;

    }

    @Override

    public void update(Observable observable, Object notification) {

        if (notification instanceof ColorInterpretationNotification) {

            String type = ((ColorInterpretationNotification) notification).getType();

            if(type.equals(ColorInterpretationNotification.CHANGED_COLOR_INTERPRETATION_VALUE)

               || type.equals(ColorInterpretationNotification.ADDED_COLOR_INTERPRETATION)

               || type.equals(ColorInterpretationNotification.COPIED_FROM_COLOR_INTERPRETATION)){

            fireColorinterpretationChangedEvent(new ChangeColorInterpretationEvent(

                (String[])((ColorInterpretationNotification) notification).getValue(0),

                (String[])((ColorInterpretationNotification) notification).getValue(1)));

            }

            if (type.equals(ColorInterpretationNotification.SETTED_PALETTE)) {

                fireColorinterpretationChangedEvent(new ChangePaletteEvent(

                    (ColorTable) ((ColorInterpretationNotification) notification).getValue(0),

                    (ColorTable) ((ColorInterpretationNotification) notification).getValue(1)));

            }

            if (type.equals(ColorInterpretationNotification.CHANGED_PALETTE)) {

                fireColorinterpretationChangedEvent(new ChangePaletteEvent(

                    (ColorTable) ((ColorInterpretationNotification) notification).getValue(0),

                    (ColorTable) ((ColorInterpretationNotification) notification).getValue(0)));

            }

            if (type.equals(ColorInterpretationNotification.SETTED_PALETTE_BAND)) {

                fireColorinterpretationChangedEvent(new ChangePaletteBandEvent(

                    (int) ((ColorInterpretationNotification) notification).getValue(0),

                    (int) ((ColorInterpretationNotification) notification).getValue(1)));

            }

        }

    }

    public void fireColorinterpretationChangedEvent(RasterLegendEvent event) {

        for (int i = 0; i < listeners.size(); i++) {

            ((RasterLegendChangedListener) listeners.get(i)).colorInterpretationChanged(event);

        }

    }

    @Override

    public void addLegendListener(LegendContentsChangedListener listener) {

        if(listener instanceof RasterLegendChangedListener){

            addLegendListener((RasterLegendChangedListener)listener);

            return;

        }

        throw new UnsupportedOperationException("Raster layer can't be listened by a no RasterLegendChangedListener");

    }

    @Override

    public void removeLegendListener(LegendContentsChangedListener listener) {

        if(listener instanceof RasterLegendChangedListener){

            removeLegendListener((RasterLegendChangedListener)listener);

            return;

        }

        throw new UnsupportedOperationException("Raster layer can't be listened by a no RasterLegendChangedListener");

    }

    private void addLegendListener(RasterLegendChangedListener listener) {

        if (listener != null && !listeners.contains(listener))

            listeners.add(listener);

    }

    private void removeLegendListener(RasterLegendChangedListener listener) {

        listeners.remove(listener);

    }

}