Application: gvSIG desktop » gvSIG legends: base legends

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

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSelection;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.operations.IHasImageLegend;

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

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

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

import org.gvsig.gui.ColorTablePainter;

import org.gvsig.gui.DefaultColorTablePainter;

import org.gvsig.legend.heatmap.lib.api.HeatmapLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractVectorialLegend;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.DefaultFeatureDrawnNotification;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.impl.SimpleTextSymbol;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

public class DefaultHeatmapLegend extends AbstractVectorialLegend implements HeatmapLegend, IHasImageLegend {

    private class DensityAlgorithm {

        private double[][] grid;

        private double[][] kernel;

        private int distance;

        private int height;

        private int with;

        private double maxValue;

        private double minValue;

        public DensityAlgorithm(int distance) {

            this.setDistance(distance);

        }

        public void setDistance(int distance) {

            this.distance = distance;

            this.kernel = new double[2 * this.distance + 1][2 * this.distance + 1];

            for( int y = -this.distance; y < this.distance + 1; y++ ) {

                for( int x = -this.distance; x < this.distance + 1; x++ ) {

                    final double dDist = Math.sqrt(x * x + y * y);

                    if( dDist < this.distance ) {

                        this.kernel[x + this.distance][y + this.distance] = Math.pow(1 - (dDist * dDist) / (this.distance * this.distance), 2);

                    } else {

                        this.kernel[x + this.distance][y + this.distance] = 0;

                    }

                }

            }

        }

        public int getDistance() {

            return this.distance;

        }

        public void init(int with, int height) {

            this.with = with;

            this.height = height;

            this.grid = new double[with][height];

            this.maxValue = 0;

            this.minValue = 0;

        }

        public void add(int px, int py) {

            add(px, py, 1);

        }

        public void add(int px, int py, double value) {

            for( int y = -this.distance; y < this.distance + 1; y++ ) {

                for( int x = -this.distance; x < this.distance + 1; x++ ) {

                    if( this.kernel[x + this.distance][y + this.distance] != 0 ) {

                        addValue(px + x, py + y, value * this.kernel[x + this.distance][y + this.distance]);

                    }

                }

            }

        }

        private void addValue(int px, int py, double value) {

            if( px < 0 || py < 0 || px >= with || py >= height ) {

                return;

            }

            value += this.grid[px][py];

            this.grid[px][py] = value;

            if( value > this.maxValue ) {

                this.maxValue = value;

            }

            if( value < this.minValue ) {

                this.minValue = value;

            }

        }

        public void draw(BufferedImage img, Graphics2D g, HeatmapColorTable hmColorTable, Cancellable cancel) {

            try {

                Color c;

                int maxIndexColor = hmColorTable.length-1;

                for( int x = 0; x < with; x++ ) {

                    for( int y = 0; y < height; y++ ) {

                        if( cancel.isCanceled() ) {

                            return;

                        }

                        double value = this.grid[x][y];

                        if( value > 0 ) {

                            int icolor = (int) (value * maxIndexColor / maxValue);

//                            icolor = icolor < 0 ? 0 : icolor >= maxIndexColor ? maxIndexColor - 1 : icolor;

                            c = blend(new Color(img.getRGB(x, y)),hmColorTable.getColorTable()[icolor]);

                            img.setRGB(x, y, c.getRGB());

                        }

                    }

                }

            } catch (Exception ex) {

                LOG.warn("Problems drawing heatmap", ex);

            }

        }

        private Color blend(Color dst, Color src) {

            //

            // https://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending

            //

            // when the destination background is opaque

            //

            // double outa = 1;

            double srca = src.getAlpha() / 255.0;

            double srca_1 = (1 - srca);

            Color color = new Color(

                (int)(src.getRed()  * srca + dst.getRed()  * srca_1) & 0xff,

                (int)(src.getGreen()* srca + dst.getGreen()* srca_1) & 0xff,

                (int)(src.getBlue() * srca + dst.getBlue() * srca_1) & 0xff

            );

            return color;

        }

    }

    private final ISymbol defaultSymbol;

    private final DensityAlgorithm algorithm;

    private boolean isRamp;

    private Color[] sourceColorTable;

    private int colorTableHotColorAlpha;

    private int colorTableColdColorAlpha;

    private String fieldName;

    private boolean useAlphaInColorTable;

    private Image imageLegend;

    private HeatmapColorTable hmColorTable;

    public DefaultHeatmapLegend() {

        this.defaultSymbol = new SimpleTextSymbol();

        this.algorithm = new DensityAlgorithm(30);

        this.colorTableHotColorAlpha = 255;

        this.colorTableColdColorAlpha = 0;

        this.useAlphaInColorTable = false;

        this.setColorTable(100, new Color(0, 0, 255, 0), new Color(255, 0, 0, 255));

        this.imageLegend = null;

    }

    @Override

