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.heatmapcomparison</artifactId>

    <version>1.0.14</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.heatmapcomparison.app</artifactId>

  <packaging>pom</packaging>

  <name>org.gvsig.legend.heatmapcomparison.app</name>

  <modules>

    <module>org.gvsig.legend.heatmapcomparison.app.mainplugin</module>

  </modules>

</project>

<!-- gvSIG. Desktop Geographic Information System. Copyright (C) 2007-2013 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. -->

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <include>org.gvsig:org.gvsig.legend.heatmapcomparison.lib.api</include>

        <include>org.gvsig:org.gvsig.legend.heatmapcomparison.lib.impl</include>

        <include>org.gvsig:org.gvsig.legend.heatmapcomparison.swing.api</include>

        <include>org.gvsig:org.gvsig.legend.heatmapcomparison.swing.impl</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

package org.gvsig.legend.heatmapcomparison.app;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.plugins.Extension;

public class HeatmapComparisonLegendExtension extends Extension {

    @Override

    public void initialize() {

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-heatmapcomparison", this);

    }

    @Override

    public void execute(String string) {

    }

    @Override

    public boolean isEnabled() {

        return true;

    }

    @Override

    public boolean isVisible() {

        return true;

    }

}

<?xml version="1.0" encoding="ISO-8859-1"?>

<!-- gvSIG. Desktop Geographic Information System. Copyright (C) 2007-2013 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. -->

<plugin-config>

  <depends plugin-name="org.gvsig.app.mainplugin" />

  <resourceBundle name="text" />

  <libraries library-dir="lib" />

  <extensions>

    <extension class-name="org.gvsig.legend.heatmapcomparison.app.HeatmapComparisonLegendExtension"

      description="" active="true" priority="1">

    </extension>

  </extensions>

</plugin-config>

<?xml version="1.0"?>

<!--

Definitions of plugin persistence org.gvsig.legend.heatmapcomparison.app.mainplugin

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="org.gvsig.legend.heatmapcomparison.app.mainplugin">

      <extends>

      </extends>

      <description>Persistence of the legend of heatmap comparison</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

_Heatmap_comparison_legend_description=Heat map for representing the difference between dots density in a map.

_Heatmap_comparison_legend=Heat map comparison

_Distance=Distance

pixels=pixels

_Use_color_ramp=Use a color ramp

_Number_of_colors=Number of colors

_Hot_color=Hot color

Alpha=Alpha

_Cold_color=Cold color

_Use_color_table=Use a color table

_Color_table=Color table

_Use_transparency=Use transparencia

_Hot_color_transparency=Hot color transparency

_Cold_color_transparency=Cold color transparency

_Use_a_field_to_weight_the_heat_map=Use a field to weight the heat map

_Hot_filter=Hot filter

_Cold_filter=Cold filter

_Mid_color=Mid color

_Heatmap_comparison_legend_description=Mapa de calor comparado que representa la diferencia entre densidad de puntos en un mapa.

_Heatmap_comparison_legend=Mapa de calor comparado

_Distance=Distancia

pixels=pixels

_Use_color_ramp=Usar un gradiente de color

_Number_of_colors=Numero de colores

_Hot_color=Color caliente

Alpha=Alpha

_Cold_color=Color frio

_Use_color_table=Usar tabla de color

_Color_table=Tabla de color

_Use_transparency=Usar transparencia

_Hot_color_transparency=Transparencia del color caliente

_Cold_color_transparency=Transparencia del color frio

_Use_a_field_to_weight_the_heat_map=Usar un campo para ponderar el mapa de calor

_Hot_filter=Filtro caliente

_Cold_filter=Filtro frio

_Mid_color=Color medio

