Application: gvSIG desktop » gvSIG legends: base legends

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

    <version>1.0.4</version>

  </parent>

  <groupId>org.gvsig</groupId>

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

  <packaging>pom</packaging>

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

  <modules>

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

  </modules>

</project>

#Tue Sep 26 23:24:29 CEST 2017

buildNumber=6

<!-- 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.aggregate.lib.api</include>

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

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

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

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

package org.gvsig.legend.aggregate.app;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.plugins.Extension;

public class AggregateLegendTextExtension extends Extension {

    @Override

    public void initialize() {

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

    }

    @Override

    public void execute(String string) {

    }

    @Override

    public boolean isEnabled() {

        return true;

    }

    @Override

    public boolean isVisible() {

        return true;

    }

}

<?xml version="1.0"?>

<!--

Definitions of plugin persistence org.gvsig.aggregatelegend.app.mainplugin

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

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

      <extends>

      </extends>

      <description>Persistence of the legend of aggregate texts</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

_Aggregate_legend_description=Leyenda de agrupaci\u00f3n de marcadores

_Aggregate_legend=Agrupaci\u00f3n de marcadores

_Use_basic_cluster_mark=Usar estilo b\u00e1sico para la agrupaci\u00f3n de marcadores

_Use_styled_cluster_mark=Usar un estilo avanzado para la agrupaci\u00f3n de marcadores

_Symbol_size=Tama\u00f1o de simbolo

_Outline_color=Color del contorno

_Fill_color=Color de relleno

_Text_color=Color de texto

_Text_font=Fuente del texto

_Show_bounds=Mostrar l\u00edmites

_Style=Estilo

_Operation=Operaci\u00f3n

_Attribute=Atributo

_Aditional_value=Valor adicional

Alpha=Alpha

Average=Media

_Calculate_the_average_of_the_selected_attribute_for_the_grouped_features=Calcula la media del atributo seleccionado para las features agrupadas

Count=Cuenta

_Count_of_grouped_features=Cuenta de las features agrupadas

Maximum=M\u00e1ximo

_Calculate_the_maximum_of_the_selected_attribute_for_the_grouped_features=Calcula el maximo del atributo seleccionado para las features agrupadas

Minimun=Minimo

_Calculate_the_minimun_of_the_selected_attribute_for_the_grouped_features=Calcula el minimo del atributo seleccionado para las features agrupadas

_Select_style=Seleccion de estilo

Sum=Suma

_Calculate_the_sum_of_the_selected_attribute_for_the_grouped_features=Calcula la suma del atributo seleccionado para las features agrupadas

_Aggregate_legend_description=Marker clustering legend

_Aggregate_legend=Marker clustering

_Use_basic_cluster_mark=Use basic style cluster mark

_Use_styled_cluster_mark=Use advanced style cluster mark

_Symbol_size=Symbol size

_Outline_color=Outline color

_Fill_color=Fill color

_Text_color=Text color

_Text_font=Text font

_Show_bounds=Show bounds

_Style=Style

_Operation=Operation

_Attribute=Attribute

_Aditional_value=Aditional value

Alpha=Alpha

Average=Average

_Calculate_the_average_of_the_selected_attribute_for_the_grouped_features=Calculate the average of the selected attribute for the grouped features

Count=Count

_Count_of_grouped_features=Count of grouped features

Maximum=Maximum

_Calculate_the_maximum_of_the_selected_attribute_for_the_grouped_features=Calculate the maximum of the selected attribute for the grouped features

Minimun=Minimun

_Calculate_the_minimun_of_the_selected_attribute_for_the_grouped_features=Calculate the minimun of the selected attribute for the grouped features

_Select_style=Select style

_Calculate_the_sum_of_the_selected_attribute_for_the_grouped_features=Calculate the sum of the selected attribute for the grouped features

Sum=Sum

<?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.aggregate.app.AggregateLegendTextExtension"

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

      <action 

          name="aggregatelegend-set" 

          label="_Set_aggregated_legend" 

          tooltip="_Set_aggregated_legend"

          position="900700100" 

          action-command="aggregatelegend-set"

          accelerator=""

      />

    </extension>

  </extensions>