    protected String[] getRequiredFeatureAttributeNames(FeatureStore featureStore) throws DataException {

        FeatureType ftype = featureStore.getDefaultFeatureType();

        if( StringUtils.isEmpty(this.fieldName) ) {

            return new String[]{

                ftype.getDefaultGeometryAttributeName()

            };

        }

        return new String[]{

            ftype.getDefaultGeometryAttributeName(),

            this.fieldName

        };

    }

    @Override

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    @Override

    public void setDefaultSymbol(ISymbol is) {

    }

    @Override

    public ISymbol getSymbolByFeature(Feature ftr) throws MapContextException {

        return this.defaultSymbol;

    }

    @Override

    public int getShapeType() {

        return Geometry.TYPES.GEOMETRY;

    }

    @Override

    public void setShapeType(int i) {

    }

    @Override

    public boolean isUseDefaultSymbol() {

        return true;

    }

    @Override

    public void useDefaultSymbol(boolean bln) {

    }

    @Override

    public boolean isSuitableForShapeType(int shapeType) {

        return true;

    }

    @Override

    protected void draw(BufferedImage image, Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, Map queryParameters, ICoordTrans coordTrans, FeatureStore featureStore, FeatureQuery featureQuery, double dpi) throws LegendException {

        this.algorithm.init(image.getWidth(), image.getHeight());

        super.draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans, featureStore, featureQuery, dpi);

