Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.dynamiclegend;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

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

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.layers.vectorial.SpatialEvaluatorsFactory;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelingMethod;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.IPlacementConstraints;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.IZoomConstraints;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.AttrInTableLabelingStrategy;

import static org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.AttrInTableLabelingStrategy.MIN_TEXT_SIZE;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.AbstractCartographicSupport;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.CartographicSupportToolkit;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.impl.SimpleTextSymbol;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author osc

 */

public class DefaultDynamicLabelingStrategy extends AbstractCartographicSupport implements DynamicLabelingStrategy {

    private Feature feature;

    public String LROTATION = "LROTATION";

    public String LTEXT = "LTEXT";

    public String LHEIGHT = "LHEIGHT";

    public String LCOLOR = "LCOLOR";

    public String LFONT = "LFONT";

    public String LFONTSTYLE = "LFONTS";

    public static Expression expRotation = null;

    public static Expression expText = null;

    public static Expression expHeight = null;

    public static Expression expColor = null;

    public static Expression expFont = null;

    public static Expression expFontStyle = null;

    public static Expression expUnit;

    public static Expression expReferenceSystem;

    private MutableSymbolTable symbolTable = null;

    private FeatureSymbolTable featureSymbolTable = null;

    private FLyrVect layer;

    private List<Geometry> drawnGeometryLabels;

    private final boolean printMode = false;

    private final IZoomConstraints zoom = null;

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

    public SymbolTable getFeatureSymbolTable() {

        if (symbolTable == null) {

            MutableSymbolTable s = ExpressionEvaluatorLocator.getManager().createSymbolTable();

            featureSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

            s.addSymbolTable(featureSymbolTable);

            if (feature!=null) {

                featureSymbolTable.setFeature(feature);

            }

            symbolTable = s;

        }

        return symbolTable;

    }

//    private Expression getExpressionFromString(String value) {

//        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

//        expression.setPhrase(value);

//        return expression;

//    }

    private Object getValueFromExpression(Expression exp) {

        if (exp == null) {

            return null;

        }

        Object value = exp.execute(getFeatureSymbolTable());

        return value;

    }

    public Object getComputedValue(String field) {

        Object value;

        value = feature.get(field);

        return value;

    }

    @Override

    public Expression getRotation() {

        return expRotation;

    }

    @Override

    public int getComputedRotation() {

        Integer value = (Integer) getValueFromExpression(getRotation());

        return value;

    }

    @Override

    public Expression getText() {

        return expText;

    }

    @Override

    public String getComputedText() {

        String value = (String) getValueFromExpression(getText());

        return value;

    }

    @Override

    public Expression getHeight() {

        return expHeight;

    }

    @Override

    public int getComputedHeight() {

        int value = (int) getValueFromExpression(getHeight());

        return value;

    }

    @Override

    public Expression getColor() {

        return expColor;

    }

    @Override

