gvSIG projects pool

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.legend.filteredheatmap</artifactId>

    <version>1.0.50</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.filteredheatmap.lib</artifactId>

  <packaging>pom</packaging>

  <modules>

    <module>org.gvsig.legend.filteredheatmap.lib.api</module>

    <module>org.gvsig.legend.filteredheatmap.lib.impl</module>

  </modules>

</project>

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.legend.filteredheatmap.lib.api;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.task.Cancellable;

/**

 *

 * @author osc

 */

public interface KernelExpressionAlgorithm {

    public void setDistance(int distance);

    public int getDistance();

    public void init(int with, int height);

    public void add(int px, int py);

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

    public void drawWithOpaqueColors(BufferedImage img, Graphics2D g, Color[] colorTable, Cancellable cancel, Geometry roi, int limitProportionToDraw);

    public void drawWithAlphaColors(BufferedImage img, Graphics2D g, Color[] colorTable, Cancellable cancel, Geometry roi, int limitProportion);

    public Expression getKernelExpression();

    public void setKernelExpression(Expression kernelExpression);

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.legend.filteredheatmap.lib.api;

import org.gvsig.expressionevaluator.SymbolTable;

public interface FilteredHeatmapLegendManager {

    /**

     * Creates an aggregate legend

     *

     * @return the aggregate legend

     */

    public FilteredHeatmapLegend create();

    public Class<? extends FilteredHeatmapLegend> getLegendClass(); 

    public SymbolTable createKernelSymbolTable(KernelExpressionAlgorithm alg, int x, int y);

    public KernelExpressionAlgorithm createKernelExpressionAlgorithm(int distance);

}

package org.gvsig.legend.filteredheatmap.lib.api;

import java.awt.Color;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.geom.Geometry;

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

public interface FilteredHeatmapLegend extends IVectorLegend {

    public int getDistance();

    public void setDistance(int distance);

    public void setColorTable(Color[] colorTable);

    public void setColorTable(int numColors, Color coldColor, Color hotColor);

    public Color[] getSourceColorTable();

    public Color[] getTargetColorTable();

    public Geometry getROI();

    public void setROI(Geometry roi);

    public boolean useRamp();

    public String getFieldName();

    public void setFieldName(String fieldName);

    public int getColorTableHotColorAlpha();

    public void setColorTableHotColorAlpha(int colorTableHotColorAlpha);

    public int getColorTableColdColorAlpha();

    public void setColorTableColdColorAlpha(int colorTableColdColorAlpha);

    public boolean useAlphaInColorTable();

    public boolean setUseAlphaInColorTable(boolean use);

    public int getRampNumColors();

    public Color getRampColdColor();

    public Color getRampHotColor();

    public int getFilterProportionValue();

    public void setFilterProportionValue(int proportionValue);

    public Expression getFilterByExpression();

    public void setFilterByExpression(Expression filterExpression);

    public boolean getUseFilterByExpression();

    public void setUseFilterByExpression(boolean useFilterExpression);

    public Expression getKernelExpression();

    public void setKernelExpression(Expression kernelExpression);

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.legend.filteredheatmap.lib.api;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.tools.locator.AbstractLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

public class FilteredHeatmapLegendLocator extends AbstractLocator {

    /**

     * FilteredHeatmapLegend locator name

     */

    private static final String LOCATOR_NAME = "FilteredHeatmapLegendLocator";

    /**

     * HeatmapLegend manager name

     */

    public static final String MANAGER_NAME = "FilteredHeatmapLegendManager";

    /**

     * HeatmapLegend manager description

     */

    private static final String MANAGER_DESCRIPTION =

        "FilteredHeatmapLegend Manager of gvSIG";

    /**

     * Unique instance

     */

    private static final FilteredHeatmapLegendLocator instance = new FilteredHeatmapLegendLocator();

    @Override

    public String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Registers the Class implementing the FilteredHeatmapLegendManager interface.

     *

     * @param clazz

     *            implementing the FilteredHeatmapLegendManager interface

     */