</plugin-config>

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

    <version>1.0.4</version>

  </parent>

  <groupId>org.gvsig</groupId>

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

  <version>1.0.4</version>

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

    <properties>

    <!-- Package info property values -->

    <gvsig.package.info.state>devel</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: Aggregate text symbols</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.aggregate.swing.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

  </dependencies>

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

  <groupId>org.gvsig</groupId>

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

  <version>1.0.4</version>

  <packaging>pom</packaging>

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

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

  <parent>

    <groupId>org.gvsig</groupId>

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

    <version>2.0.205</version>

  </parent>

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

  <scm>

    <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.aggregate/tags/org.gvsig.legend.aggregate-1.0.4</connection>

    <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.aggregate/tags/org.gvsig.legend.aggregate-1.0.4</developerConnection>

    <url>https://devel.gvsig.org/redmine/projects/gvsig-base-legends/repository/show/org.gvsig.legend.aggregate/tags/org.gvsig.legend.aggregate-1.0.4</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-base-legends/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-base-legends/org.gvsig.legend.aggregate/tags</tagBase>

        </configuration>

      </plugin>

    </plugins>

  </build>

  <dependencyManagement>

    <dependencies>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.4</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.4</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.4</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.4</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.4</version>

      </dependency>

    </dependencies>

  </dependencyManagement>

  <modules>

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

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

    <module>org.gvsig.legend.aggregate.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>

  <parent>

    <groupId>org.gvsig</groupId>

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

    <version>1.0.4</version>

  </parent>

  <groupId>org.gvsig</groupId>

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

  <packaging>pom</packaging>

  <modules>

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

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

  </modules>

</project>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="DefaultAggregateLegend">

      <extends>

        <class>VectorialLegend</class>

      </extends>

      <fields>

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

          <description></description>

        </field>

        <field name="fillColor" type="object" classOfValue="java.awt.Color">

          <description></description>

        </field>

        <field name="outlineColor" type="object" classOfValue="java.awt.Color">

          <description></description>

        </field>

        <field name="textColor" type="object" classOfValue="java.awt.Color">

          <description></description>

        </field>

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

          <description></description>

        </field>

        <field name="font" type="object" classOfValue="java.awt.Font">

          <description></description>

        </field>

        <field name="labelStyle" type="object" classOfValue="org.gvsig.fmap.mapcontext.rendering.symbols.styles.ILabelStyle">

          <description></description>

        </field>

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

          <description></description>

        </field>

        <field name="operation" type="object" classOfValue="org.gvsig.legend.aggregate.lib.api.Operation">

          <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>  

org.gvsig.legend.aggregate.lib.impl.AggregateLegendLibraryImpl

package org.gvsig.legend.aggregate.lib.impl.operation;

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

import org.gvsig.legend.aggregate.lib.spi.AbstractOperation;

public class CountOperation extends AbstractOperation {

    int count = 0;

    public CountOperation() {

        super("Count", "_Count_of_grouped_features");

    }

    @Override

    public void reset() {

        count = 0;

    }

    @Override

    public void perform(Feature feature) {

        count++;

    }

    @Override

    public Object getValue() {

        return count;

    }

}

package org.gvsig.legend.aggregate.lib.impl.operation;

import java.text.MessageFormat;

import org.apache.commons.lang3.StringUtils;

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

import org.gvsig.legend.aggregate.lib.spi.AbstractOperation;

public class AvgOperation extends AbstractOperation {

    private double avg = 0;

    private int count = 0;

    public AvgOperation() {

        super(

            "Average", 

            "_Calculate_the_average_of_the_selected_attribute_for_the_grouped_features"

        );

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public boolean isAditionalValueRequiered() {

        return true;

    }

    @Override

    public void reset() {

        avg = 0;

        count = 0;

    }

    @Override

    public void perform(Feature feature) {

            try {

                double value = feature.getDouble(this.getAttributeName());

                avg = ( avg * count + value ) / (count+1);

                count++;

            } catch(Exception ex) {

            }

    }

    @Override

    public Object getValue() {

        return this.avg;

    }

    @Override

    public String format() {

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

            return super.format(); 

        }

        try {

            return MessageFormat.format("{0,number,"+this.getAditionalValue()+"}", this.getValue());

        } catch(Exception ex) {

            return super.format(); 

        }

    }

}

package org.gvsig.legend.aggregate.lib.impl.operation;

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

import org.gvsig.legend.aggregate.lib.spi.AbstractOperation;

public class MinOperation extends AbstractOperation {

    private int min = 0;

