gvSIG tools: basic charts

package org.gvsig.project.documents.view.legend;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Map;

import org.cresques.cts.ICoordTrans;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.legend.IBarsChartLegend;

import org.gvsig.chart.legend.IChartLegend;

import org.gvsig.chart.legend.symbols.IChartSymbol;

import org.gvsig.chart.model.ChartDataSet;

import org.gvsig.chart.renderer.ChartSerieEntity;

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.FeatureStore;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

import org.gvsig.symbology.SymbologyLocator;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.ISimpleFillSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.util.Callable;

import org.jfree.chart.LegendItem;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class BarsChartLegend extends VectorialUniqueValueLegend implements IBarsChartLegend {

    final static private Logger LOGGER = LoggerFactory.getLogger(BarsChartLegend.class);

    public static class RegisterLegend implements Callable {

        @Override

        public Object call() throws Exception {

            MapContextManager manager = MapContextLocator.getMapContextManager();

            manager.registerLegend(IChartLegend.BARSCHART_LEGEND_NAME,

                    BarsChartLegend.class);

            return Boolean.TRUE;

        }

    }

    public static final String BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME = "BarsChartLegend";

    private static final String FIELD_NAMES = "FieldLegendNames";

    private static final String FIELD_LABEL_NAMES = "FieldLabelNames";

    private static final String FIELD_LABEL_COLOR = "FieldLabelColor";

    protected ISymbol backgroundSymbol;

    protected String[] fields;

    protected String[] labels;

    protected int size = 150;

    protected boolean is3D;

    protected boolean isOutlineShow;

    protected Color outlineColor;

    protected int outlineWidth;

    protected boolean onlySelection = false;

    protected int referenceSystem = 0;

    protected String fieldSize;

    protected String fieldNormalize = "---";

    protected int sizeFrom = 10;

    protected int sizeTo = 1000;

    protected int unit = -1;

    protected int sizeOption = IChartSymbol.SIZEFIXED;

    protected boolean isActiveLimits;

    protected double minFeature;

    protected double maxFeature;

    protected Color[] colors = null;

    protected IChartSymbol symbol;

    private double maxField;

    protected FeatureSelection featSelection;

    public BarsChartLegend() {

    }

    public BarsChartLegend(int shapeType) {

        super(shapeType);

    }

    @Override

    public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

            Cancellable cancel, double scale, Map queryParameters,

            ICoordTrans coordTrans, FeatureStore featureStore,

            FeatureQuery featureQuery) throws LegendException {

        try {

            this.featSelection = featureStore.getFeatureSelection();

            System.out.println("CHARTLEGEND: " + featSelection.getSelectedCount() + " seleccionados.");

        } catch (DataException e) {

            e.printStackTrace();

        }

        super.draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans,

                featureStore, featureQuery);

    }

    @Override

    public boolean is3D() {

        return is3D;

    }

    @Override

    public void setIs3D(boolean b) {

        is3D = b;

    }

    @Override

    public int getSize() {

        return size;

    }

    @Override

    public void setSize(int size) {

        this.size = size;

    }

    @Override

    public boolean isOutlineShow() {

        return isOutlineShow;

    }

    @Override

    public void setOutlineShow(boolean isOutlineShow) {

        this.isOutlineShow = isOutlineShow;

    }

    @Override

    public Color getOutlineColor() {

        return outlineColor;

    }

    @Override

    public void setOutlineColor(Color outlineColor) {

        this.outlineColor = outlineColor;

    }

    @Override

    public int getOutlineWidth() {

        return outlineWidth;

    }

    @Override

    public void setOutlineWidth(int outlineWidth) {

        this.outlineWidth = outlineWidth;

    }

    @Override

    public void setOnlySelection(boolean onlySelection) {

        this.onlySelection = onlySelection;

    }

    @Override

    public boolean isOnlySelection() {

        return onlySelection;

    }

    @Override

    public ISymbol getBackgroundSymbol() {

        return backgroundSymbol;

    }

    @Override

    public void setBackgroundSymbol(ISymbol backgroundSymbol) {

        this.backgroundSymbol = backgroundSymbol;

    }

    @Override

    public int getSizeOption() {

        return this.sizeOption;

    }

    @Override

    public String getFieldSize() {

        return this.fieldSize;

    }

    @Override

    public String getFieldNormalize() {

        return this.fieldNormalize;

    }

    @Override

    public int getSizeFrom() {

        return this.sizeFrom;

    }

    @Override

    public int getSizeTo() {

        return this.sizeTo;

    }

    @Override

    public int getUnit() {

        return unit;

    }

    @Override

    public void setSizeFrom(int s) {

        this.sizeFrom = s;

    }

    @Override

    public void setSizeTo(int s) {

        this.sizeTo = s;

    }

    @Override

    public void setUnit(int unit) {

        this.unit = unit;

    }

    @Override

    public void setFieldSize(String f) {

        this.fieldSize = f;

    }

    @Override

    public void setFieldNormalize(String f) {

        this.fieldNormalize = f;

    }

    @Override

    public void setSizeOption(int option) {

        this.sizeOption = option;

    }

    @Override

    public boolean isActiveLimits() {

        return isActiveLimits;

    }

    @Override

    public void setActiveLimits(boolean b) {

        this.isActiveLimits = b;

    }

    @Override

    public Color[] getColors() {

        return colors;

    }

    @Override

    public void setColors(Color[] colors) {

        this.colors = colors;

        updateSymbols();

    }

    @Override

    public int getReferenceSystem() {

        return referenceSystem;

    }

    @Override

    public void setReferenceSystem(int rs) {

        this.referenceSystem = rs;

    }

    @Override

    public void setMinFeature(double min) {

        this.minFeature = min;

    }

    @Override

    public void setMaxFeature(double max) {

        this.maxFeature = max;

    }

    @Override

    public ISymbol getSymbolByFeature(Feature feat) throws MapContextException {

        Feature feat2 = feat.getCopy();

        if (this.onlySelection) {

            if (!featSelection.isSelected(feat)) {

                return null;

            }

        }

        // TODO: AQU? PRODR?AMOS RECUPERAR VARIOS SIMBOLOS. POR AHORA, SUPONEMOS QUE EL DEFAULTSYMBOL ES EL QUE TIENE EL CHARTSYMBOL

        symbol = (IChartSymbol) getDefaultSymbol();

        if (symbol == null) {

            symbol = (IChartSymbol) MapContextLocator

                    .getSymbolManager().createSymbol(IChartSymbol.SYMBOL_NAME);

        }

        symbol.setOnlySelection(onlySelection);

        double size1 = 0d;

        ChartDataSet dataSet = ChartLocator.getServiceManager()

                .getChartManager().createChartDataSet();

        String[] names = getFieldNames();

        if (names != null) {

            ArrayList groupedBy = new ArrayList();

            ArrayList serie = new ArrayList();

            ArrayList category = new ArrayList();

            for (String name : names) {

                double val = feat2.getDouble(name);

                if (sizeOption == IChartSymbol.SIZESUM) {

                    size1 += val;

                }

                groupedBy.add(name);

                serie.add("default");

                category.add(val);

            }

            dataSet.addData("groupby", groupedBy);

            dataSet.addData("series", serie);

            dataSet.addData("categories", category);

            symbol.getChart().setChartDataSet(dataSet);

            ChartService cs = symbol.getChart();

            cs.getChartProperties().setChartDimension(this.is3D);

            List<ChartSerieEntity> lst = cs.getChartLegendItems();

            for (int j = 0; j < names.length; j++) {

                colors[j] = getSymbolByValue(names[j]).getColor();

                LegendItem item = new LegendItem(names[j], colors[j]);

                item.setSeriesKey(names[j]);

                ChartSerieEntity e = cs.createNewChartSerieEntity(item);

                if (e != null) {

                    lst.add(e);

                }

            }

            cs.setCategoriesPaint(Arrays.asList(colors));

        }

        double separation = sizeTo - sizeFrom;

        switch (sizeOption) {

            case IChartSymbol.SIZESUM:

                if (isActiveLimits()) {

                    double difFeat = maxFeature - minFeature;

                    double step = difFeat / separation;

                    size1 = sizeFrom + ((size1 - minFeature) / step);

                }

                symbol.setSize(size1);

                break;

            case IChartSymbol.SIZEFIELD:

                if (separation == 0) {

                    separation = 1;

                }

                double value = feat2.getDouble(getFieldSize());

                if (!getFieldNormalize().equals("---")) {

                    double normalize = feat2.getDouble(getFieldNormalize());

                    if (normalize != 0) {

                        value = value / normalize;

                    }

                    if (isActiveLimits()) {

                        size1 = sizeFrom + (value * separation);

                    } else {

                        size1 = value;

                    }

                } else {

                    if (isActiveLimits()) {

                        double difFeat = maxFeature - minFeature;

                        double step = difFeat / separation;

                        size1 = sizeFrom + ((value - minFeature) / step);

                    } else {

                        size1 = value;

                    }

                }

                symbol.setSize(size1);

                break;

            default:

                symbol.setSize(getSize());

                break;

        }

        return symbol;

    }

    public String[] getFieldNames() {

        return fields;

    }

    @Override

    public String[] getFieldLabels() {

        if (labels == null) {

            return new String[0];

        }

        return labels;

    }

    @Override

    public void setFields(String[] fields) {

        this.fields = fields;

        updateSymbols();

    }

    @Override

    public void setLabels(String[] fields) {

        this.labels = fields;

        updateSymbols();

    }

    @SuppressWarnings({"unchecked", "rawtypes"})

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        // Set parent properties

        super.loadFromState(state);

        this.fields = state.getStringArray(FIELD_NAMES);

        this.labels = state.getStringArray(FIELD_LABEL_NAMES);

        this.colors = (Color[]) state.getArray(FIELD_LABEL_COLOR, Color.class);

        // Set own properties

        this.backgroundSymbol = (ISymbol) state.get("backgroundSymbol");

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

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

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

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

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

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

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

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

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

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

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

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

        this.symbol = (IChartSymbol) state.get("symbol");

        this.featSelection = (FeatureSelection) state.get("featSelection");

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

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

        this.minFeature = state.getDouble("minFeature");

        this.maxFeature = state.getDouble("maxFeature");

        this.maxField = state.getDouble("maxField");

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent properties

        super.saveToState(state);

        // Save own properties

        state.set(FIELD_NAMES, this.fields);

        state.set(FIELD_LABEL_NAMES, this.labels);

        state.set(FIELD_LABEL_COLOR, this.colors);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager.addDefinition(

                        BarsChartLegend.class,

                        BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME,

                        BARS_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

                        null,

                        null

                );

                // Extend the Classified Vector Legend base definition

                definition.extend(manager.getDefinition(VECTORIAL_UNIQUE_VALUE_LEGEND_PERSISTENCE_DEFINITION_NAME));

                // Field names

                definition.addDynFieldArray(FIELD_NAMES)

                        .setClassOfItems(String.class);

                definition.addDynFieldArray(FIELD_LABEL_NAMES)

                        .setClassOfItems(String.class);

                definition.addDynFieldArray(FIELD_LABEL_COLOR)

                        .setClassOfItems(Color.class);

                definition.addDynField("backgroundSymbol").setClassOfValue(ISymbol.class);

                definition.addDynFieldInt("size");

                definition.addDynFieldBoolean("is3D");

                definition.addDynFieldBoolean("isOutlineShow");

                definition.addDynFieldBoolean("onlySelection");

                definition.addDynFieldBoolean("isActiveLimits");

                definition.addDynFieldInt("outlineWidth");

                definition.addDynFieldInt("referenceSystem");

                definition.addDynFieldInt("sizeFrom");

                definition.addDynFieldInt("sizeTo");

                definition.addDynFieldInt("unit");

                definition.addDynFieldInt("sizeOption");

                definition.addDynFieldObject("outlineColor").setClassOfValue(Color.class);

                definition.addDynFieldObject("symbol").setClassOfValue(IChartSymbol.class);

                definition.addDynFieldObject("featSelection").setClassOfValue(FeatureSelection.class);

                definition.addDynFieldString("fieldSize");

                definition.addDynFieldString("fieldNormalize");

                definition.addDynFieldDouble("minFeature");

                definition.addDynFieldDouble("maxFeature");

                definition.addDynFieldDouble("maxField");

            }

            return Boolean.TRUE;

        }

    }

    protected void updateSymbols() {

        ISymbol[] symbols = getSymbols();

        for (ISymbol symbol1 : symbols) {

            delSymbol(getSymbolKey(symbol1));

        }

        if (fields != null && colors != null && labels != null) {

            if (fields.length != colors.length) {

                LOGGER.warn("The length of fields and colors isn't the same: fields.length = " + fields.length

                        + " colors.length = " + colors.length);

            }

            if (fields.length != labels.length) {

                LOGGER.warn("The length of fields and labels isn't the same: fields.length = " + fields.length

                        + " labels.length = " + labels.length);

            }

            for (int i = 0; i < Math.min(fields.length, Math.min(labels.length, colors.length)); i++) {

                ISimpleFillSymbol symbol1 = SymbologyLocator.getSymbologyManager().createSimpleFillSymbol();

                symbol1.setColor(colors[i]);

                symbol1.setDescription(labels[i]);

                addSymbol(fields[i], symbol1);

            }

        }

    }

}