Application: gvSIG desktop » gvSIG legends: base legends

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.rendering;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.i18n.Messages;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MarkerFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.MultiLayerFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

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

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.util.Callable;

/**

 * Implements a legend which represents the quantitative information

 * (numeric values). This representation is possible thanks to a symbol

 * whose size is different each time (depending on the numeric values

 * and if we want to use normalization or not).

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 * @author jldominguez

 */

public class ProportionalSymbolsLegend extends VectorialUniqueValueLegend  {

    private static Logger logger = LoggerFactory.getLogger(ProportionalSymbolsLegend.class);

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_NAME =

        "PROPORTIONAL_SYMBOL_LEGEND";

    public static final String

    PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME =

        "PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION";

        public void setClassifyingFieldNames(String[] fNames) {

                super.setClassifyingFieldNames(fNames);

                valueField = fNames[0];

                normalizationField = fNames[1];

        }

        private ISymbol backgroundSymbol;

        private String valueField;

        private String normalizationField;

        private double minSize;

        private double maxSize;

        private int templateShapeType;

        private boolean useNormalization;

        private double maxFeature, minFeature;

        private ZSort zSort = null;

        public ISymbol getSymbolByValue(Object key) {

                return null;

        }

        public ISymbol getSymbolByFeature(Feature feat) {

                ISymbol theSymbol = getDefaultSymbol();

                ISymbol auxSymbol;

                double value = 0;

                double normValue = 0;

                double size;

                double separation = maxSize-minSize;

                if (separation == 0) {

                        separation = 1;

                }

                try {

                        value = feat.getDouble(this.valueField);

                        if (useNormalization) {

                            normValue = feat.getDouble(this.normalizationField);

                            if (normValue == 0) {

                                size = (value >= 0) ?

                                    Double.POSITIVE_INFINITY :

                                    Double.NEGATIVE_INFINITY;

                            } else {

                        value = value / normValue;

                        size = minSize + (value * separation) ;

                            }

                        } else {

                                double difFeat = maxFeature - minFeature;

                                double step = difFeat/separation;

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

                        }

                } catch (Exception e) {

                        logger.info("Error while getting value in ProportionalSymbolsLegend.", e);

                        return null;

                }

                if (size == Double.NaN || size == Double.POSITIVE_INFINITY

                    || size == Double.NEGATIVE_INFINITY) {

            // logger.info("The symbol size is NaN or INFINITE.");

                        return null;

                }

                Geometry defgeom = feat.getDefaultGeometry();

                int def_geom_type = defgeom.getGeometryType().getType();

                if (isPolygonal(def_geom_type) && theSymbol instanceof IMarkerSymbol) {

                        MarkerFillSymbol aux = new MarkerFillSymbol();

                        ((IMarkerSymbol) theSymbol).setSize(size);

                        aux.setMarker((IMarkerSymbol) theSymbol);

                        SimpleMarkerFillPropertiesStyle p = new SimpleMarkerFillPropertiesStyle();

                        p.setFillStyle(SimpleMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

                        aux.setMarkerFillProperties(p);

                        theSymbol = aux;

                }

                else if (isLinear(def_geom_type)) {

                        ILineSymbol line = (ILineSymbol) theSymbol;

                        line.setLineWidth(size);

                        theSymbol = line;

                }

                else if (isPoint(def_geom_type)) {

                        IMarkerSymbol marker = (IMarkerSymbol) theSymbol;

                        marker.setSize(size);

                        theSymbol = marker;

                }

                if (backgroundSymbol != null) {

                        MultiLayerFillSymbol multi = new MultiLayerFillSymbol() ;

                        multi.addLayer(backgroundSymbol);

                        multi.addLayer(theSymbol);

                        return multi;

                }

                auxSymbol = theSymbol;

                return auxSymbol;

        }

    public static boolean isPolygonal(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, ty) || 

            geomManager.isSubtype(Geometry.TYPES.SURFACE, ty);

    }

    public static boolean isLinear(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTICURVE, ty) || 