    public MinOperation() {

        super("Minimun", "_Calculate_the_minimum_of_the_selected_attribute_for_the_grouped_features");

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public void reset() {

        min = 0;

    }

    @Override

    public void perform(Feature feature) {

        try {

            int x = feature.getInt(this.getAttributeName());

            if( x > min ) {

                min = x;

            }

        } catch (Exception ex) {

        }

    }

    @Override

    public Object getValue() {

        return this.min;

    }

}

package org.gvsig.legend.aggregate.lib.impl.operation;

import java.text.MessageFormat;

import org.apache.commons.lang3.StringUtils;

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

import org.gvsig.legend.aggregate.lib.spi.AbstractOperation;

public class SumOperation extends AbstractOperation {

    int sum = 0;

    public SumOperation() {

        super("Sum", "_Calculate_the_sum_of_the_selected_attribute_for_the_grouped_features");

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public boolean isAditionalValueRequiered() {

        return true;

    }

    @Override

    public void reset() {

        sum = 0;

    }

    @Override

    public void perform(Feature feature) {

        try {

            double x = feature.getDouble(this.getAttributeName());

            sum += x;

        } catch (Exception ex) {

        }

    }

    @Override

    public Object getValue() {

        return sum;

    }

    @Override

    public String format() {

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

            return super.format(); 

        }

        try {

            return MessageFormat.format("{0,number,"+this.getAditionalValue().trim()+"}", this.getValue());

        } catch(Exception ex) {

            return super.format(); 

        }

    }    

}

package org.gvsig.legend.aggregate.lib.impl.operation;

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

import org.gvsig.legend.aggregate.lib.spi.AbstractOperation;

public class MaxOperation extends AbstractOperation {

    private int max = 0;

    public MaxOperation() {

        super("Maximum", "_Calculate_the_maximum_of_the_selected_attribute_for_the_grouped_features");

    }

    @Override

    public boolean isAttributeRequiered() {

        return true;

    }

    @Override

    public void reset() {

        max = 0;

    }

    @Override

    public void perform(Feature feature) {

        try {

            int x = feature.getInt(this.getAttributeName());

            if( x > max ) {

                max = x;

            }

        } catch (Exception ex) {

        }

    }

    @Override

    public Object getValue() {

        return this.max;

    }

}

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

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.fmap.mapcontext.rendering.symbols.styles.ILabelStyle;

import org.gvsig.legend.aggregate.lib.api.AggregateLegend;

import org.gvsig.legend.aggregate.lib.api.AggregateLegendManager;

import org.gvsig.legend.aggregate.lib.api.Operation;

import org.gvsig.legend.aggregate.lib.impl.operation.AvgOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.CountOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.MaxOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.MinOperation;

import org.gvsig.legend.aggregate.lib.impl.operation.SumOperation;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.SimpleLabelStyle;

public class DefaultAggregateLegendManager implements AggregateLegendManager {

    private ILabelStyle defaultLabelStyle = null;

    private Map<String,Operation> operations;

    private Operation defaultOperation = null;

    public DefaultAggregateLegendManager() {

        this.defaultLabelStyle = new SimpleLabelStyle();

        this.addOperation(new CountOperation());

        this.addOperation(new MinOperation());

        this.addOperation(new MaxOperation());

        this.addOperation(new AvgOperation());

        this.addOperation(new SumOperation());

    }

    @Override

    public AggregateLegend createAggregateLegend() {

        return new DefaultAggregateLegend();

    }

    @Override

    public Class<? extends AggregateLegend> getLegendClass() {

        return DefaultAggregateLegend.class;

    }

    @Override

    public ILabelStyle getDefaultLabelStyle() {

        return this.defaultLabelStyle;

    }

    @Override

    public void setDefaultLabelStyle(ILabelStyle defaultLabelStyle) {

        this.defaultLabelStyle = defaultLabelStyle;

    }

    @Override

    public void addOperation(Operation operation) {

        if( this.operations == null ) {

            this.operations = new HashMap<>();

        }

        if( this.operations.isEmpty() ) {

            this.defaultOperation = operation;

        }

        this.operations.put(operation.getName(),operation);

    }

    @Override

    public Collection<Operation> getOperations() {

        if( this.operations == null ) {

            this.operations = new HashMap<>();

        }

        return this.operations.values();

    }

    @Override

    public Operation getDefaultOperation() {

        return this.defaultOperation;

    }

    @Override

