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

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.documents.table.TableDocument;

import org.gvsig.app.project.documents.table.TableManager;

import org.gvsig.chart.ChartLocator;

import org.gvsig.chart.ChartService;

import org.gvsig.chart.legend.IChartLegend;

import org.gvsig.chart.legend.ILinkedChartLegend;

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.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.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 static org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialUniqueValueLegend.VECTORIAL_UNIQUE_VALUE_LEGEND_PERSISTENCE_DEFINITION_NAME;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

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.persistence.impl.DelegatedList;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.util.Callable;

import org.jfree.chart.LegendItem;

@Deprecated

public final class LinkedChartLegend extends BasePieChartLegend implements ILinkedChartLegend {

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager = MapContextLocator.getMapContextManager();

            manager.registerLegend(IChartLegend.LINKED_LEGEND_NAME,

                    LinkedChartLegend.class);

            return Boolean.TRUE;

        }

    }

    public static final String LINKED_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME = "LinkedChartLegend";

    private static final String FIELD_NAMES = "FieldLegendNames";

    private static final String FIELD_LABEL_NAMES = "FieldLabelNames";

    private static final String FIELD_LABEL_COLOR = "FieldLabelColor";

    protected Map<String, List> indexHash;

    private String linkedField;

    private String groupedByField = "";

    private List<String> linkedFieldValues;

    private String[] linkedFieldTableNames;

    private String[] linkedFieldName;

    private String linkedTable;

    private boolean originSelected;

    private boolean destinationSelected;

    private String[] linkedFields;

    private String timeField;

    private String legendType;

    public LinkedChartLegend() {

        this.indexHash = new HashMap<>();

    }

    @Override

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

            Cancellable cancel, double scale, Map queryParameters,

            ICoordTrans coordTrans, FeatureStore featureStore,

            FeatureQuery featureQuery) throws LegendException {

        FeatureSelection fsel;

        try {

            this.featSelection = featureStore.getFeatureSelection();

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

        } catch (DataException e) {

            e.printStackTrace();

        }

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

                featureStore, featureQuery);

    }

    /**

     * Devuelve un array con los campos seleccionados a pintar de la capa

     * enlazada

     *

     * @return

     */

    public String[] getLinkedClassifyingFieldNames() {

        return getClassifyingFieldNames();

    }

    @Override

    public String[] getClassifyingFieldNames() {

        return this.linkedFieldName;

    }

    @Override

    public void setLinkedFieldName(String[] fieldName) {

        this.linkedFieldName = fieldName;

        updateSymbols();

    }

    @Override

    public void setDataHash(Map<String, List> hash) {

        this.indexHash = hash;

    }

    @Override

    public Set<String> getLinkedFieldValues() {

        return this.indexHash.keySet();

    }

    public void setLinkedFieldValues(List<String> values) {

        this.linkedFieldValues = values;

        updateSymbols();

    }

    @Override

    public Map<String, List> getLinkedData() {

        indexHash = new HashMap<>();

        ApplicationManager appManager = ApplicationLocator.getManager();

        final Project project = appManager.getCurrentProject();

        TableDocument selDoc = (TableDocument) project.getDocument(this.linkedTable,

                TableManager.TYPENAME);

        if (selDoc != null) {

            try {

                FeatureType featType = selDoc.getStore().getDefaultFeatureType();

                FeatureAttributeDescriptor[] atts = featType.getAttributeDescriptors();

                FeatureSelection fsel = selDoc.getStore().getFeatureSelection();

                FeatureSet fs = selDoc.getStore().getFeatureSet();

                DisposableIterator it = null;

                if (this.destinationSelected) {

                    it = fsel.fastIterator();

                } else {

                    it = fs.fastIterator();

                }

                while (it.hasNext()) {

                    Feature f = (Feature) it.next();

                    String key = f.getString(this.linkedField);

                    if (key != null) {

                        List<Map<String, Double>> array = indexHash.get(key);

                        if (array == null) {

                            array = new ArrayList<>();

                            indexHash.put(key, array);

                        }

                        if (array instanceof DelegatedList) {

                            List<Map<String, Double>> auxarray = new ArrayList<>();

                            for (int i = 0; i < array.size(); i++) {

                                auxarray.add(array.get(i));

                            }

                            array = auxarray;

                        }

                        Map<String, Double> elem = new HashMap<>();

                        for (String field : getLinkedFields()) {

                            if (!field.equalsIgnoreCase(key)) {

                                Double value = f.getDouble(field);

                                elem.put(field, value);

                            }

                        }

                        String xAxis = this.timeField;

                        if (StringUtils.isNotEmpty(xAxis)) {

                            Double value = f.getDouble(xAxis);

                            elem.put(xAxis, value);

                        }

                        array.add(elem);

                    }

                }

                it.dispose();

            } catch (DataException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        } else {

            throw new RuntimeException("No se encuentra la tabla "

                    + this.linkedTable);

        }

        return indexHash;

    }

    @Override

    public ISymbol getSymbolByFeature(Feature feat) throws MapContextException {

        if (this.onlySelection) {

            if (!featSelection.isSelected(feat)) {

                return null;

            }

        }

        String name = "";

        if (getClassifyingFieldNames() != null && getClassifyingFieldNames().length > 0) {

            name = feat.getString(getClassifyingFieldNames()[0]);

        } else {

            return null;

        }

        Set<String> indexes = getLinkedFieldValues();

        if (!indexes.contains(name)) {

            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 size = 0;

        ChartDataSet dataSet = ChartLocator.getServiceManager()

                .getChartManager().createChartDataSet();

        ChartService cs = symbol.getChart();

        if (StringUtils.equals(cs.getChartType(), "BarsChart")) {

            addBarsDataSetInfo(dataSet, name);

        } else {

            addPieDataSetInfo(dataSet, name);

        }

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

        String[] names = getFieldNames();

        if (names != null) {

            cs.setChartDataSet(dataSet);

            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;

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

                }

                symbol.setSize(size);

                break;

            case IChartSymbol.SIZEFIELD:

                if (separation == 0) {

                    separation = 1;

                }

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

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

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

                    if (normalize != 0) {

                        value = value / normalize;

                    }

                    if (isActiveLimits()) {

                        size = sizeFrom + (value * separation);

                    } else {

                        size = value;

                    }

                } else {

                    if (isActiveLimits()) {

                        double difFeat = maxFeature - minFeature;

                        double step = difFeat / separation;

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

                    } else {

                        size = value;

                    }

                }

                symbol.setSize(size);

                break;

            default:

                symbol.setSize(getSize());

                break;

        }

        return symbol;

    }

    private void addPieDataSetInfo(ChartDataSet dataSet, String name) {

        String[] names = getFieldNames();

        String[] _labels = getFieldLabels();

        if (names != null && _labels != null && _labels.length == names.length) {

            ArrayList serie = new ArrayList();

            ArrayList category = new ArrayList();

            ArrayList groupedBy = new ArrayList();

            Iterator it = indexHash.get(name).iterator();

            int ji = 1;

            while (it.hasNext()) {

                Map<String, Object> it_next = (Map<String, Object>) it.next();

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

                    if (getGroupedField() != null && getGroupedField() != "") {

                        groupedBy.add("" + it_next.get(getGroupedField()));

                    } else {

                        if (ji != 1 || (ji == 1 && it.hasNext())) {

                            groupedBy.add("" + ji);

                        } else {

                            groupedBy.add(" ");

                        }

                    }

                    double val = (Double) it_next.get(names[i]);

                    if (sizeOption == IChartSymbol.SIZESUM) {

                        size += val;

                    }

                    serie.add(_labels[i]);

                    category.add(val);

                }

                ji++;

            }

            dataSet.addData("groupby", groupedBy);

            dataSet.addData("series", serie);

            dataSet.addData("categories", category);

        }

    }

    private void addBarsDataSetInfo(ChartDataSet dataSet, String name) {

        String[] names = getFieldNames();

        if (names != null) {

            ArrayList serie = new ArrayList();

            ArrayList category = new ArrayList();

            ArrayList groupedBy = new ArrayList();

            Iterator it = indexHash.get(name).iterator();

            int ji = 1;

            while (it.hasNext()) {

                Map<String, Object> it_next = (Map<String, Object>) it.next();

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

                    if (getGroupedField() != null && getGroupedField() != "") {

                        serie.add("" + it_next.get(getGroupedField()));

                    } else {

                        serie.add("" + ji);

                    }

                    double val = (Double) it_next.get(names[i]);

                    if (sizeOption == IChartSymbol.SIZESUM) {

                        size += val;

                    }

                    groupedBy.add(names[i]);

                    category.add(val);

                }

                ji++;

            }

            dataSet.addData("groupby", groupedBy);

            dataSet.addData("series", serie);

            dataSet.addData("categories", category);

        }

    }

    @Override

    public String getLinkedField() {

        return this.linkedField;

    }

    @Override

    public void setLinkedField(String field) {

        this.linkedField = field;

    }

    @Override

    public String getTimeField() {

        return this.timeField;

    }

    @Override

    public void setTimeField(String field) {

        this.timeField = field;

    }

    @Override

    public String getLegendType() {

        return this.legendType;

    }

    @Override

    public void setLegendType(String field) {

        this.legendType = field;

    }

    @Override

    public void setGroupedField(String string) {

        this.groupedByField = string;

    }

    @Override

    public String getGroupedField() {

        return this.groupedByField;

    }

    @Override

    public String getLinkedTable() {

        return this.linkedTable;

    }

    @Override

    public boolean getLinkedSelected() {

        return this.destinationSelected;

    }

    @Override

    public String[] getOriginFieldName() {

        return linkedFieldName;

    }

    @Override

    public boolean getOriginSelected() {

        return this.originSelected;

    }

    @Override

    public void setLinkedTable(String selectedItem) {

        this.linkedTable = selectedItem;

        updateSymbols();

    }

    @Override

    public void setOriginSelected(boolean selected) {

        this.originSelected = selected;

    }

    @Override

    public void setLinkedSelected(boolean selected) {

        this.destinationSelected = selected;

    }

    @Override

    public void setLinkedFields(String[] fields) {

        this.linkedFields = fields;

        updateSymbols();

    }

    @Override

    public String[] getLinkedFields() {

        return linkedFields;

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        // Set parent properties

        super.loadFromState(state);

        this.linkedFields = state.getStringArray("linkedFields");

        this.linkedFieldName = state.getStringArray("linkedFieldName");

        this.linkedFieldTableNames = state.getStringArray("linkedFieldTableNames");

        // Set own properties

        this.linkedFieldValues = (List<String>) state.getList("linkedFieldValues");

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

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

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

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

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

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

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

        this.indexHash = state.getMap("indexHash");

        //getLinkedData();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent properties

        super.saveToState(state);

        // Save own properties

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

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

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

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

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

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

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

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

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

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

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

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

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                DynStruct definition = manager.addDefinition(

                        LinkedChartLegend.class,

                        LINKED_CHART_LEGEND_PERSISTENCE_DEFINITION_NAME,

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

                // Field names

                definition.addDynFieldArray("linkedFields")

                        .setClassOfItems(String.class);

                definition.addDynFieldArray("linkedFieldName")

                        .setClassOfItems(String.class);

                definition.addDynFieldArray("linkedFieldTableNames")

                        .setClassOfItems(String.class);

                definition.addDynFieldList("linkedFieldValues")

                        .setClassOfItems(String.class);

                definition.addDynFieldBoolean("originSelected");

                definition.addDynFieldBoolean("destinationSelected");

                definition.addDynFieldString("linkedTable");

                definition.addDynFieldString("linkedField");

                definition.addDynFieldString("groupedByField");

                definition.addDynFieldString("timeField");

                definition.addDynFieldMap("indexHash").setClassOfItems(List.class);

                definition.addDynFieldString("legendType");

            }

            return Boolean.TRUE;

        }

    }

}