    public Color getComputedColor() {

        int rgbcolor = (int) getColor().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public Expression getFixedSize() {

        return expHeight;

    }

    @Override

    public double getComputedFixedSize() {

        double value = (double) getValueFromExpression(getFixedSize());

        return value;

    }

    @Override

    public int getComputedUnit() {

        int value = (int) getValueFromExpression(getUnitExp());

        return value;

    }

    @Override

    public void setText(Expression expression) {

        expText = expression;

    }

    @Override

    public void setRotation(Expression expression) {

        expRotation = expression;

    }

    @Override

    public void setHeight(Expression expression) {

        expHeight = expression;

    }

    @Override

    public void setColor(Expression expression) {

        expColor = expression;

    }

    @Override

    public void setUsesFixedSize(boolean b) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public boolean usesFixedSize() {

        return false;

    }

    @Override

    public void setFixedSize(double fixedSize) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public void setUsesFixedColor(boolean b) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public boolean usesFixedColor() {

        return true;

    }

    @Override

    public Expression getFixedColor() {

        return expColor;

    }

    @Override

    public Color getComputedFixedColor() {

        int rgbcolor = (int) getFixedColor().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public void setFixedColor(Color fixedColor) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public Expression getColorFont() {

        return expColor;

    }

    @Override

    public Color getComputedColorFont() {

        int rgbcolor = (int) getColorFont().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public void setColorFont(Color colorFont) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public Expression getFont() {

        return expFont;

    }

    @Override

    public Font getComputedFont() {

        String value = (String) getFont().execute(getFeatureSymbolTable());

        Font font = new Font(value, getComputedFontStyle(), getComputedHeight());

        return font;

    }

    @Override

    public void setFont(Font selFont) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public Expression getFontStyle() {

        return expFontStyle;

    }

    @Override

    public int getComputedFontStyle() {

        int value = (int) getFontStyle().execute(getFeatureSymbolTable());

        return value;

    }

    @Override

    public void setFontStyle(Expression expression) {

        expFontStyle = expression;

    }

    @Override

    public void setFeature(Feature f) {

        feature = f;

        if (featureSymbolTable==null) {

            getFeatureSymbolTable();

        }

        featureSymbolTable.setFeature(f);

    }

    @Override

    public ILabelingMethod getLabelingMethod() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setLabelingMethod(ILabelingMethod method) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public IPlacementConstraints getPlacementConstraints() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setPlacementConstraints(IPlacementConstraints constraints) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public IZoomConstraints getZoomConstraints() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setZoomConstraints(IZoomConstraints constraints) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public Expression getUnitExp() {

        return expUnit;

    }

    public Expression getReferenceSystemExp() {

        return expReferenceSystem;

    }

    private org.gvsig.fmap.geom.primitive.Point createLabelPoint(org.gvsig.fmap.geom.Geometry geom)

            throws CreateGeometryException {

        try {

            return geom.centroid();

        } catch (Exception e) {

            return null;

        }

    }

    @Override

    public void draw(BufferedImage mapImage, Graphics2D mapGraphics, double scale, ViewPort viewPort, Cancellable cancel, double dpi) throws ReadException {

        PrintAttributes props = null;

        if (layer == null) {

            return;

        }

        if (zoom == null

                || (zoom.isUserDefined() && (scale >= zoom.getMaxScale())

                && (scale <= zoom.getMinScale()))) {

            FeatureSet set = null;

            DisposableIterator iterator = null;

            try {

                // limit the labeling to the visible extent

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

                FeatureStore featureStore = layer.getFeatureStore();

                ICoordTrans ct = layer.getCoordTrans();

                String geomName = featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName();

                //TODO

                fields.add(LCOLOR);

                fields.add(LFONT);

                fields.add(LFONTSTYLE);

                fields.add(LHEIGHT);

                fields.add(LROTATION);

                fields.add(LTEXT);

                fields.add(geomName);

                FeatureQuery featureQuery = layer.createFeatureQuery();

                if (viewPort.getAdjustedEnvelope().contains(

                        layer.getFullEnvelope())) {

                    /*

                     * viewport contains layer completely

                     */

                    set = featureStore.getFeatureSet(featureQuery);

                } else {

                    /*

                     * view port does not contain layer completely

                     */

                    Evaluator iee = null;

                    IProjection data_proj = null;

                    Envelope env_in_store_crs = null;

                    if (ct == null) {

                        env_in_store_crs = viewPort.getAdjustedEnvelope();

                        data_proj = viewPort.getProjection();

                    } else {

                        env_in_store_crs = viewPort.getAdjustedEnvelope().convert(

                                ct.getInverted());

                        data_proj = ct.getPOrig();

                    }

                    iee = SpatialEvaluatorsFactory.getInstance().intersects(

                            env_in_store_crs,

                            data_proj,

                            featureStore

                    );

                    featureQuery.setAttributeNames((String[]) fields.toArray(new String[fields.size()]));

                    featureQuery.setFilter(iee);

                    set = featureStore.getFeatureSet(featureQuery);

                }

                /*

                 * 'set' now has the features that have to be labeled

                 */

                FeatureSelection selection = this.layer.getFeatureStore().getFeatureSelection();

                iterator = set.fastIterator();

                while (iterator.hasNext()) {

                    if (cancel.isCanceled()) {

                        return;

                    }

                    try {

                        Feature feat = (Feature) iterator.next();

                        Geometry geom = feat.getDefaultGeometry();

                        if (geom == null) {

                            continue;

                        }

                        double size = 0;

                        Color color = null;

                        this.setFeature(feat);

                        if ("".equals(getComputedText())) {

                            continue;

                        } else if (getComputedText() == null) {

                            continue;

                        }

                        SimpleTextSymbol sym = new SimpleTextSymbol();

                        sym.setFont(getComputedFont());

                        sym.setUnit(getComputedUnit());

                        sym.setReferenceSystem(getComputedReferenceSystem());

                        if (this.usesFixedSize()) { //(useFixedSize) {

                            // uses fixed size

                            size = getComputedFixedSize();// * fontScaleFactor;

                        } else if (true) { //(getComputedHeight() ) {

                            // text size is defined in the table

                            size = getComputedHeight();

//                        } else {

//                            // otherwise will use the size in the symbol

//                            size = sym.getFont().getSize();

                        }

                        double the_dpi = viewPort.getDPI();

                        if (props != null) {

                            int len = PrintAttributes.PRINT_QUALITY_DPI.length;

                            int priq = props.getPrintQuality();

                            if (priq < 0 || priq >= len) {

                                throw new ReadException(featureStore.getName(),

                                        new Exception("Bad print quality value: " + priq));

                            } else {

                                the_dpi = PrintAttributes.PRINT_QUALITY_DPI[priq];

                            }

                        }

                        size = CartographicSupportToolkit.getCartographicLength(this,

                                size,

                                viewPort,

                                the_dpi);

                        if (size <= MIN_TEXT_SIZE) {

                            // label is too small to be readable, will be skipped

                            // this speeds up the rendering in wider zooms

                            continue;

                        }

                        /*

                         * ym.setFontSize(int) assumes dpi = 72

                         */

                        double font_size = size * 72 / the_dpi;

                        sym.setFontSize(font_size);

                        if (selection.isSelected(feat)) {

                            color = MapContext.getSelectionColor();

                        } else {

                            color = getComputedColorFont();

                        }

                        sym.setTextColor(color);

                        if (ct != null) {

                            /*

                             * Reproject from store CRS to view CRS

                             */

                            geom = geom.cloneGeometry();

                            geom.reProject(ct);

                        }

                        Point p = null;

                        // text rotation is defined in the table

                        double rotation = -Math.toRadians(((Number) getComputedRotation()).doubleValue());

                        p = createLabelPoint(geom);

                        sym.setText(getComputedText());

                        sym.setRotation(rotation);

                        if (p != null) {

                            if (props == null) {

                                sym.draw(mapGraphics, viewPort.getAffineTransform(), p, feat, cancel);

                            } else {

                                sym.print(mapGraphics, viewPort.getAffineTransform(), p, props);

                            }

                        }

                    } catch (Exception ex) {

                        logger.warn("", ex);

                    }

                }

            } catch (BaseException e) {

                throw new ReadException(

                        "Could not draw annotation in the layer.", e);

            } finally {

                if (iterator != null) {

                    iterator.dispose();

                }

                if (set != null) {

                    set.dispose();

                }

            }

        }

    }

    @Override

    public void print(Graphics2D g, double scale, ViewPort viewPort, Cancellable cancel, PrintAttributes properties) throws ReadException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public String[] getUsedFields() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setLayer(FLayer flayer) {

        layer = (FLyrVect) flayer;

    }

    @Override

    public boolean shouldDrawLabels(double scale) {

        return true;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setUnit(int unitIndex) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setUnit(Expression expression) {

        expUnit = expression;

    }

    @Override

    public int getUnit() {

        return getComputedUnitExp();

    }

    public int getComputedUnitExp() {

        int value = (int) getValueFromExpression(getUnitExp());

        return value;

    }

    public int getComputedReferenceSystem() {

        int value = (int) getValueFromExpression(getReferenceSystemExp());

        return value;

    }

    @Override

    public int getReferenceSystem() {

        return getComputedReferenceSystem();

    }

    @Override

    public void setReferenceSystem(int referenceSystem) {

//        this.referenceSystem = referenceSystem;

    }

    @Override

    public void setFont(Expression expression) {

        expFont = expression;

    }

    @Override

    public void setFontStyle(int style) {

    }

    @Override

    public void setReferenceSystem(Expression expression) {

        expReferenceSystem = expression;

    }

}