Application: gvSIG desktop » gvSIG legends: base legends

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

import java.awt.Color;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import javax.annotation.processing.SupportedSourceVersion;

import javax.lang.model.SourceVersion;

import org.apache.commons.collections4.map.LRUMap;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.StoresRepository;

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.mapcontext.MapContextException;

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

import org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLegend;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.persistence.PersistentState;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SupportedSourceVersion(SourceVersion.RELEASE_8)

@SuppressWarnings("UseSpecificCatch")

public class DefaultPictureMarkerSymbolTableLegend 

        extends AbstractVectorialLegend 

        implements PictureMarkerSymbolTableLegend 

{

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

    private static final int IMAGESCACHE_SIZE = 100;

    /** 

     * defaultSimbol no se usa para nada. 

     * Lo inicializamos en el constructor a SimpleMarkerSymbol por si a caso 

     * alguien lo consulta, por ejemplo al persistir el ImageMarkerSimbol.

     */

    transient private final ISimpleMarkerSymbol defaultSymbol;

    transient private final Coercion toColor;

    transient private FeatureStore imagesStore;

    transient private ExpressionBuilder expressionBuilder;

    transient private final LRUMap<Object, BufferedImage[]> imagesCache;

    private double size;

    private int units;

    private Color lineToOffsetColor;

    private boolean drawLineToOffset;

    private String classifyingFieldName;

    private String offsetXFieldName;

    private String offsetYFieldName;

    private String rotationFieldName;

    private String lineToOffsetColorFieldlName;

    private String imagesTableName;

    private String imagesTableClassifyingFieldName;

    private String imageFieldName;

    private String imageSelectedFieldName;

    private SimpleImage imageNotFound;

    private double scale;

    private boolean reverseDirectionOfAngle;

    private class MyZSort extends ZSort {

        public MyZSort() {

                super();

        }

        @Override

        public void legendChanged(LegendChangedEvent e) throws MapContextException {

//                symbols.clear();

//                usingZSort = false;

//                initialize(e.getNewLegend());

        }

        @Override

        public String getClassName() {

                return getClass().getName();

        }

        @Override

        public int getLevelCount() {

                return 2;

        }

        @Override

        public void setUsingZSort(boolean usingZSort) {

        }

        @Override

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

        }

        @Override

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

        }

        @Override

        public int[] getLevels(ISymbol sym) {

                return new int[]{0,1};

        }

        @Override

        public int[] getLevels(int row) {

                return null;

        }

        @Override

        public boolean isUsingZSort() {

                return true;

        }

        @Override

        public ISymbol[] getSymbols() {

                return null;

        }

        @Override

        public String[] getDescriptions() {

            return new String[] {"line", "Image"};

        }

        @Override

        public int getTopLevelIndexAllowed() {

                return 0;

        }

        @Override

        public String toString() {

            return "Line, Image";

        }

        @Override

        public boolean symbolChanged(SymbolLegendEvent e) {

                return true;

        }

        @Override

        public boolean classifiedSymbolChange(SymbolLegendEvent e) {

                return true;

        }

        @Override

        public boolean intervalChange(IntervalLegendEvent e) {

                return false;

        }

        @Override

        public boolean valueChange(ValueLegendEvent e) {

                return false;

        }

        // TODO should not exist here

        @Override

        public boolean labelFieldChange(LabelLegendEvent e) {

                return false;

        }

        @Override

        public void legendCleared(LegendClearEvent event) {

        }

    }

    public DefaultPictureMarkerSymbolTableLegend() {

        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

        this.scale = 1;

        this.defaultSymbol = symbologyManager.createSimpleMarkerSymbol();

        this.toColor = ToolsLocator.getDataTypesManager().getCoercion(DataTypes.COLOR);

        this.size = DEFAULT_IMAGE_SIZE;

        this.drawLineToOffset = true;

        this.lineToOffsetColor = Color.DARK_GRAY;

        this.imagesCache = new LRUMap<>(IMAGESCACHE_SIZE);

        this.reverseDirectionOfAngle = false;

        this.setZSort(new MyZSort());

    }

    @Override

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    @Override

    public void setDefaultSymbol(ISymbol is) {

        //DO NOTHING

    }

    private Color getColor(Feature feature, String attrname, Color defaultValue) {

        if( StringUtils.isBlank(attrname) ) {

            return defaultValue;

        }

        try {

            return (Color) toColor.coerce(feature.get(attrname));

        } catch(Exception ex) {

            return defaultValue;

        }

    }

    @Override

    public ISymbol getSymbolByFeature(Feature feature) throws MapContextException {

        ImageMarkerSymbol symbol = new ImageMarkerSymbol();

        Point2D.Double offset = new Point2D.Double(0,0);

        if( StringUtils.isNotBlank(this.offsetXFieldName)) {

            offset.x = feature.getDouble(this.offsetXFieldName)*this.scale;

        }

        if( StringUtils.isNotBlank(this.offsetYFieldName)) {

            offset.y = feature.getDouble(this.offsetYFieldName)*this.scale;

        }

        symbol.setOffset(offset);

        if( StringUtils.isNotBlank(this.rotationFieldName)) {

            if( this.isReverseDirectionOfAngle() ) {

                symbol.setRotation(360 - feature.getDouble(this.rotationFieldName));            

            } else {

                symbol.setRotation(feature.getDouble(this.rotationFieldName));

            }

        } else {

            symbol.setRotation(0);

        }

        if( drawLineToOffset && (offset.x!=0 || offset.y!=0))    {

            symbol.setDrawLineToOffset(true);

            symbol.setLineToOffsetColor(

                    getColor(

                            feature, 

                            this.lineToOffsetColorFieldlName, 

                            this.lineToOffsetColor

                    )

            );

        } else {

            symbol.setDrawLineToOffset(false);

            symbol.setLineToOffsetColor(Color.DARK_GRAY);

        }

        symbol.setSize(this.size*this.scale);

        symbol.setUnit(this.units);

        Object classifyingValue = feature.get(this.classifyingFieldName);

        BufferedImage[] images = this.getImages(classifyingValue);

        symbol.setImage(images[0]);

        symbol.setImageSel(images[1]);

        return symbol;

    }

    @Override

    public int getShapeType() {

        return Geometry.TYPES.POINT;

    }

    private BufferedImage[] getImages(Object classifyingValue) {

        BufferedImage[] images;

        images = this.imagesCache.get(classifyingValue);

        if( images!=null ) {

            return images;

        }

        images = new BufferedImage[] { null, null };        

        try {

            FeatureStore store = this.getImagesStore();

            FeatureType featureType = store.getDefaultFeatureTypeQuietly();

            FeatureAttributeDescriptor attr = featureType.getAttributeDescriptor(this.imagesTableClassifyingFieldName);

            Object value = attr.coerce(classifyingValue);

            ExpressionBuilder builder = this.getExpressionBuilder();

            String filter = builder.eq(

                    builder.column(this.imagesTableClassifyingFieldName),

                    builder.constant(value)

            ).toString();

            Feature f = store.findFirst(filter);

            if( f==null ) {

                SimpleImage image = getImageNotFound();

                images[0] = image.getBufferedImage();

                images[1] = images[0];

            } else {

                SimpleImage image = (SimpleImage) f.getFromProfile(this.imageFieldName);

                if( image != null ) {

                    images[0] = image.getBufferedImage();

                    images[1] = images[0];

                }

                image = (SimpleImage) f.getFromProfile(this.imageSelectedFieldName);

                if( image != null && !image.isEmpty() ) {

                    images[1] = image.getBufferedImage();

                }

            }

        } catch(Exception ex) {

            LOGGER.debug("Can't retrieve images from table '"+this.imagesTableName+"'", ex);

        }

        this.imagesCache.put(classifyingValue, images);

        return images;

    }

    private SimpleImage getImageNotFound() {

        if(this.imageNotFound == null){

            URL url = this.getClass().getResource("/images/picturemarkersymboltablelegend/image-not-found.png");

            this.imageNotFound = ToolsSwingLocator.getToolsSwingManager().createSimpleImage(url);

        }

        return this.imageNotFound;

    }

    private ExpressionBuilder getExpressionBuilder() {

        if( this.expressionBuilder == null ) {

            this.expressionBuilder = ExpressionUtils.createExpressionBuilder();

        }

        return this.expressionBuilder;

    }

    private FeatureStore getImagesStore() {

        if( this.imagesStore == null ) {

            StoresRepository repository = DALLocator.getDataManager().getStoresRepository();

            this.imagesStore = (FeatureStore) repository.getStore(this.imagesTableName);

        }

        return this.imagesStore;

    }

    @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 GeometryUtils.isSubtype(Geometry.TYPES.POINT, shapeType);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        this.scale = state.getDouble("scale",1.0);

        this.size = state.getDouble("size",DEFAULT_IMAGE_SIZE);

        this.units = state.getInt("units",-1);

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

        this.drawLineToOffset = state.getBoolean("drawLineToOffset",true);

        this.reverseDirectionOfAngle = state.getBoolean("reverseDirectionOfAngle",false);

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

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

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

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

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

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

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

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

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

        setZSort(new MyZSort());

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }

    @Override

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

        List<String> attributes = new ArrayList<>();

        if( StringUtils.isNotBlank(this.classifyingFieldName)) {

            attributes.add(this.classifyingFieldName);

        }

        if( StringUtils.isNotBlank(this.offsetXFieldName)) {

            attributes.add(this.offsetXFieldName);

        }

        if( StringUtils.isNotBlank(this.offsetYFieldName)) {

            attributes.add(this.offsetYFieldName);

        }

        if( StringUtils.isNotBlank(this.rotationFieldName)) {

            attributes.add(this.rotationFieldName);

        }

        if( StringUtils.isNotBlank(this.lineToOffsetColorFieldlName)) {

            attributes.add(this.lineToOffsetColorFieldlName);

        }

        attributes.add( fs.getDefaultFeatureType().getDefaultGeometryAttributeName() );

        return attributes.toArray(new String[attributes.size()]);

    }

    @Override

    public Color getDefaultLineToOffsetColor() {

        return this.lineToOffsetColor;

    }

    @Override

    public void setDefaultLineToOffsetColor(Color color) {

        this.lineToOffsetColor = color;

    }

    @Override

    public boolean isDrawLineToOffset() {

        return this.drawLineToOffset;

    }

    @Override

    public void setDrawLineToOffset(boolean drawLineToOffset) {

        this.drawLineToOffset = drawLineToOffset;

    }

    @Override

    public double getImageSize() {

        return this.size;

    }

    @Override

    public void setImageSize(double size) {

        this.size = size;

    }

    @Override

    public String getLineToOffsetColorFieldName() {

        return this.lineToOffsetColorFieldlName;

    }

    @Override

    public void setLineToOffsetColorFieldName(String fieldName) {

        this.lineToOffsetColorFieldlName = fieldName;

    }

    @Override

    public String getOffsetXFieldName() {

        return this.offsetXFieldName;

    }

    @Override

    public void setOffsetXFieldName(String fieldName) {

        this.offsetXFieldName = fieldName;

    }

    @Override

    public String getOffsetYFieldName() {

        return this.offsetYFieldName;

    }

    @Override

    public void setOffsetYFieldName(String fieldName) {

        this.offsetYFieldName = fieldName;

    }

    @Override

    public String getRotationFieldName() {

        return this.rotationFieldName;

    }

    @Override

    public void setRotationFieldName(String fieldName) {

        this.rotationFieldName = fieldName;

    }

    @Override

    public String getImagesTableName() {

        return imagesTableName;

    }

    @Override

    public void setImagesTableName(String imagesTableName) {

        this.imagesTableName = imagesTableName;

        this.imagesCache.clear();

    }

    @Override

    public String getImageFieldName() {

        return imageFieldName;

    }

    @Override

    public void setImageFieldName(String imageFieldName) {

        this.imageFieldName = imageFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String getClassifyingFieldName() {

        return classifyingFieldName;

    }

    @Override

    public void setClassifyingFieldName(String classifyingFieldName) {

        this.classifyingFieldName = classifyingFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String getImageSelectedFieldName() {

        return imageSelectedFieldName;

    }

    @Override

    public void setImageSelectedFieldName(String imageSelectedFieldName) {

        this.imageSelectedFieldName = imageSelectedFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String getImagesTableClassifyingFieldName() {

        return imagesTableClassifyingFieldName;

    }

    @Override

    public void setImagesTableClassifyingFieldName(String imagesTableClassifyingFieldName) {

        this.imagesTableClassifyingFieldName = imagesTableClassifyingFieldName;

        this.imagesCache.clear();

    }

    @Override

    public String[] getDescriptions() {

        return new String[] { this.imagesTableName + ", "+ this.classifyingFieldName};

    }

    @Override

    public ISymbol[] getSymbols() {

        return new ISymbol[] { this.defaultSymbol };

    }

    @Override

    public Object[] getValues() {

        return new Object[] { "" } ;

    }

    @Override

    public int getUnits() {

        return units;

    }

    @Override

    public void setUnits(int units) {

        this.units = units;

    }

    @Override

    public double getScale() {

        return scale;

    }

    @Override

    public void setScale(double scale) {

        this.scale = scale;

    }

    @Override

    public void setReverseDirectionOfAngle(boolean reverse) {

        this.reverseDirectionOfAngle = reverse;

    }

    @Override

    public boolean isReverseDirectionOfAngle() {

        return this.reverseDirectionOfAngle;

    }

}