            geomManager.isSubtype(Geometry.TYPES.CURVE, ty);

    }

    public static boolean isPoint(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTIPOINT, ty) || 

            geomManager.isSubtype(Geometry.TYPES.POINT, ty);

    }

        /**

         * Gets the background symbol which only can appear when the shapetype of the layer

         * is polygonal

         *

         * @return ISymbol the symbol for the background

         */

        public ISymbol getBackgroundSymbol() {return backgroundSymbol;}

        /**

         * Sets the background symbol which is used only when the shapetype of the layer is polygonal

         *

         * @param backgroundSymbol the symbol for the background

         */

        public void setBackgroundSymbol(ISymbol backgroundSymbol) {this.backgroundSymbol = backgroundSymbol;}

        /**

         * Obtains the classifying field name to be used to calculate the size of the symbol

         *

         * @return String  the name of the field

         * @throws ReadDriverException

         */

        public String getValueField() {

//                try {

//                        // TODO:

//                        // Por los alias, al guardar un proyecto no podemos

//                        // permitir que se guarde con campos que luego

//                        // no van a existir.

////                        int id = dataSource.getFieldIndexByName(valueField);

////                        valueField = dataSource.getFieldName(id);

//                } catch (ReadDriverException e) {

//                        e.printStackTrace();

//                        throw new RuntimeException(e);

//                }

                return valueField;

        }

        /**

         * Sets the classifying field name to be used to calculate the size of the symbol

         *

         * @param String  the name of the field

         */

        public void setValueField(String valueField) {this.valueField = valueField;}

        /**

         * Obtains the classifying field name to be used to calculate the size of the symbol when the

         * user is doing it with a normalization value.

         *

         * @return String  the name of the field

         */

        public String getNormalizationField() {

                return normalizationField;

        }

        /**

         * Sets the classifying field name to be used to calculate the size of the symbol when the

         * user is doing it with a normalization value.

         *

         * @param String  the name of the field

         */

        public void setNormalizationField(String normalizationField) {this.normalizationField = normalizationField;}

        /**

         * Obtains the minimum size for the symbol

         *

         * @return double  the minimum size for the symbol

         */

        public double getMinSize() {return minSize;}

        /**

         * Sets the minimum size for the symbol

         *

         * @param minSize  the minimum size for the symbol

         */

        public void setMinSize(double minSize) {this.minSize = minSize;}

        /**

         * Obtains the maximum size for the symbol

         *

         * @return double  the minimum size for the symbol

         */

        public double getMaxSize() {return maxSize;}

        /**

         * Sets the maximum size for the symbol

         *

         * @param maxSize  the minimum size for the symbol

         */

        public void setMaxSize(double maxSize) {this.maxSize = maxSize;}

        /**

         * Obtains the shapetype of the template symbol

         *

         * @return int shape type for the template symbol

         */

        public int getTemplateShapeType() {return templateShapeType;}

        /**

         * Sets the shapetype of the template symbol

         *

         * @param templateShapeType shape type for the template symbol

         */

        public void setTemplateShapeType(int tst) {

                if (isPolygonal(getShapeType())) {

                        if (isPoint(tst) || isPolygonal(tst)) {

                            this.templateShapeType = tst;

                        }

                } else {

                    if ((isPoint(tst) && isPoint(getShapeType()))

                        || (isLinear(tst) && isLinear(getShapeType()))) {

                        // || (getShapeType() == Geometry.TYPES.NULL)) {

                        this.templateShapeType = tst;

                    }

                }

        }

        /**

         * Obtains the boolean which is true if the user wants to calculate the size of the

         * symbol using a normalization field.

         *

         * @return boolean true if the user wants normalization.Otherwise, false.

         */

        public boolean getUseNormalization() {return useNormalization;}

        /**

         * Sets the boolean which is true if the user wants to calculate the size of the

         * symbol using a normalization field.

         *

         * @param useNormalization true if the user wants normalization.Otherwise, false.

         */

        public void setUseNormalization(boolean useNormalization) {this.useNormalization = useNormalization;}

        /**

         * Obtains the variable which represents the maximum value of the classifying field that is used

         * to calculate the size of the symbol

         *

         * @return double  the maximum value of the classifying field

         */

        public double getMaxFeature() {return maxFeature;}

        /**

         * Sets the variable which represents the maximum value of the classifying field that is used

         * to calculate the size of the symbol

         *

         * @param maxFeature

         */

        public void setMaxFeature(double maxFeature) {this.maxFeature = maxFeature;}

        /**

         * Obtains the variable which represents the minimum value of the classifying field that is used

         * to calculate the size of the symbol

         *

         * @return double  the minimum value of the classifying field

         */

        public double getMinFeature() {return minFeature;}

        /**

         * Sets the variable which represents the minimum value of the classifying field that is used

         * to calculate the size of the symbol

         *

         * @param minFeature

         */

        public void setMinFeature(double minFeature) {this.minFeature = minFeature;}

        public ISymbol[] getSymbols() {

                ISymbol[] auxSymbols=super.getSymbols();

                if(backgroundSymbol != null){

                        ISymbol[] symbols=new ISymbol[auxSymbols.length+1];

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

                                symbols[i]=auxSymbols[i];

                        }

                        symbols[symbols.length-1]=backgroundSymbol;

                        return symbols;

                } else {

                        return auxSymbols;

                }

        }

        public ZSort getZSort() {

                if (zSort == null){

                        zSort = new MyZSort(this);

                }

                return zSort;

        }

        public void setZSort(ZSort zSort){

                return;

        }

        private class MyZSort extends ZSort {

                public MyZSort(ILegend legend) {

                        super(legend);

                }

                public void legendChanged(LegendChangedEvent e) {

                }

                public String getClassName() {

                        return getClass().getName();

                }

                public int getLevelCount() {

                        int levels = 0;

                        if (backgroundSymbol!=null){

                                if(backgroundSymbol instanceof IMultiLayerSymbol){

                                        levels += ((IMultiLayerSymbol)backgroundSymbol).getLayerCount();

                                } else {

                                        levels += 1;

                                }

                        }

                        ISymbol sym = getDefaultSymbol();

                        if(getDefaultSymbol() instanceof IMultiLayerSymbol){

                                levels += ((IMultiLayerSymbol)sym).getLayerCount();

                        } else {

                                levels += 1;

                        }

                        return levels+1;

                }

                public void setUsingZSort(boolean usingZSort) {

                }

                public void setLevels(ISymbol sym, int[] values) {

                }

                public void setLevels(int row, int[] values) {

                }

                public int[] getLevels(ISymbol sym) {

                        return getLevels(0);

                }

                public int[] getLevels(int row) {

                        int levelsCount = getLevelCount();

                        int[] levels = new int[levelsCount];

                        int bgLevels = 1;

                        if (backgroundSymbol!=null){

                                if(backgroundSymbol instanceof IMultiLayerSymbol){

                                        bgLevels = ((IMultiLayerSymbol)backgroundSymbol).getLayerCount();

                                }

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

                                        levels[i]=i;

                                }

                        }

                        ISymbol sym = getDefaultSymbol();

                        int frLevels = 1;

                        if(getDefaultSymbol() instanceof IMultiLayerSymbol){

                                frLevels = ((IMultiLayerSymbol)sym).getLayerCount();

                        }

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

                                levels[i+bgLevels]=i+bgLevels;

                        }

                        levels[frLevels+bgLevels]=frLevels+bgLevels;

                        return levels;

                }

                public boolean isUsingZSort() {

                        return backgroundSymbol!=null;

                }

                public ISymbol[] getSymbols() {

                        return getSymbols();

                }

                public String[] getDescriptions() {

                        return getDescriptions();

                }

                public int getTopLevelIndexAllowed() {

                        return getLevelCount();

                }

                @Override

                public String toString() {

                        String out = "ZSort for ProportionalSymbolLegend";

                        return out;

                }

                public boolean symbolChanged(SymbolLegendEvent e) {

                        return true;

                }

                public boolean classifiedSymbolChange(SymbolLegendEvent e) {

                        return true;

                }

                public boolean intervalChange(IntervalLegendEvent e) {

                        return false;

                }

                public boolean valueChange(ValueLegendEvent e) {

                        return false;

                }

                // TODO should not exist here

                public boolean labelFieldChange(LabelLegendEvent e) {

                        return false;

                }

                public void legendCleared(LegendClearEvent event) {

                }

        }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        int[] ft = state.getIntArray("fieldTypes");

        this.setClassifyingFieldTypes(ft);

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

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

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

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

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

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

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

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

        ISymbol sym = (ISymbol) state.get("defaultSymbol");

        this.setDefaultSymbol(sym);

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

        this.setBackgroundSymbol(sym);

        String[] fieldNames = new String[2];

        fieldNames[0]= valueField;

        if (normalizationField.compareTo(Messages.getText("none")) == 0) {

            fieldNames[1]= fieldNames[0];

        } else {

            fieldNames[1] = normalizationField;

        }

        setClassifyingFieldNames(fieldNames);

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        int[] ft = this.getClassifyingFieldTypes();

        state.set("fieldTypes", ft);

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

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

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

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

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

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

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

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

        state.set("defaultSymbol", this.getDefaultSymbol());

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

    }

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager

                .getDefinition(PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition =

                    manager

                        .addDefinition(

                            ProportionalSymbolsLegend.class,

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME,

                            PROPORTIONAL_SYMBOL_LEGEND_PERSISTENCE_DEFINITION_NAME

                                + " Persistence definition", null, null);

                definition.addDynFieldString("valueField").setMandatory(true);

                definition.addDynFieldString("normalizationField").setMandatory(true);

                definition.addDynFieldInt("templateShapeType").setMandatory(true);

                definition.addDynFieldArray("fieldTypes").setClassOfItems(Integer.class).setMandatory(true);

                definition.addDynFieldDouble("maxSize").setMandatory(true);

                definition.addDynFieldDouble("minSize").setMandatory(true);

                definition.addDynFieldDouble("maxFeature").setMandatory(true);

                definition.addDynFieldDouble("minFeature").setMandatory(true);

                definition.addDynFieldBoolean("useNormalization").setMandatory(true);

                definition.addDynFieldObject("defaultSymbol")

                .setClassOfValue(ISymbol.class).setMandatory(true);

                definition.addDynFieldObject("backgroundSymbol")

                .setClassOfValue(ISymbol.class).setMandatory(true);

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                PROPORTIONAL_SYMBOL_LEGEND_NAME,

                ProportionalSymbolsLegend.class);

            return Boolean.TRUE;

        }

    }

}