    public Operation createOperation(String name) {

        Operation op = this.operations.get(name);

        if( op == null ) {

            throw new IllegalArgumentException("Can't locate operation '"+name+"'.");

        }

        return op.clone();

    }

}

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

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Ellipse2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import javax.swing.UIManager;

import org.cresques.cts.ICoordTrans;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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

import org.gvsig.fmap.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.rendering.legend.LegendException;

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

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

import org.gvsig.fmap.mapcontext.rendering.symbols.styles.ILabelStyle;

import org.gvsig.legend.aggregate.lib.api.AggregateLegend;

import org.gvsig.legend.aggregate.lib.api.AggregateLegendLocator;

import org.gvsig.legend.aggregate.lib.api.Operation;

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.fill.impl.SimpleFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.SimpleLineSymbol;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.logger.FilteredLogger;

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 DefaultAggregateLegend extends AbstractVectorialLegend implements AggregateLegend {

    private static class Group {

//        private final Point pointGeo;

//        private final Rectangle2D rectangle;

        private Operation op;

        private final Point pointPixels;

        private final Ellipse2D circle;

        public Group(Point pointGeo, Point pointPixels, double size, Operation op) {

            this.op = op;

            this.op.reset();

//            this.pointGeo = pointGeo;

            this.pointPixels = pointPixels;

            double d2 = size * 2;

//            this.rectangle = new Rectangle2D.Double(pointPixels.getX() - distance, pointPixels.getY() - distance, d2, d2);

            this.circle = new Ellipse2D.Double(pointPixels.getX() - size, pointPixels.getY() - size, d2, d2);

        }

        public boolean contains(Point pointPixels) {

//            return this.rectangle.contains(pointPixels.getX(), pointPixels.getY());

          return this.circle.contains(pointPixels.getX(), pointPixels.getY());

        }

        public void add(Feature feature) {

            op.perform(feature);

        }

        public Operation getOperation() {

            return this.op;

        }

    }

    private static final Logger LOG = LoggerFactory.getLogger(DefaultAggregateLegend.class);

    private List<Group> groups;

    private int symbolSize; // Pixels

    private Color fillColor;

    private Color outlineColor;

    private Color textColor;

    private boolean showBounds;

    private Font font;

    private boolean useStyle;

    private ILabelStyle labelStyle;

    private Operation operation;

    private SimpleFillSymbol defaultSymbol;

    public DefaultAggregateLegend() {

        this.groups = null;

        this.useStyle = false;

        this.symbolSize = 30;

        this.fillColor = new Color(0xd0ffcccc, true); // Un rojo

        this.outlineColor = new Color(0xff5f60de, true); // un azul

        this.textColor = new Color(0xff000000, true); // negro

        this.showBounds = false;

        this.labelStyle = null;        

        this.font = UIManager.getFont("Label.font");

        this.operation = AggregateLegendLocator.getAggregateLegendManager().getDefaultOperation().clone();

        this.defaultSymbol = new SimpleFillSymbol();

        this.defaultSymbol.setOutline(new SimpleLineSymbol());

        this.defaultSymbol.getOutline().setLineColor(this.outlineColor);

        this.defaultSymbol.setFillColor(this.fillColor);

    }

    @Override

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

        if( this.operation.isAttributeRequiered() && this.operation.getAttributeName()!=null ) {

            return new String[]{

                this.operation.getAttributeName(),

                featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()

            };

        }

        return new String[]{

            featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()

        };

    }

    @Override

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    @Override

    public void setDefaultSymbol(ISymbol is) {

    }

    @Override

    public ISymbol getSymbolByFeature(Feature ftr) throws MapContextException {

        return this.getDefaultSymbol();

    }

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

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