        if( !cancel.isCanceled() ) {

            hmColorTable = null;

            if( this.useRamp() || !useAlphaInColorTable ) {

                hmColorTable = new HeatmapColorTable(this.getSourceColorTable());

            } else {

                hmColorTable = new HeatmapColorTable(this.getSourceColorTable(),colorTableColdColorAlpha, colorTableHotColorAlpha);

            }

            this.algorithm.draw(image, g, hmColorTable, cancel);

        }

    }

    @Override

    protected void drawFeatures(

        BufferedImage image,

        Graphics2D g,

        final ViewPort viewPort,

        final Cancellable cancel,

        final ICoordTrans coordTrans,

        double dpi,

        DefaultFeatureDrawnNotification drawnNotification,

        FeatureSet featureSet,

        FeatureSelection selection

    ) throws BaseException {

        int x = -1;

        if( !StringUtils.isEmpty(this.fieldName) ) {

            x = featureSet.getDefaultFeatureType().getIndex(this.fieldName);

        }

        final int n = x;

        featureSet.accept(new Visitor() {

            @Override

            public void visit(Object o) throws VisitCanceledException, BaseException {

                if( cancel.isCanceled() ) {

                    throw new VisitCanceledException();

                }

                Feature feature = (Feature) o;

                Geometry geom = feature.getDefaultGeometry();

                if( geom != null ) {

                    Point pointGeo = geom.centroid();

                    if( coordTrans != null ) {

                        pointGeo.reProject(coordTrans);

                    }

                    Point pointPixels = (Point) pointGeo.cloneGeometry();

                    pointPixels.transform(viewPort.getAffineTransform());

                    if( n >= 0 ) {

                        double value = 0;

                        try {

                            value = feature.getDouble(n);

                        } catch(Exception ex) {

                        }

                        if( value >0 ) {

                            algorithm.add((int) pointPixels.getX(), (int) pointPixels.getY(), value);

                        }

                    } else {

                        algorithm.add((int) pointPixels.getX(), (int) pointPixels.getY());

                    }

                }

            }

        });

    }

    /**

     * @return the distance

     */

    @Override

    public int getDistance() {

        return this.algorithm.getDistance();

    }

    /**

     * @param distance the distance to set

     */

    @Override

    public void setDistance(int distance) {

        this.algorithm.setDistance(distance);

    }

    @Override

    public void setColorTable(Color[] colorTable) {

        this.isRamp = false;

        this.sourceColorTable = colorTable;

        this.imageLegend = null;

        this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

    }

    @Override

    public void setColorTable(int numColor, Color first, Color last) {

        Color[] table = new Color[numColor];

        double deltaRed = (last.getRed() - first.getRed()) / numColor;

        double deltaGreen = (last.getGreen() - first.getGreen()) / numColor;

        double deltaBlue = (last.getBlue() - first.getBlue()) / numColor;

        double deltaAlpha = (last.getAlpha() - first.getAlpha()) / numColor;

        for( int i = 0; i < numColor; i++ ) {

            table[i] = new Color(

                (int) (first.getRed() + i * deltaRed),

                (int) (first.getGreen() + i * deltaGreen),

                (int) (first.getBlue() + i * deltaBlue),

                (int) (first.getAlpha() + i * deltaAlpha)

            );

        }

        this.isRamp = true;

        this.sourceColorTable = table;

        this.imageLegend = null;

        this.fireDefaultSymbolChangedEvent(new SymbolLegendEvent(null,null));

    }

    @Override

    public Color[] getSourceColorTable() {

        return this.sourceColorTable;

    }

    @Override

    public Color[] getTargetColorTable() {

        return this.getHetMapColorTable().getColorTable();

    }

    private HeatmapColorTable getHetMapColorTable() {

        if (this.hmColorTable == null) {

            if (this.useRamp() || !useAlphaInColorTable) {

                this.hmColorTable = new HeatmapColorTable(this.getSourceColorTable());

            } else {

                this.hmColorTable =

                    new HeatmapColorTable(this.getSourceColorTable(), colorTableColdColorAlpha, colorTableHotColorAlpha);

            }

        }

        return this.hmColorTable;

    }

    @Override

    public boolean useRamp() {

        return this.isRamp;

    }

    @Override

    public String getFieldName() {

        return this.fieldName;

    }

    @Override

    public void setFieldName(String fieldName) {

        this.fieldName = fieldName;

    }

    @Override

    public int getColorTableHotColorAlpha() {

        return colorTableHotColorAlpha;

    }

    @Override

    public void setColorTableHotColorAlpha(int colorTableHotColorAlpha) {

        this.colorTableHotColorAlpha = colorTableHotColorAlpha;

        this.imageLegend = null;

    }

    @Override

    public int getColorTableColdColorAlpha() {

        return colorTableColdColorAlpha;

    }

    @Override

    public void setColorTableColdColorAlpha(int colorTableColdColorAlpha) {

        this.colorTableColdColorAlpha = colorTableColdColorAlpha;

        this.imageLegend = null;

    }

    @Override

    public boolean useAlphaInColorTable() {

        return this.useAlphaInColorTable;

    }

    @Override

    public boolean setUseAlphaInColorTable(boolean use) {

        boolean x = this.useAlphaInColorTable;

        this.useAlphaInColorTable = use;

        return x;

    }

    @Override

    public Image getImageLegend() {

        if( this.imageLegend==null ) {

            BufferedImage img = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);

            ColorTablePainter painter = new DefaultColorTablePainter(this.getTargetColorTable(),"");

            Graphics2D g = img.createGraphics();

            g.setClip(0, 0, 80, 20);

            g.setBackground(Color.WHITE);

            g.fillRect(0, 0, 80, 20);

            painter.paint(g, false);

            this.imageLegend = img;

        }

        return this.imageLegend;

    }

    @Override

    public String getPathImage() {

        return null;

    }

    private static class HeatmapColorTable {

        private Color[] sourceColorTable = null;

        private int coldAlpha = -1;

        private int hotAlpha = -1;

        private Color coldColor = null;

        private Color hotColor = null;

        private Color[] targetColorTable = null;

        private int length = -1;

        public HeatmapColorTable(Color[] sourceColorTable){

            this.sourceColorTable  = sourceColorTable;

            this.length = sourceColorTable.length;

        }

        public HeatmapColorTable(Color[] sourceColorTable, int coldAlpha, int hotAlpha){

            this.sourceColorTable  = sourceColorTable;

            this.coldAlpha = coldAlpha;

            this.hotAlpha = hotAlpha;

            this.length = sourceColorTable.length;

        }

        public HeatmapColorTable(Color coldColor, Color hotColor, int coldAlpha, int hotAlpha, int length){

            this.coldColor = coldColor;

            this.hotColor = hotColor;

            this.coldAlpha = coldAlpha;

            this.hotAlpha = hotAlpha;

            this.length = length;

        }

        public Color[] getColorTable(){

            if(targetColorTable==null){

                if(sourceColorTable!=null){ //Tenemos tabla de color

                    double alphaDelta = getDelta(coldAlpha, hotAlpha, length);

                    targetColorTable = new Color[sourceColorTable.length];

                    for (int i = 0; i < sourceColorTable.length; i++) {

                        Color sourceColor = sourceColorTable[i];

                        if (coldAlpha >= 0 && hotAlpha >= 0) {

                            targetColorTable[i] =

                                new Color(sourceColor.getRed(),

                                    sourceColor.getGreen(),

                                    sourceColor.getBlue(),

                                    coldAlpha + (int) (i * alphaDelta));

                        } else {

                            targetColorTable[i] = sourceColor;

                        }

                    }

                } else {  //Tenemos gradiente

                    int coldRed = coldColor.getRed();

                    int coldGreen = coldColor.getGreen();

                    int hotGreen = hotColor.getGreen();

                    int hotRed = hotColor.getRed();

                    int coldBlue = coldColor.getBlue();

                    int hotBlue = hotColor.getBlue();

                    double redDelta = getDelta(coldRed, hotRed, length);

                    double greenDelta = getDelta(coldGreen, hotGreen, length);

                    double blueDelta = getDelta(coldBlue, hotBlue, length);

                    double alphaDelta = getDelta(coldAlpha, hotAlpha, length);

                    targetColorTable = new Color[length];

                    for (int i = 0; i < sourceColorTable.length; i++) {

                        targetColorTable[i] =

                            new Color(coldRed + (int) (i * redDelta),

                                coldGreen + (int) (i * greenDelta),

                                hotGreen + (int) (i * blueDelta),

                                coldAlpha + (int) (i * alphaDelta));

                    }

                }

            }

            return targetColorTable;

        }

        private double getDelta(int x1, int x2, int lenght){

            return (x2-x1)/((double)lenght-1);

        }

    }

}