Application: gvSIG desktop » gvSIG raster

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

import java.awt.Graphics;

import java.awt.Image;

import java.awt.color.ColorSpace;

import java.awt.color.ICC_ColorSpace;

import java.awt.color.ICC_Profile;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.image.BufferedImage;

import org.apache.log4j.spi.AppenderAttachable;

import org.cresques.cts.ICoordTrans;

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

import org.gvsig.fmap.geom.GeometryLocator;

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.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.exceptions.BufferException;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 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 ColorTable colorTable;

    private Transparency transparency;

    private FilterList filters;

    /**

     * 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_TABLE_PERSISTENCE_FIELD = "colorTable";

    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) {

        this.colorInterpretation = 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, ColorTable colorTable,

        Transparency transparency, FilterList filters) {

        this.colorInterpretation = colorInterpretation;

        this.colorTable = colorTable;

        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");

        }

        if ((this.colorInterpretation.isRGB() || this.colorInterpretation.isBGR() || this.colorInterpretation

            .isRGBA()) && this.colorTable != null) {

            taskStatus.abort();

            throw new IllegalStateException(

                "If color interpretation is RGB, RGBA or BGR, raster legend can not have a color table");

        }

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

        Buffer bufferToDraw = null;

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

            // Convert extension to check if envelopes intersect

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

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

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

                return;

            }

            try {

                // Clip buffer with doubled converted envelope

                bufferToDraw = buffer.clip(convertedEnvelope);

                // Convert interpolated clipped buffer

                bufferToDraw = bufferToDraw.convert(coordTrans.getInverted(), taskStatus);

                double widthPixel =

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

                        / viewPort.getImageWidth());

                double heightPixel =

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

                        / viewPort.getImageHeight());

                bufferToDraw =

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

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

                        taskStatus);

            } catch (BufferException e) {

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

                taskStatus.abort();

                return;

            }

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

            double widthPixel = 0;

            double heightPixel = 0;

            try {

                // Clip and interpolate buffer with view port envelope

                if(buffer.getEnvelope().equals(viewPort.getAdjustedEnvelope())){

                    bufferToDraw = buffer;

                } else {

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

                }

                widthPixel =

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

                        / viewPort.getImageWidth());

                heightPixel =

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

                        / viewPort.getImageHeight());

                bufferToDraw =

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

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

                        taskStatus);

            } 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;

        }

        // Draw buffer

        Image image = null;

        if (this.colorInterpretation.isGray()){

             // Draw buffer with gray scale

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

        }else if ( this.colorInterpretation.isPalette() && this.colorTable != null ) {

            // Draw buffer with table color

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

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

            || this.colorInterpretation.isBGR()) {

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

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

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

            // Draw HSL buffer without color table

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

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

            // Draw CMYK buffer without color table

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

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

            // 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;

        }

        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()) {

            image =

                new BufferedImage(buffer.getColumns(), buffer.getRows(),

                    BufferedImage.TYPE_INT_ARGB);

        } else if (colorInterpretation.isBGR()) {

            image =

                new BufferedImage(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 = buffer.getBand(redBandIndex);

        Band greenBand = buffer.getBand(greenBandIndex);

        Band blueBand = buffer.getBand(blueBandIndex);

        Band alphaBand = null;

        if (colorInterpretation.hasAlphaBand()) {

            int alphaBandIndex =

                colorInterpretation.getBand(ColorInterpretation.ALPHA_BAND);

            alphaBand = buffer.getBand(alphaBandIndex);

        }

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

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

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

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

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

                Number alphaValue = 255;

                if (alphaBand != null) {

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

                }

                if (transparency != null) {

                    // Apply defined transparency ranges

                    alphaValue = alphaValue.byteValue() & 0xFF;

                    int newAlpha =

                        transparency.getTransparencyRangeAlpha(redValue.byteValue(),

                            greenValue.byteValue(), blueValue.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;

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

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

                        ((redValue.byteValue() & 0xFF) << 16) | // red

                        ((greenValue.byteValue() & 0xFF) << 8) | // green

                        ((blueValue.byteValue() & 0xFF) << 0); // blue

                } else if (colorInterpretation.isBGR()) {

                    intRGB = ((blueValue.byteValue() & 0xFF) << 16 | // blue

                        ((greenValue.byteValue() & 0xFF) << 8) | // green

                        ((redValue.byteValue() & 0xFF) << 0)); // red

                }

                image.setRGB(j, i, intRGB);

            }

        }

        return image;

    }

    private Image drawHSLBuffer(Graphics graphics, Buffer buffer,

        ColorInterpretation colorInterpretation,Transparency transparency,

        FilterList filters) {

        BufferedImage image = null;

        image =

            new BufferedImage(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 =

            new BufferedImage(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 =

            new BufferedImage(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 =

            new BufferedImage(buffer.getColumns(), buffer.getRows(), BufferedImage.TYPE_INT_ARGB);

        Band greyBand = buffer.getBand(0);

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

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

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

                Integer alphaValue =255;

                if (transparency != null) {

                    // Apply defined transparency ranges

                    alphaValue = alphaValue.byteValue() & 0xFF;

                    int newAlpha =

                        transparency.getTransparencyRangeAlpha(greyValue.byteValue(),

                            greyValue.byteValue(), greyValue.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 intARGB = ((alphaValue.byteValue()  & 0xFF) << 24) | // alpha

                    ((greyValue.byteValue() & 0xFF) << 16) | // red

                    ((greyValue.byteValue() & 0xFF) << 8) | // green

                    ((greyValue.byteValue() & 0xFF) << 0); // blue

                image.setRGB(j, i, intARGB);

            }

        }

        return image;

    }

    private Image drawPaletteBuffer(Graphics graphics, Buffer buffer, ColorTable colorTable,

        Transparency transparency, FilterList filters) {

        BufferedImage image =

            new BufferedImage(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(0).get(i, j);

                byte[] rgba = colorTable.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));

    }

    public ColorTable getColorTable() {

        return this.colorTable;

    }

    @Override

    public void setColorTable(ColorTable colorTable) {

        ColorInterpretation colorInterpretation = this.getColorInterpretation();

        if (colorInterpretation != null

            && (colorInterpretation.isRGB() || colorInterpretation.isBGR() || colorInterpretation

                .isRGBA())) {

            throw new IllegalArgumentException(

                "Can not set color table when color interpretation is RGB, BGR or RGBA");

        }

        this.colorTable = colorTable;

    }

    @Override

    public ColorInterpretation getColorInterpretation() {

        return this.colorInterpretation;

    }

    @Override

    public void setColorInterpretation(ColorInterpretation colorInterpretation) {

        if (this.colorTable != null

            && (colorInterpretation.isRGB() || colorInterpretation.isBGR() || colorInterpretation

                .isRGBA())) {

            throw new IllegalArgumentException(

                "Can not set color interpreation RGB, RGBA or BGR if legend has a color table specifed");

        }

        this.colorInterpretation = colorInterpretation;

    }

    @Override

    public FilterList getFilters() {

        return this.filters;

    }

    @Override

    public void setFilters(FilterList filterList) {

        this.filters = filterList;

    }

    /**

     *

     */

    public static void registerDefinition() {

        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.addDynField(COLOR_TABLE_PERSISTENCE_FIELD).setMandatory(false)

                .setClassOfValue(ColorTable.class);

            definition.addDynField(COLOR_INTERPRETATION_PERSISTENCE_FIELD).setMandatory(false)

                .setClassOfValue(ColorInterpretation.class);

            definition.addDynField(FILTERS_PERSISTENCE_FIELD).setMandatory(false)

                .setClassOfValue(FilterList.class);

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(COLOR_TABLE_PERSISTENCE_FIELD, this.getColorTable());

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

        state.set(FILTERS_PERSISTENCE_FIELD, this.filters);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.setColorTable((ColorTable) state.get(COLOR_TABLE_PERSISTENCE_FIELD));

        this.setColorInterpretation((ColorInterpretation) state

            .get(COLOR_INTERPRETATION_PERSISTENCE_FIELD));

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

    }

}