        this.drawGroups(image, g, cancel, viewPort.getAffineTransform());

    }

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

        this.groups = new ArrayList<>();

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

                    boolean inGroup = false;

                    for( Group group : groups ) {

                        if( group.contains(pointPixels) ) {

                            group.add(feature);

                            inGroup = true;

                            break;

                        }

                    }

                    if( !inGroup ) {

                        Group group = new Group(pointGeo, pointPixels, getSymbolSize(), getOperation().clone());

                        group.add(feature);

                        groups.add(group);

                    }

                }

            }

        });

    }

    private void drawGroups(BufferedImage image, Graphics2D g, Cancellable cancel, AffineTransform affineTransform) {

        FilteredLogger logger = new FilteredLogger(LOG, "", 10);

        AffineTransform identity = new AffineTransform();

        g.setFont(this.font);

        FontMetrics fm = g.getFontMetrics();

        int fontAscent = fm.getAscent();

        int fontAscentAddDescentDiv2 = ((fm.getAscent() + fm.getDescent())) / 2;        

        for( Group group : groups ) {

            if( cancel.isCanceled() ) {

                return;

            }

            try {

                int x = (int) group.pointPixels.getX();

                int y = (int) group.pointPixels.getY();

                String txt = group.getOperation().format();

                if( this.useStyle && this.labelStyle != null ) {

                    Dimension size = this.labelStyle.getSize();

                    this.labelStyle.setTextFields(new String[]{txt});

                    g.setTransform(identity);

                    g.translate(x-size.getWidth()/2, y-size.getHeight()/2);

                    Rectangle rect = new Rectangle(

                        0,

                        0,

                        (int)size.getWidth(),

                        (int)size.getHeight());

                    this.labelStyle.drawInsideRectangle(g, rect);

                    Rectangle2D[] bounds = this.labelStyle.getTextBounds();

                    if(bounds.length>0){

                        Rectangle2D bound = bounds[0];

                        Rectangle2D expandedBound = new Rectangle2D.Double(

                            bound.getMinX()*size.getWidth(),

                            bound.getMinY()*size.getHeight(),

                            bound.getWidth()*size.getWidth(),

                            bound.getHeight()*size.getHeight());

                        drawCenteredString(txt, expandedBound, g);

                    }

                    g.translate(-(x-size.getWidth()/2), -(y-size.getHeight()/2));

                } else {

                    int r = symbolSize/2;

                    g.setColor(this.fillColor);

                    g.fillOval( x-r, y-r, 2*r, 2*r);

                    g.setColor(this.outlineColor);

                    g.drawOval( x-r, y-r, 2*r, 2*r);

                    if( this.showBounds ) {

                        g.drawRect( x-r, y-r, 2*r, 2*r);

                    }

                    g.setColor(this.textColor);

                    int txtX = x - (fm.stringWidth(txt) / 2);

                    int txtY = fontAscent + y - fontAscentAddDescentDiv2; //((fm.getAscent() + fm.getDescent())) / 2;

                    g.drawString(txt, txtX, txtY);

                }

            } catch (Exception ex) {

                logger.warn("Can't draw group",ex);

            }

        }

    }

    private void drawCenteredString(String s, Rectangle2D rect, Graphics2D g) {

        double x = rect.getMinX();

        double y = rect.getMinY();

        double w = rect.getWidth();

        double h = rect.getHeight();

        FontMetrics fm = g.getFontMetrics();

        int auxX = (int)(x+((w - fm.stringWidth(s)) / 2));

        int auxY = (int)(y+((fm.getAscent() + (h - (fm.getAscent() + fm.getDescent())) / 2)));

        g.setColor(Color.BLACK);

        g.drawString(s, auxX, auxY);

      }

    @Override

    public ILabelStyle getLabelStyle() {

        return this.labelStyle;

    }

    @Override

    public void setLabelStyle(ILabelStyle labelStyle) {

        this.labelStyle = labelStyle;

    }

    @Override

    public int getSymbolSize() {

        return this.symbolSize;

    }

    @Override

    public void setSymbolSize(int simbolSize) {

        boolean changed = (this.symbolSize == simbolSize);

        this.symbolSize = simbolSize;

        if( changed ) {

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

        }

    }

    @Override

    public Operation getOperation() {

        return this.operation;

    }

    @Override

    public void setOperation(Operation operation) {

        boolean changed = (this.operation.getName().equalsIgnoreCase(operation.getName()));

        this.operation = operation;

        if( changed ) {

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

        }

    }

    @Override

    public Color getFillColor() {

        return fillColor;

    }

    @Override

    public void setFillColor(Color fillColor) {

        boolean changed = (this.fillColor.equals(fillColor));

        this.fillColor = fillColor;

        this.defaultSymbol.setFillColor(this.fillColor);

        if( changed ) {

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

        }

    }

    @Override

    public Color getOutlineColor() {

        return outlineColor;

    }

    @Override

    public void setOutlineColor(Color outlineColor) {

        boolean changed = (this.outlineColor.equals(outlineColor));

        this.outlineColor = outlineColor;

        this.defaultSymbol.getOutline().setLineColor(this.outlineColor);

        if( changed ) {

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

        }

    }

    @Override

    public boolean isShowBounds() {

        return showBounds;

    }

    @Override

    public void setShowBounds(boolean showBounds) {

        boolean changed = (this.showBounds == showBounds);

        this.showBounds = showBounds;

        if( changed ) {

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

        }

    }

    @Override

    public Font getFont() {

        return font;

    }

    @Override

    public void setFont(Font font) {

        this.font = font;

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

    }

    @Override

    public boolean isUseStyle() {

        return useStyle;

    }

    @Override

    public void setUseStyle(boolean useStyle) {

        boolean changed = (this.useStyle == useStyle);

        this.useStyle = useStyle;

        if( changed ) {

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

        }

    }

    @Override

    public Color getTextColor() {

        return this.textColor;

    }

    @Override

    public void setTextColor(Color textColor) {

        boolean changed = (this.textColor.equals(textColor));

        this.textColor = textColor;

        if( changed ) {

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

        }

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

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

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

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

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

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

        this.font = (Font) state.get("font");

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

        this.labelStyle = (ILabelStyle) state.get("labelStyle");

        this.operation = (Operation) state.get("operation");

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("symbolSize", symbolSize);

        state.set("fillColor", fillColor);

        state.set("outlineColor", outlineColor);

        state.set("textColor", textColor);

        state.set("showBounds", showBounds);

        state.set("font", font);

        state.set("useStyle", useStyle);

        state.set("labelStyle", labelStyle);

        state.set("operation", operation);

    }

}