    public static void registerFilteredHeatmapLegendManager(Class clazz){

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    /**

     * Registers the default Class implementing the FilteredHeatmapLegendManager interface

     *

     * @param clazz

     *            implementing the FilteredHeatmapLegendManager interface

     */

    public static void registerDefaultFilteredHeatmapLegendManager(Class clazz){

        getInstance().registerDefault(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    /**

     * Return a reference to FilteredHeatmapLegendManager.

     *

     * @return a reference to HeatmapLegendManager

     * @throws LocatorException

     *             if there is no access to the class or the class

     *             cannot be instantiated

     * @see Locator#get(String)

     */

    public static FilteredHeatmapLegendManager getFilteredHeatmapLegendManager() throws LocatorException {

        return (FilteredHeatmapLegendManager) getInstance().get(MANAGER_NAME);

    }

    /**

     * @return

     */

    public static Locator getInstance() {

        return instance;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.legend.filteredheatmap.lib.api;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendWriter;

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

public class FilteredHeatmapLegendLibrary extends AbstractLibrary {

    @Override

    protected void doInitialize() throws LibraryException {

        registerAsAPI(FilteredHeatmapLegendLibrary.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        // Validate there is any implementation registered.

        FilteredHeatmapLegendManager manager = FilteredHeatmapLegendLocator.getFilteredHeatmapLegendManager();

        if (manager == null) {

            throw new ReferenceNotRegisteredException(

                FilteredHeatmapLegendLocator.MANAGER_NAME, FilteredHeatmapLegendLocator.getInstance());

        }

        SymbologyManager symbolManager = SymbologyLocator.getSymbologyManager();

        ILegendWriter legendWriter = symbolManager.getDefaultLegendWriter();

        MapContextManager mcoman = MapContextLocator.getMapContextManager();

        mcoman.registerLegendWriter(

            FilteredHeatmapLegend.class,

            SymbolManager.LEGEND_FILE_EXTENSION.substring(1),

            legendWriter.getClass());

    }

}

org.gvsig.legend.filteredheatmap.lib.api.FilteredHeatmapLegendLibrary

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.filteredheatmap.lib.api</artifactId>

  <name>org.gvsig.legend.filteredheatmap.lib.api</name>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.legend.filteredheatmap.lib</artifactId>

    <version>1.0.50</version>

  </parent>

  <build>

    <plugins>

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-jar-plugin</artifactId>

        <configuration>

        </configuration>

        <executions>

          <!-- Generates a jar file only with the test classes -->

          <execution>

            <goals>

              <goal>test-jar</goal>

            </goals>

          </execution>

        </executions>

      </plugin>

    </plugins>

  </build>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.mapcontext.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.symbology.lib.api</artifactId>

    </dependency>

  </dependencies>

</project>

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

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

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.Arrays;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

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

import org.gvsig.legend.filteredheatmap.lib.api.KernelExpressionAlgorithm;

import org.gvsig.tools.logger.FilteredLogger;

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

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

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author osc

 */

public class DefaultKernelExpressionAlgorithm implements KernelExpressionAlgorithm {

    private double[][] grid;

    private double[][] kernel;

    private int distance;

    private int height;

    private int with;

    private double maxValue;

    private double minValue;

    private Expression kernelExpression;

    protected static final Logger LOG = LoggerFactory

            .getLogger(KernelExpressionAlgorithm.class);

    protected static final FilteredLogger LOGF = new FilteredLogger(LOG, "KernelExpressionAlgorithm", 30);

    private boolean forceUpdate;

    private KernelSymbolTable kSymbolTable;

    private MutableSymbolTable kernelsymbolTable;

    public DefaultKernelExpressionAlgorithm(int distance, Expression kernelExpression) {

        this.init(distance, distance);

        this.setKernelExpression(kernelExpression);

        this.setDistance(distance);

    }

    @Override

    public Expression getKernelExpression() {

        return this.kernelExpression;

    }

    @Override

    public void setDistance(int distance) {

        if (forceUpdate) {

            forceUpdate = false;

        } else {

            if (this.distance == distance) {

                return;

            }

        }

        if (this.distance == distance) {

            return;

        }

        this.distance = distance;

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

        if (kernelExpression == null || kernelExpression.isEmpty()) {

            return;

        }

        Object value;

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

                    kSymbolTable.setXY(x, y);

                    kSymbolTable.setAlgorithm(this);

                    try {

                        value = this.kernelExpression.execute(kernelsymbolTable);

                    } catch (Exception e) {

                        LOGF.warn("Problems executing expression.");

                        continue;

                    }

                    String obj = value.toString();

                    this.kernel[x + this.distance][y + this.distance] = Double.parseDouble(obj);

                } else {

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

                }

            }

        }

    }

    @Override

    public int getDistance() {

        return this.distance;

    }

    @Override

    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;

    }

    @Override

    public void add(int px, int py) {

        add(px, py, 1);

    }

    @Override

    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;

        }

    }