<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.heatmapcomparison.app</artifactId>

    <version>1.0.14</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.heatmapcomparison.app.mainplugin</artifactId>

  <version>1.0.14</version>

  <name>org.gvsig.legend.heatmapcomparison.app.mainplugin</name>

    <properties>

    <!-- Package info property values -->

    <gvsig.package.info.state>testing</gvsig.package.info.state>

    <gvsig.package.info.dependencies>required: org.gvsig.app.mainplugin -ge 2.4.0-A</gvsig.package.info.dependencies>

    <gvsig.package.info.official>true</gvsig.package.info.official>

    <gvsig.package.info.name>Vector legend: heat map comparison</gvsig.package.info.name>

    <gvsig.package.info.description>Legend for aggregate text symbols that are near.</gvsig.package.info.description>

    <gvsig.package.info.categories>View,Vector,Symbology</gvsig.package.info.categories>

    <gvsig.package.info.javaVM>j1_7</gvsig.package.info.javaVM>

    <gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-base-legends/pool</gvsig.package.info.poolURL>

  </properties>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.andami</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.heatmapcomparison.swing.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.heatmapcomparison.lib.impl</artifactId>

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.heatmapcomparison.swing.impl</artifactId>

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.app.mainplugin</artifactId>

      <scope>compile</scope>

    </dependency>

  </dependencies>

</project>

#Fri Jul 31 23:44:07 CEST 2020

buildNumber=15

<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.heatmapcomparison</artifactId>

  <version>1.0.14</version>

  <packaging>pom</packaging>

  <name>${project.artifactId}</name>

  <description>Legend for heat maps.</description>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.desktop</artifactId>

    <version>2.0.287</version>

  </parent>

  <url>https://devel.gvsig.org/sites/org.gvsig.legend.heatmapcomparison/${project.version}</url>

  <scm>

    <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-projects-pool/org.gvsig.legend.heatmapcomparison/tags/org.gvsig.legend.heatmapcomparison-1.0.14</connection>

    <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-projects-pool/org.gvsig.legend.heatmapcomparison/tags/org.gvsig.legend.heatmapcomparison-1.0.14</developerConnection>

    <url>https://devel.gvsig.org/redmine/projects/gvsig-projects-pool/repository/show/org.gvsig.legend.heatmapcomparison/tags/org.gvsig.legend.heatmapcomparison-1.0.14</url>

  </scm>

  <repositories>

    <repository>

      <id>gvsig-public-http-repository</id>

      <name>gvSIG maven public HTTP repository</name>

      <url>http://devel.gvsig.org/m2repo/j2se</url>

      <releases>

        <enabled>true</enabled>

        <updatePolicy>daily</updatePolicy>

        <checksumPolicy>warn</checksumPolicy>

      </releases>

      <snapshots>

        <enabled>true</enabled>

        <updatePolicy>daily</updatePolicy>

        <checksumPolicy>warn</checksumPolicy>

      </snapshots>

    </repository>

  </repositories>

  <distributionManagement>

    <site>

      <id>gvsig-repository</id>

      <url>dav:https://devel.gvsig.org/download/projects/gvsig-projects-pool/pool/${project.artifactId}/${project.version}</url>

    </site>

  </distributionManagement>

  <build>

    <plugins>

      <plugin>

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

        <artifactId>maven-release-plugin</artifactId>

        <configuration>

          <tagBase>https://devel.gvsig.org/svn/gvsig-projects-pool/org.gvsig.legend.heatmapcomparison/tags</tagBase>

        </configuration>

      </plugin>

    </plugins>

  </build>

  <dependencyManagement>

    <dependencies>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.14</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.legend.heatmapcomparison.lib.impl</artifactId>

        <version>1.0.14</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.legend.heatmapcomparison.swing.api</artifactId>

        <version>1.0.14</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.legend.heatmapcomparison.swing.impl</artifactId>

        <version>1.0.14</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.legend.heatmapcomparison.app.mainplugin</artifactId>

        <version>1.0.14</version>

      </dependency>

    </dependencies>

  </dependencyManagement>

  <modules>

    <module>org.gvsig.legend.heatmapcomparison.lib</module>

    <module>org.gvsig.legend.heatmapcomparison.swing</module>

    <module>org.gvsig.legend.heatmapcomparison.app</module>

  </modules>