/**

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

import org.gvsig.fmap.mapcontext.MapContextLibrary;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.legend.aggregate.lib.api.AggregateLegendLibrary;

import org.gvsig.legend.aggregate.lib.api.AggregateLegendLocator;

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 AggregateLegendLibraryImpl extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(AggregateLegendLibrary.class);

        this.require(MapContextLibrary.class);

        this.require(SymbologyDefaultImplLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        AggregateLegendLocator.registerAggregateLegendManager(DefaultAggregateLegendManager.class);

        MapContextManager mcmanager = MapContextLocator.getMapContextManager();

        mcmanager.registerLegend("AggregateLegend", DefaultAggregateLegend.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        persistenceManager.registerFactory(new OperationPersistenceFactory());

        persistenceManager.addDefinition(

            DefaultAggregateLegend.class, 

            "DefaultAggregateLegend", 

            "/org/gvsig/legend/aggregate/lib/impl/DefaultAggregateLegend.persistence.xml"

        );

    }

}

/**

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

 */

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

import org.gvsig.legend.aggregate.lib.api.AggregateLegendLocator;

import org.gvsig.legend.aggregate.lib.api.AggregateLegendManager;

import org.gvsig.legend.aggregate.lib.api.Operation;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.AbstractSinglePersistenceFactory;

import org.gvsig.tools.persistence.PersistentState;

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

public class OperationPersistenceFactory extends AbstractSinglePersistenceFactory {

    static final String FIELD_NAME = "name";

    static final String FIELD_ATTRIBUTE = "attribute";

    static final String FIELD_VALUE = "value";

    private static final String DYNCLASS_NAME = "AggregateLegendOperation";

    private static final String DYNCLASS_DESCRIPTION = "Operation for aggregate legend";

    public OperationPersistenceFactory() {

        super(Operation.class, DYNCLASS_NAME, DYNCLASS_DESCRIPTION, null, null);

        DynStruct definition = this.getDefinition();

        definition.addDynFieldString(FIELD_NAME).setMandatory(true);

        definition.addDynFieldString(FIELD_ATTRIBUTE).setMandatory(false);

        definition.addDynFieldString(FIELD_VALUE).setMandatory(false);

    }

    @Override

    public Object createFromState(PersistentState state)

        throws PersistenceException {

        AggregateLegendManager manager = AggregateLegendLocator.getAggregateLegendManager();

        String name = (String) state.get(FIELD_NAME);

        Operation operation = manager.createOperation(name);

        operation.setAttributeName(state.getString(FIELD_ATTRIBUTE));

        operation.setAditionalValue(state.getString(FIELD_VALUE));

        return operation;

    }

    @Override

    public void saveToState(PersistentState state, Object obj)

        throws PersistenceException {

        Operation op = (Operation) obj;

        state.set(FIELD_NAME, op.getName());

        state.set(FIELD_ATTRIBUTE, op.getAttributeName());

        state.set(FIELD_VALUE, op.getAditionalValue());

    }

}

<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.aggregate.lib.impl</artifactId>

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

  <parent>

    <groupId>org.gvsig</groupId>

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

    <version>1.0.4</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.legend.aggregate.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>