    @Override

    public void drawWithOpaqueColors(BufferedImage img, Graphics2D g, Color[] colorTable, Cancellable cancel, Geometry roi, int limitProportion) {

        try {

            ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

            Color c;

            double valueForLimit;

            if (limitProportion == 100) {

                return;

            } else if (limitProportion > 0 && limitProportion < 100) {

                ArrayList<Double> singleArray = new ArrayList<>();

                for (double[] ds : this.grid) {

                    for (double d : ds) {

                        if (d != 0) {

                            singleArray.add(d);

                        }

                    }

                }

                int size = singleArray.size();

                Double[] sd = singleArray.toArray(new Double[singleArray.size()]);

                Arrays.sort(sd);

                int indexForLimitValue = ((size - 1) * limitProportion) / 100;

                valueForLimit = sd[indexForLimitValue];

            } else {

                valueForLimit = 0.0;

            }

            int maxIndexColor = colorTable.length - 1;

            //double minValueToDraw = ((maxValue - minValue) * limitProportion) / 100;

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

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

                    if (cancel.isCanceled()) {

                        return;

                    }

                    if (roi != null) {

                        Point point = GeometryUtils.createPoint(x, y);

                        if (!roi.intersects(point)) {

                            continue;

                        }

                    }

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

                    if (value > 0) {

                        if (value < valueForLimit) {

                            continue;

                        }

                        int icolor = this.calculateIndexColor(value, valueForLimit, maxIndexColor);

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

                        c = toolsSwingManager.alphaBlendingWithOpaqueBackground(

                                new Color(img.getRGB(x, y)),

                                colorTable[icolor]

                        );

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

                    }

                }

            }

        } catch (Exception ex) {

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

        }

    }

    // Adapt values to the proportion between minValueToDraw and maxValue of the grid

    public int calculateIndexColor(double value, double minValueToDraw, int maxIndexColor) {

        double d = maxValue - minValueToDraw;

        double dif = value - minValueToDraw;

        int x = (int) ((dif * maxIndexColor) / d);

        if (x > maxIndexColor) {

            LOGF.warn("Problems drawing heatmap. Index color is bigger than maxIndexColor");

            return maxIndexColor;

        } else if (x < 0) {

            LOGF.warn("Problems drawing heatmap. Index color is bellow 0");

            return 0;

        }

        return x;

    }

    @Override

