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 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.getEnvelope().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.getEnvelope().getLength(0)

                        / viewPort.getImageWidth());

                double heightPixel =

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

                        / viewPort.getImageHeight());

                bufferToDraw =

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

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

                        taskStatus);

            } catch (BufferException e) {

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

                taskStatus.abort();

                return;

            }

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

            double widthPixel = 0;

            double heightPixel = 0;

            try {

                // Clip and interpolate buffer with view port envelope

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

                widthPixel =

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

                        / viewPort.getImageWidth());

                heightPixel =

                    getHeightPixel(bufferToDraw.getEnvelope(), viewPort.getEnvelope().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() && this.colorTable != null) {

            // Draw buffer with table color

            image = drawBuffer(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 = drawBuffer(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.getEnvelope(), 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 drawBuffer(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");

        }

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

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

                //TODO Review this bucle

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

                }

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

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

                        ((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 drawBuffer(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));

    }

}