</project>

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

  <artifactId>org.gvsig.legend.heatmapcomparison.lib.impl</artifactId>

  <name>org.gvsig.legend.heatmapcomparison.lib.impl</name>

  <parent>

    <groupId>org.gvsig</groupId>

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

    <version>1.0.14</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.ui</artifactId>

      <scope>compile</scope>

    </dependency>

  </dependencies>

</project>

/* 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.heatmapcomparison.lib.impl;

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

import org.gvsig.legend.heatmapcomparison.lib.api.HeatmapComparisonLegend;

import org.gvsig.legend.heatmapcomparison.lib.api.HeatmapComparisonLegendManager;

public class DefaultHeatmapComparisonLegendManager implements HeatmapComparisonLegendManager {

    @Override

    public HeatmapComparisonLegend create() {

        return new DefaultHeatmapComparisonLegend();

    }

    @Override

    public Class<? extends HeatmapComparisonLegend> getLegendClass() {

        return DefaultHeatmapComparisonLegend.class;

    }

}

package org.gvsig.legend.heatmapcomparison.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.GeometryUtils;

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.heatmapcomparison.lib.api.HeatmapComparisonLegend;

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.swing.api.ToolsSwingLocator;

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

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

public class DefaultHeatmapComparisonLegend extends AbstractVectorialLegend implements HeatmapComparisonLegend, IHasImageLegend {

    private ISymbol defaultSymbol;

    private DensityAlgorithm algorithm;

    private String fieldName;

    private Color rampColdColor;

    private Color rampMidColor;

    private Color rampHotColor;

    private int rampNumColors;

    private Geometry roi;

    private Image imageLegend;

    private HeatmapColorTable hmColorTable;

    private Expression hotFilter;

    private Expression coldFilter;

    private boolean useWeight;

    public DefaultHeatmapComparisonLegend() {

        this.defaultSymbol = new SimpleTextSymbol();

        this.algorithm = new DensityAlgorithm(30);

        this.fieldName = null;

        this.useWeight = false;

        this.setColorTable(10, Color.BLUE, new Color(255, 255, 0, 30), Color.RED);

    }

    @Override

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

        //TODO optimize required features

        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;

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

        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.setDistance(distance);

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

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

            }

        } 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.setDistance(distance);

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

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

                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 s = ExpressionEvaluatorLocator.getManager().createSymbolTable();

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

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

                    double value = 0;

                    try {

                        fst.setFeature(feature);

                        if (useWeight == true) {

                            if (n > 0) {

                                value = feature.getDouble(n);

                            }

                            fillAlgorithmHot(s, hotFilter, pointPixels, value);

                            fillAlgorithmCold(s, coldFilter, pointPixels, value);

                        } else {

                            fillAlgorithmHot(s, hotFilter, pointPixels, 1.0);

                            fillAlgorithmCold(s, coldFilter, pointPixels, 1.0);

                        }

                    } catch (Exception ex) {

                    }

                }

            }

        }

        );

    }

    protected void fillAlgorithmCold(MutableSymbolTable s, Expression filter, Point pointPixels, Double value) {

        Object boolResult = filter.execute(s);

        if (boolResult instanceof Boolean) {

            boolean hbool = (Boolean) boolResult;

            if (hbool) {

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

            }

        }

    }

    protected void fillAlgorithmHot(MutableSymbolTable s, Expression filter, Point pointPixels, Double value) {

        Object boolResult = filter.execute(s);

        if (boolResult instanceof Boolean) {

            boolean hbool = (Boolean) boolResult;

            if (hbool) {

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

            }

        }

    }

    /**

     * @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(int numColors, Color coldColor, Color midColor, Color hotColor) {

        this.rampColdColor = coldColor;

        this.rampMidColor = midColor;

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

        return this.fieldName;

    }

    @Override

    public void setFieldName(String fieldName) {

        this.fieldName = fieldName;

    }

    @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 Color[] getTargetColorTable() {

        return this.getHeatMapColorTable().getColorTable();

    }

    @Override

    public String getPathImage() {

        return null;

    }

    private HeatmapColorTable getHeatMapColorTable() {

        if (this.hmColorTable == null) {

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

        }

        return this.hmColorTable;

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.defaultSymbol = new SimpleTextSymbol();

        this.imageLegend = null;

        super.loadFromState(state);

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

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

        this.algorithm.setDistance(distance);

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

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

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

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

        this.useWeight = (boolean) state.get("useWeight");

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

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

    }

    @Override

    public int getRampNumColors() {

        return this.rampNumColors;

    }

    @Override

    public Color getRampColdColor() {

        return this.rampColdColor;

    }

    @Override

    public Color getRampMidColor() {

        return this.rampMidColor;

    }

    @Override

    public Color getRampHotColor() {

        return this.rampHotColor;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("fieldName", fieldName);

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

        state.set("rampNumColors", rampNumColors);

        state.set("rampColdColor", rampColdColor);

        state.set("rampMidColor", rampMidColor);

        state.set("rampHotColor", rampHotColor);

        state.set("useWeight", useWeight);

        state.set("coldFilter", coldFilter);

        state.set("hotFilter", hotFilter);

    }

    @Override

    public void setHotFilter(Expression hotFilter) {

        this.hotFilter = hotFilter;

    }

    @Override

    public void setColdFilter(Expression coldFilter) {

        this.coldFilter = coldFilter;

    }

    @Override

    public Expression getColdFilter() {

        return this.coldFilter;

    }

    @Override

    public Expression getHotFilter() {

        return this.hotFilter;

    }

    @Override

    public boolean getUseWeight() {

        return this.useWeight;

    }

    public void setUseWeight(boolean useWeight) {

        this.useWeight = useWeight;

    }

    private class DensityAlgorithm {

        private double[][] gridHot;

        private double[][] gridCold;

        private double[][] kernel;

        private int distance;

        private int height;

        private int with;

        private double maxValue;

        private double minValue;

        private final String HOT = "hot-value";

        private final String COLD = "cold-value";

        public DensityAlgorithm(int distance) {

            this.setDistance(distance);

        }

        public void setDistance(int distance) {

            if (this.distance == distance) {

                return;

            }

            this.distance = distance;

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

            double powDistance = Math.pow(this.distance, 2); // * this.distance;

            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 - Math.pow(dDist, 2) / powDistance, 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.gridHot = new double[with][height];

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

            this.maxValue = 0;

            this.minValue = 0;

        }

        public void addHot(int px, int py) {

            addHot(px, py, 1);

        }

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

            add(px, py, value, this.HOT);

        }

        public void addCold(int px, int py) {

            addCold(px, py, 1);

        }

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

            add(px, py, value, this.COLD);

        }

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

            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], grid);

                    }

                }

            }

        }

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

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

                return;

            }

            if (grid == this.HOT) {

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

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

                if (value > this.maxValue) {

                    this.maxValue = value;

                }

            }

            if (grid == this.COLD) {

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

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

                if (-value < this.minValue) {

                    this.minValue = -value;

                }

            }

        }

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

            try {

                ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

                Color c;

                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.getResultGrid(x, y);

                        int icolor = this.calculateIndexColorNotEqual(value, colorTable);

                        if (value==0.0) {

                            continue;

                        }

                        c = toolsSwingManager.alphaBlendingWithOpaqueBackground(

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

                                colorTable[icolor]

                        );

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

                    }

                }

            } catch (Exception ex) {

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

            }

        }

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

            try {

                Color c;

                ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

                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.getResultGrid(x, y);

                        int icolor = this.calculateIndexColorNotEqual(value, colorTable);

                        if (value==0.0) {

                            continue;

                        }

                        c = colorTable[icolor];

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

                    }

                }

            } catch (Exception ex) {

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

            }

        }

        private double getResultGrid(int x, int y) {

            double valueHot = this.gridHot[x][y];

            double valueCold = this.gridCold[x][y];

            return valueHot - valueCold;

        }

        private int calculateIndexColorNotEqual(double value, Color[] colorTable) {

            int midTable = (colorTable.length) / 2;

            if (value < 0) {

                int icolor = (int) (value * (midTable - 1) / minValue);

                int coldIndex = midTable - icolor - 1;

                return coldIndex;

            } else if (value > 0) {

                int icolor = (int) (value * (midTable - 1) / maxValue);

                int hotIndex = midTable + icolor + 1;

                return hotIndex;

            }

            return midTable;

        }

    }

    private static class HeatmapColorTable {

        private Color coldColor = null;

        private Color midColor = null;

        private Color hotColor = null;

        private Color[] targetColorTable = null;

        private int length = -1;

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

            this.coldColor = coldColor;

            this.midColor = midColor;

            this.hotColor = hotColor;

            this.length = length;

        }

        public Color[] getColorTable() {

            if (targetColorTable == null) {

                targetColorTable = new Color[length * 2 + 1];

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

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

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

                double deltaAlpha = (midColor.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));

                }

                targetColorTable[length] =new Color(midColor.getRed(), midColor.getGreen(), midColor.getBlue(), midColor.getTransparency());

                double deltaRedCold = (hotColor.getRed() - midColor.getRed()) / length;

                double deltaGreenCold = (hotColor.getGreen() - midColor.getGreen()) / length;

                double deltaBlueCold = (hotColor.getBlue() - midColor.getBlue()) / length;

                double deltaAlphaCold = (hotColor.getAlpha() - midColor.getAlpha()) / length;

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

                    int fixi = length + i;

                    targetColorTable[fixi]

                            = new Color(

                                    (int) (midColor.getRed() + i * deltaRedCold),

                                    (int) (midColor.getGreen() + i * deltaGreenCold),

                                    (int) (midColor.getBlue() + i * deltaBlueCold),

                                    (int) (midColor.getAlpha() + i * deltaAlphaCold));

                }

            }

            return targetColorTable;

        }

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

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

//        }

    }

}

/**

 * 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.heatmapcomparison.lib.impl;

import org.gvsig.fmap.mapcontext.MapContextLibrary;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.legend.heatmapcomparison.lib.api.HeatmapComparisonLegendLibrary;

import org.gvsig.legend.heatmapcomparison.lib.api.HeatmapComparisonLegendLocator;

import org.gvsig.symbology.impl.SymbologyDefaultImplLibrary;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.persistence.PersistenceManager;

public class HeatmapComparisonLegendLibraryImpl extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(HeatmapComparisonLegendLibrary.class);

        this.require(MapContextLibrary.class);

        this.require(SymbologyDefaultImplLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        HeatmapComparisonLegendLocator.registerHeatmapComparisonLegendManager(DefaultHeatmapComparisonLegendManager.class);

        MapContextManager mcmanager = MapContextLocator.getMapContextManager();

        mcmanager.registerLegend("HeatmapComparisonLegend", DefaultHeatmapComparisonLegend.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        persistenceManager.addDefinition(

            DefaultHeatmapComparisonLegend.class, 

            "DefaultHeatmapComparisonLegend", 

            "/org/gvsig/legend/heatmapcomparison/lib/impl/DefaultHeatmapComparisonLegend.persistence.xml"

        );

    }

}

<?xml version="1.0"?>

<definitions>

    <version>1.0.0</version>

    <classes>

        <class name="DefaultHeatmapComparisonLegend">

            <extends>

                <class>VectorialLegend</class>

            </extends>

            <fields>

                <field name="useWeight" type="boolean" defaultValue="false">

                    <description></description>

                </field>

                <field name="distance" type="integer" defaultValue="30">

                    <description></description>

                </field>

                <field name="fieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="rampColdColor" type="Object" classOfValue="java.awt.Color">

                    <description></description>

                </field>

                <field name="rampMidColor" type="Object" classOfValue="java.awt.Color">

                    <description></description>

                </field>

                <field name="rampHotColor" type="Object" classOfValue="java.awt.Color">

                    <description></description>

                </field>

                <field name="rampNumColors" type="integer" defaultValue="10">

                    <description></description>

                </field>

                <field name="hotFilter" type="Object" classOfValue="org.gvsig.expressionevaluator.Expression">

                    <description></description>

                </field>

                <field name="coldFilter" type="Object" classOfValue="org.gvsig.expressionevaluator.Expression">

                    <description></description>

                </field>

            </fields>

        </class>

    </classes>

</definitions>

org.gvsig.legend.heatmapcomparison.lib.impl.HeatmapComparisonLegendLibraryImpl

org.gvsig.legend.heatmapcomparison.lib.api.HeatmapComparisonLegendLibrary

/* 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.heatmapcomparison.lib.api;

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

public interface HeatmapComparisonLegendManager {

    /**

     * Creates an aggregate legend

     *

     * @return the aggregate legend

     */

    public HeatmapComparisonLegend create();

    public Class<? extends HeatmapComparisonLegend> getLegendClass();

}