    public void drawWithAlphaColors(BufferedImage img, Graphics2D g, Color[] colorTable, Cancellable cancel, Geometry roi, int limitProportion) {

        try {

            ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

            Color c;

            double valueForLimit;

            if (limitProportion == 100) {

                return;

            } else if (limitProportion > 0 && limitProportion < 100) {

                ArrayList<Double> singleArray = new ArrayList<>();

                for (double[] ds : this.grid) {

                    for (double d : ds) {

                        if (d != 0) {

                            singleArray.add(d);

                        }

                    }

                }

                int size = singleArray.size();

                Double[] sd = singleArray.toArray(new Double[singleArray.size()]);

                Arrays.sort(sd);

                int indexForLimitValue = ((size - 1) * limitProportion) / 100;

                valueForLimit = sd[indexForLimitValue];

            } else {

                valueForLimit = 0.0;

            }

            int maxIndexColor = colorTable.length - 1;

            //double minValueToDraw = ((maxValue - minValue) * limitProportion) / 100;

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

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

                    if (cancel.isCanceled()) {

                        return;

                    }

                    if (roi != null) {

                        Point point = GeometryUtils.createPoint(x, y);

                        if (!roi.intersects(point)) {

                            continue;

                        }

                    }

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

                    if (value > 0) {

                        if (value < valueForLimit) {

                            continue;

                        }

                        int icolor = this.calculateIndexColor(value, valueForLimit, maxIndexColor);

                        c = colorTable[icolor];

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

                    }

                }

            }

        } catch (Exception ex) {

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

        }

    }

    @Override

    public void setKernelExpression(Expression kernelExpression) {

        if (this.kernelExpression != kernelExpression) {

            this.kernelExpression = kernelExpression;

            this.forceUpdate = true;

            this.setDistance(this.distance);

            this.kSymbolTable = new KernelSymbolTable(this, 0, 0);

//            kernelExpression.link(kSymbolTable);

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            kernelsymbolTable = manager.createSymbolTable();

            kernelsymbolTable.addSymbolTable(kSymbolTable);

        }

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.legend.filteredheatmap.lib.api.FilteredHeatmapLegend;

import org.gvsig.legend.filteredheatmap.lib.api.FilteredHeatmapLegendManager;

import org.gvsig.legend.filteredheatmap.lib.api.KernelExpressionAlgorithm;

public class DefaultFilteredHeatmapLegendManager implements FilteredHeatmapLegendManager {

    @Override

    public FilteredHeatmapLegend create() {

        return new DefaultFilteredHeatmapLegend();

    }

    @Override

    public Class<? extends FilteredHeatmapLegend> getLegendClass() {

        return DefaultFilteredHeatmapLegend.class;

    }

    @Override

    public SymbolTable createKernelSymbolTable(KernelExpressionAlgorithm alg, int x, int y) {

        return new KernelSymbolTable(alg, x, y);

    }

    @Override

    public KernelExpressionAlgorithm createKernelExpressionAlgorithm(int distance) {

        return new DefaultKernelExpressionAlgorithm(distance, null);

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

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

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.legend.filteredheatmap.lib.api.KernelExpressionAlgorithm;

/**

 *

 * @author osc

 */

public class KernelSymbolTable extends AbstractSymbolTable {

    private KernelExpressionAlgorithm algorithm;

    private int pixely;

    private int pixelx;

    private double pixeldistance;

    public KernelSymbolTable(KernelExpressionAlgorithm algorithm, int x, int y) {

        super(DataManager.DAL_SYMBOL_TABLE);

        this.algorithm = algorithm;

        this.pixelx = x;

        this.pixely = y;

        this.pixeldistance = 15;

        this.addFunction(new KernelDistanceFunc());

        this.addFunction(new PixelDistanceFunc());

        this.addFunction(new PixelXFunc());

        this.addFunction(new PixelYFunc());

    }

    @Override

    public KernelSymbolTable clone() throws CloneNotSupportedException {

        KernelSymbolTable other = (KernelSymbolTable) super.clone();

        return other;

    }

    public void setAlgorithm(KernelExpressionAlgorithm algorithm) {

        this.algorithm = algorithm;

    }

    public void setXY(int x, int y) {

        this.pixelx = x;

        this.pixely = y;

        this.pixeldistance = Math.sqrt(pixelx * pixelx + pixely * pixely);

    }

    public class KernelDistanceFunc extends AbstractFunction {

        public KernelDistanceFunc() {

            super(

                    "Kernel Algorithm",

                    "kerneldistance",

                    Range.is(0),

                    "Return the distance",

                    "kerneldistance()",

                    null,

                    "Integer"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return algorithm.getDistance();

        }

    }

    public class PixelDistanceFunc extends AbstractFunction {

        public PixelDistanceFunc() {

            super(

                    "Kernel Algorithm",

                    "pixeldistance",

                    Range.is(0),

                    "Return the distance to the pixel",

                    "pixeldistance()",

                    null,

                    "Double"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return pixeldistance;

        }

    }

    public class PixelXFunc extends AbstractFunction {

        public PixelXFunc() {

            super(

                    "Kernel Algorithm",

                    "pixelx",

                    Range.is(0),

                    "Return the pixel coordinate x",

                    "pixelx()",

                    null,

                    "Double"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return pixelx;

        }

    }

    public class PixelYFunc extends AbstractFunction {

        public PixelYFunc() {

            super(

                    "Kernel Algorithm",

                    "pixely",

                    Range.is(0),

                    "Return the pixel coordinate y",

                    "pixely()",

                    null,

                    "Double"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return pixely;

        }

    }

}

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

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

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

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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

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

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.filteredheatmap.lib.api.FilteredHeatmapLegend;

import org.gvsig.legend.filteredheatmap.lib.api.KernelExpressionAlgorithm;

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.persistence.PersistentState;

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

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

public class DefaultFilteredHeatmapLegend extends AbstractVectorialLegend implements FilteredHeatmapLegend, IHasImageLegend {

    private ISymbol defaultSymbol;

    private KernelExpressionAlgorithm algorithm;

    private boolean isRamp;

    private Color[] sourceColorTable;

    private int colorTableHotColorAlpha;

    private int colorTableColdColorAlpha;

    private boolean useAlphaInColorTable;

    private String fieldName;

    private Image imageLegend;

    private HeatmapColorTable hmColorTable;

    private Color rampColdColor;

    private Color rampHotColor;

    private int rampNumColors;

    private Geometry roi;

    private int proportionValue;

    private Expression filterExpression;

    private boolean useFilterExpression;

    public DefaultFilteredHeatmapLegend() {

        this.defaultSymbol = new SimpleTextSymbol();

        Expression kernelPowExp = ExpressionEvaluatorLocator.getExpressionEvaluatorManager().createExpression();

        kernelPowExp.setPhrase("power(1-(power(pixeldistance(), 2)/power(kerneldistance(), 2)),2)");

        this.algorithm = new DefaultKernelExpressionAlgorithm(30, kernelPowExp);

        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;

        this.hmColorTable = null;

        this.fieldName = null;

    }

    @Override

    public Expression getKernelExpression() {

        return this.algorithm.getKernelExpression();

    }

    @Override

    public void setKernelExpression(Expression kernelExpression) {

        this.algorithm.setKernelExpression(kernelExpression);

    }

    @Override

    public int getFilterProportionValue() {

        return this.proportionValue;

    }

    @Override

    public void setFilterProportionValue(int proportionValue) {

        this.proportionValue = proportionValue;

    }

    @Override

    public Expression getFilterByExpression() {

        return this.filterExpression;

    }

    @Override

    public void setFilterByExpression(Expression filterExpression) {

        this.filterExpression = filterExpression;

    }

    @Override

    public boolean getUseFilterByExpression() {

        return this.useFilterExpression;

    }

    @Override

    public void setUseFilterByExpression(boolean useFilterExpression) {

        this.useFilterExpression = useFilterExpression;

    }

    @Override

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

        FeatureType ftype = featureStore.getDefaultFeatureType();

//        String[] allAttributes = new String[ftype.getAttributeDescriptors().length];

        ArrayList<String> arrayAttributes = new ArrayList<>();

        for (FeatureAttributeDescriptor attributeDescriptor : ftype.getAttributeDescriptors()) {

            arrayAttributes.add(attributeDescriptor.getName());

        }

        String[] a = arrayAttributes.toArray(new String[arrayAttributes.size()]);

        return a;

    }

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

        int saved_distance = this.algorithm.getDistance();

        try {

            int distance = (int) (this.algorithm.getDistance() * (dpi / 72));

            Geometry theROI = null;

            if (this.roi != null) {

                theROI = this.roi.cloneGeometry();

                theROI.transform(viewPort.getAffineTransform());

            }

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

            this.algorithm.setDistance(distance);

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

            if (!cancel.isCanceled()) {

                this.algorithm.drawWithOpaqueColors(image, g, this.getHeatMapColorTable().getColorTable(), cancel, theROI, this.getFilterProportionValue());

            }

        } finally {

            this.algorithm.setDistance(saved_distance);

        }

    }

    @Override

    public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

            double scale, Map queryParameters, ICoordTrans coordTrans,

            FeatureStore featureStore, FeatureQuery featureQuery, PrintAttributes properties)

            throws LegendException {

        int saved_distance = this.algorithm.getDistance();

        try {

            double dpi = viewPort.getDPI();

            // Ver CartographicSupportToolkit.getCartographicLength

            int distance = (int) (this.algorithm.getDistance() * (dpi / 72));

            Geometry theROI = null;

            if (this.roi != null) {

                theROI = this.roi.cloneGeometry();

                theROI.transform(viewPort.getAffineTransform());

            }

            this.algorithm.init(viewPort.getImageWidth(), viewPort.getImageHeight());

            this.algorithm.setDistance(distance);

            BufferedImage image = new BufferedImage(viewPort.getImageWidth(), viewPort.getImageHeight(), BufferedImage.TYPE_INT_ARGB);

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

            if (!cancel.isCanceled()) {

                this.algorithm.drawWithAlphaColors(image, g, this.getHeatMapColorTable().getColorTable(), cancel, theROI, this.getFilterProportionValue());

                g.drawImage(image, 0, 0, null);

            }

        } finally {

            this.algorithm.setDistance(saved_distance);

        }

    }

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

        MutableSymbolTable symbolTable = ExpressionEvaluatorLocator.getManager().createSymbolTable();

        FeatureSymbolTable fst = DALLocator.getDataManager().createFeatureSymbolTable();

        symbolTable.addSymbolTable(fst);

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

                        fst.setFeature(feature);

                        boolean validFeature = checkToFilterFeature(fst, symbolTable);

                        if (!validFeature) {

                            return;

                        }

                    }

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

                    }

                }

            }

        });

    }

    protected boolean checkToFilterFeature(FeatureSymbolTable fst, MutableSymbolTable symbolTable) {

        if (filterExpression!=null && !filterExpression.isEmpty()) {

            Object value = filterExpression.execute(symbolTable);

            if (value instanceof Boolean) {

                return ((Boolean) value);

            } else {

                return false;

            }

        } else {

            return false;

        }

    }

    /**

     * @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.hmColorTable = null;

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

    }

    @Override

    public void setColorTable(int numColors, Color coldColor, Color hotColor) {

        this.isRamp = true;

        this.rampColdColor = coldColor;

        this.rampHotColor = hotColor;

        this.rampNumColors = numColors;

        this.imageLegend = null;

        this.hmColorTable = null;

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

    }

    @Override

    public Color[] getSourceColorTable() {

        return this.sourceColorTable;

    }

    @Override

    public Color[] getTargetColorTable() {

        return this.getHeatMapColorTable().getColorTable();

    }

    private HeatmapColorTable getHeatMapColorTable() {

        if (this.hmColorTable == null) {

            if (this.useRamp()) {

                this.hmColorTable = new HeatmapColorTable(this.rampColdColor, this.rampHotColor, this.rampNumColors);

            } else {

                if (useAlphaInColorTable) {

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

                } else {

                    this.hmColorTable

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

                }

            }

        }

        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;

        this.hmColorTable = null;

    }

    @Override

    public int getColorTableColdColorAlpha() {

        return colorTableColdColorAlpha;

    }

    @Override

    public void setColorTableColdColorAlpha(int colorTableColdColorAlpha) {

        this.colorTableColdColorAlpha = colorTableColdColorAlpha;

        this.imageLegend = null;

        this.hmColorTable = null;

    }

    @Override

    public boolean useAlphaInColorTable() {

        return this.useAlphaInColorTable;

    }

    @Override

    public boolean setUseAlphaInColorTable(boolean use) {

        boolean x = this.useAlphaInColorTable;

        this.useAlphaInColorTable = use;

        this.hmColorTable = null;

        return x;

    }

    @Override

    public void setROI(Geometry roi) {

        this.roi = roi;

    }

    @Override

    public Geometry getROI() {

        return this.roi;

    }

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

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.defaultSymbol = new SimpleTextSymbol();

        this.imageLegend = null;

        this.hmColorTable = null;

        super.loadFromState(state);

        this.isRamp = state.getBoolean("isRamp");

        this.sourceColorTable = (Color[]) state.getArray("sourceColorTable", Color.class);

        this.colorTableHotColorAlpha = state.getInt("colorTableHotColorAlpha");

        this.colorTableColdColorAlpha = state.getInt("colorTableColdColorAlpha");

        this.useAlphaInColorTable = state.getBoolean("useAlphaInColorTable");

        this.fieldName = state.getString("fieldName");

        this.rampNumColors = state.getInt("rampNumColors");

        this.rampColdColor = (Color) state.get("rampColdColor");

        this.rampHotColor = (Color) state.get("rampHotColor");

        this.proportionValue = state.getInt("proportionValue");

        this.useFilterExpression = state.getBoolean("useFilterExpression");

        this.filterExpression = (Expression) state.get("filterExpression");

        int distance = state.getInt("distance");

        Expression expression = (Expression) state.get("kernelExpression");

        this.algorithm = new DefaultKernelExpressionAlgorithm( distance, expression);

    }

    @Override

    public int getRampNumColors() {

        return this.rampNumColors;

    }

    @Override

    public Color getRampColdColor() {

        return this.rampColdColor;

    }

    @Override

    public Color getRampHotColor() {

        return this.rampHotColor;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("isRamp", isRamp); 

        state.set("sourceColorTable", sourceColorTable);

        state.set("colorTableHotColorAlpha", colorTableHotColorAlpha);

        state.set("colorTableColdColorAlpha", colorTableColdColorAlpha);

        state.set("useAlphaInColorTable", useAlphaInColorTable);

        state.set("fieldName", fieldName);

        state.set("distance", algorithm.getDistance());

        state.set("rampNumColors", rampNumColors);

        state.set("rampColdColor", rampColdColor);

        state.set("rampHotColor", rampHotColor);

        state.set("proportionValue", this.proportionValue);

        state.set("useFilterExpression", this.useFilterExpression);

        state.set("filterExpression", this.filterExpression);

        state.set("distance", this.algorithm.getDistance());

        state.set("kernelExpression", this.algorithm.getKernelExpression());

    }

    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;

        }

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

            this.sourceColorTable = sourceColorTable;

            this.coldAlpha = coldAlpha;

            this.hotAlpha = hotAlpha;

        }

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

            this.coldColor = coldColor;

            this.hotColor = hotColor;

            this.length = length;

        }

        public Color[] getColorTable() {

            if (targetColorTable == null) {

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

                    if (coldAlpha >= 0 || hotAlpha >= 0) { //Se usa alpha para la tabla de color

                        double alphaDelta = getDelta(coldAlpha, hotAlpha, sourceColorTable.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 { //No se usa alpha para la tabla de color

                        targetColorTable = sourceColorTable;

                    }

                } else { // Tenemos gradiente

                    targetColorTable = new Color[length];

                    double deltaRed = (hotColor.getRed() - coldColor.getRed()) / length;

                    double deltaGreen = (hotColor.getGreen() - coldColor.getGreen()) / length;

                    double deltaBlue = (hotColor.getBlue() - coldColor.getBlue()) / length;

                    double deltaAlpha = (hotColor.getAlpha() - coldColor.getAlpha()) / length;

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

                        targetColorTable[i]

                                = new Color(

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

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

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

                                        (int) (coldColor.getAlpha() + i * deltaAlpha));

                    }

                }

            }

            return targetColorTable;

        }

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

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

        }

    }

}