package org.gvsig.legend.heatmapcomparison.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 HeatmapComparisonLegend extends IVectorLegend {

    public int getDistance();

    public void setDistance(int distance);

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

    public Color[] getTargetColorTable();

    public Geometry getROI();

    public void setROI(Geometry roi);

    public String getFieldName();

    public void setFieldName(String fieldName);

    public int getRampNumColors();

    public Color getRampColdColor();

    public Color getRampMidColor();

    public Color getRampHotColor();

    public void setHotFilter(Expression hotFilter);

    public void setColdFilter(Expression coldFilter);

    public Expression getColdFilter();

    public Expression getHotFilter();

    public boolean getUseWeight();

    public void setUseWeight(boolean useWeight);

}

/* 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.heatmapcomparison.lib.api;

import org.gvsig.tools.locator.AbstractLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

public class HeatmapComparisonLegendLocator extends AbstractLocator {

    /**

     * HeatmapLegend locator name

     */

    private static final String LOCATOR_NAME = "HeatmapComparisonLegendLocator";

    /**

     * HeatmapLegend manager name

     */

    public static final String MANAGER_NAME = "HeatmapComparisonLegendManager";

    /**

     * HeatmapLegend manager description

     */

    private static final String MANAGER_DESCRIPTION =

        "HeatmapComparisonLegend Manager of gvSIG";

    /**

     * Unique instance

     */

    private static final HeatmapComparisonLegendLocator instance = new HeatmapComparisonLegendLocator();

    @Override

    public String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Registers the Class implementing the HeatmapLegendManager interface.

     *

     * @param clazz

     *            implementing the HeatmapLegendManager interface

     */

    public static void registerHeatmapComparisonLegendManager(Class clazz){

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

    }

    /**

     * Registers the default Class implementing the HeatmapLegendManager interface

     *

     * @param clazz

     *            implementing the HeatmapLegendManager interface

     */

    public static void registerDefaultHeatmapComparisonLegendManager(Class clazz){

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

    }

    /**

     * Return a reference to HeatmapLegendManager.

     *

     * @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 HeatmapComparisonLegendManager getHeatmapComparisonLegendManager() throws LocatorException {

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

    }

    /**

     * @return

     */

    public static Locator getInstance() {

        return instance;

    }

}