Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Paint;

import java.awt.Rectangle;

import java.awt.RenderingHints;

import java.awt.Shape;

import java.awt.TexturePaint;

import java.awt.geom.AffineTransform;

import java.awt.image.BufferedImage;

import java.util.Random;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

import org.gvsig.i18n.Messages;

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

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

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

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

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

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.swing.api.ToolsSwingLocator;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.util.Callable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Allows to define a marker symbol of any type as a path image to be used for a filled of a

 * polygon's padding

 *

 * @author   gvSIG Team

 */

public class MarkerFillSymbol extends AbstractFillSymbol implements IMarkerFillSymbol {

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

    public static final String MARK_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME =

        "MarkerFillSymbol";

    private static final String MARKER_SYMBOL = "markerSymbol";

    private static final String SELECTION_SYMBOL = "selectionSymbol";

    private static final String MARKER_FILL_PROPERTIES = "markerFillProperties";

    private static final String PREVIOUS_MARKERSIZE = "previousMarkerSize";

        public static final int RANDOM_FILL = 3;

        public static final int GRID_FILL = 1;

        public static final int SINGLE_CENTERED_SYMBOL = 2;

        public static int DefaultFillStyle = GRID_FILL;

        private MarkerFillSymbol selectionSymbol;

        private IMarkerFillPropertiesStyle markerFillProperties = new SimpleMarkerFillPropertiesStyle();

        private IMarkerSymbol markerSymbol = (IMarkerSymbol) MapContextLocator.getSymbolManager().createSymbol(IMarkerSymbol.SYMBOL_NAME);

    @Override

    public ISymbol getSymbolForSelection() {

        if (selectionSymbol == null) {

            selectionSymbol = (MarkerFillSymbol) cloneForSelection();

            selectionSymbol.setMarker((IMarkerSymbol) selectionSymbol.getMarker().getSymbolForSelection());

            selectionSymbol.setFillColor(MapContext.getSelectionColor());

        } else {

            selectionSymbol.setColor(MapContext.getSelectionColor());

        }

        if (selectionSymbol instanceof CartographicSupport) {

            ((CartographicSupport) selectionSymbol).setUnit(this.getUnit());

        }

        if (selectionSymbol.getMarker() instanceof CartographicSupport) {

            ((CartographicSupport) selectionSymbol.getMarker()).setUnit(this.getUnit());

        }

        return selectionSymbol;

    }

    @Override

    public void draw(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature f, Cancellable cancel, Rectangle rect) {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        Point centroid = null;

        Point p;

        if (this.markerSymbol instanceof CartographicSupport) {

            this.markerSymbol.setCartographicContext(this.getCartographicContext());

        }

        if (rect != null) {

            geom = getSampleGeometry(rect);

        }

        switch (markerFillProperties.getFillStyle()) {

            case SINGLE_CENTERED_SYMBOL:

                // case a single marker is used into a polygon shapetype

                //                        Geometry geom = FConverter.java2d_to_jts(geom);

                //                        com.vividsolutions.jts.geom.Point centroid = geom.getCentroid();

                try {

                    centroid = geom.centroid();

                } catch (Exception e2) {

                    logger.warn("Can't get centroid", e2);

                }

                /*

                                             * Hay ocasiones en que jts no puede calcular un centroide y devuelve NaN

                                             * (por ejemplo con geometr?as poligonales cuyos puntos tienen todos la misma

                                             * abscisa y distinta ordenada con tan solo una diferencia de 1 ? 2 unidades)

                                             * entonces, en lugar de utilizar este centroide tomamos el centro del

                                             * bounds del shp (la geometr?a es tan peque?a que consideramos que deben coincidir).

                 */

                p = null;

                if (centroid != null && !(Double.isNaN(centroid.getX()) || Double.isNaN(centroid.getY()))) {

                    double pX = centroid.getX() + markerFillProperties.getXOffset();

                    double pY = centroid.getY() + markerFillProperties.getYOffset();

                    try {

                        p = geometryManager.createPoint(pX, pY, SUBTYPES.GEOM2D);

                    } catch (CreateGeometryException e) {

                        logger.error("Can't create the point (" + pX + "," + pY + ")", e);

                    }

                    if (p != null) {

                        if (markerSymbol instanceof IMarkerSymbol_v2) {

                            ((IMarkerSymbol_v2) markerSymbol).draw(g, affineTransform, p, f, null, null);

                        } else {

                            markerSymbol.draw(g, affineTransform, p, f, null);

                        }

                    }

                } else {

                    //                Rectangle bounds = geom.getShape().getBounds();

                    //                double pX = bounds.getCenterX();

                    //                double pY = bounds.getCenterY();

                    Envelope env = geom.getEnvelope();

                    double pX = env.getCenter(Geometry.DIMENSIONS.X);

                    double pY = env.getCenter(Geometry.DIMENSIONS.Y);

                    try {

                        p = geometryManager.createPoint(pX, pY, SUBTYPES.GEOM2D);

                    } catch (CreateGeometryException e) {

                        logger.error("Can't create the point (" + pX + "," + pY + ")", e);

                    }

                    if (p != null) {

                        if (markerSymbol instanceof IMarkerSymbol_v2) {

                            ((IMarkerSymbol_v2) markerSymbol).draw(g, affineTransform, p, f, null, null);

                        } else {

                            markerSymbol.draw(g, affineTransform, p, f, null);

                        }

                    }

                }

                break;

            case GRID_FILL: { // case a grid fill is used

                Rectangle rClip = null;

                if (g.getClipBounds() != null) {

                    rClip = (Rectangle) g.getClipBounds().clone();

                    g.setClip(rClip.x, rClip.y, rClip.width, rClip.height);

                }

                g.clip(geom.getShape(affineTransform));

                int size = (int) this.toCartographicUnits(markerSymbol.getSize());

                Dimension maxSize = ToolsSwingLocator.getToolsSwingManager().getMaxPhysicalSizeOfBufferedImage();

                if (size > 0 && size <= maxSize.width && size <= maxSize.height) {

                    Rectangle rProv = new Rectangle();

                    rProv.setFrame(0, 0, size, size);

                    Paint resulPatternFill = null;

                    double xSeparation = this.toCartographicUnits(markerFillProperties.getXSeparation()); // TODO apply CartographicSupport

                    double ySeparation = this.toCartographicUnits(markerFillProperties.getYSeparation()); // TODO apply CartographicSupport

                    double xOffset = this.toCartographicUnits(markerFillProperties.getXOffset());

                    double yOffset = this.toCartographicUnits(markerFillProperties.getYOffset());

                    BufferedImage sample = null;

                    //                                    sample = ToolsSwingLocator.getToolsSwingManager().createBufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);

                    Graphics2D gAux = null;

                    if (size > 0) {

                        sample = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);

                        gAux = sample.createGraphics();

                        try {

                            markerSymbol.drawInsideRectangle(gAux, gAux.getTransform(), rProv);

                        } catch (SymbolDrawingException e) {

                            if (e.getType() == SymbolDrawingException.UNSUPPORTED_SET_OF_SETTINGS) {

                                try {

                                    IWarningSymbol warning

                                            = (IWarningSymbol) MapContextLocator.getSymbolManager()

                                                    .getWarningSymbol(

                                                            SymbolDrawingException.STR_UNSUPPORTED_SET_OF_SETTINGS,

                                                            "",

                                                            SymbolDrawingException.UNSUPPORTED_SET_OF_SETTINGS);

                                    warning.drawInsideRectangle(gAux, gAux.getTransform(), rProv);

                                } catch (SymbolDrawingException e1) {

                                    // IMPOSSIBLE TO REACH THIS

                                }

                            } else {

                                // should be unreachable code

                                throw new Error(Messages.getText("symbol_shapetype_mismatch"));

                            }

                        }

                        rProv.setRect(xOffset, yOffset,

                                rProv.getWidth() + xSeparation,

                                rProv.getHeight() + ySeparation);

                        BufferedImage bi = new BufferedImage(rProv.width, rProv.height, BufferedImage.TYPE_INT_ARGB);

                        gAux = bi.createGraphics();

                        gAux.drawImage(sample, null, 0 , 0 ); //(int) (xSeparation * 0.5), (int) (ySeparation * 0.5));

                        resulPatternFill = new TexturePaint(bi, rProv);

                        sample = null;

                        if (gAux != null) {

                            gAux.dispose();

                        }

                        g.setColor(null);

                        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

                                RenderingHints.VALUE_ANTIALIAS_ON);

                        g.setPaint(resulPatternFill);

                        g.fill(geom.getShape(affineTransform));

                        g.setClip(rClip);

                        bi = null;

                    }

                    break;

                }

            }

            case RANDOM_FILL: {

                double s = markerSymbol.getSize();

                Shape shp = geom.getShape(affineTransform);

                Rectangle r = shp.getBounds();

                int drawCount = (int) (Math.min(r.getWidth(), r.getHeight()) / s);

                Random random = new Random();

                int minx = r.x;

                int miny = r.y;

                int width = r.width;

                int height = r.height;

                r = new Rectangle();

                g.setClip(shp);

                for (int i = 0; (cancel == null || !cancel.isCanceled()) && i < drawCount; i++) {

                    int x = (int) Math.abs(random.nextDouble() * width);

                    int y = (int) Math.abs(random.nextDouble() * height);

                    x = x + minx;

                    y = y + miny;

                    //                                markerSymbol.draw(g, new AffineTransform(), new FPoint2D(x, y), cancel);

                    p = null;

                    try {

                        p = geometryManager.createPoint(x, y, SUBTYPES.GEOM2D);

                    } catch (CreateGeometryException e) {

                        logger.error("Can't create the point (" + x + "," + y + ")", e);

                    }

                    if (p != null) {

                        if (markerSymbol instanceof IMarkerSymbol_v2) {

                            ((IMarkerSymbol_v2) markerSymbol).draw(g, new AffineTransform(), p, f, cancel, null);

                        } else {

                            markerSymbol.draw(g, new AffineTransform(), p, f, cancel);

                        }

                    }

                }

                g.setClip(null);

                break;

            }

        }

        if (getOutline() != null) {

            getOutline().setCartographicContext(this.getCartographicContext());

            if (getOutline() instanceof ISymbol_v2) {

                ((ISymbol_v2) getOutline()).draw(g, affineTransform, geom, f, cancel, null);

            } else {

                getOutline().draw(g, affineTransform, geom, f, cancel);

            }

        }

    }

        @Override

        public int getSymbolType() {

                return Geometry.TYPES.SURFACE;

        }

        public String getClassName() {

                return getClass().getName();

        }

        @Override

        public void setMarker(IMarkerSymbol marker) {

                this.markerSymbol = marker;

        }

        @Override

        public IMarkerSymbol getMarker() {

                return markerSymbol;

        }

        /**

         * Sets the markerfillproperties to be used by the class

         *

         * @param markerFillStyle,IMarkerFillPropertiesStyle

         */

        @Override

        public void setMarkerFillProperties(IMarkerFillPropertiesStyle markerFillStyle) {

                this.markerFillProperties = markerFillStyle;

        }

        /**

         * Returns the markerfillproperties that are used by the class

         *

         * @return markerFillProperties,IMarkerFillPropertiesStyle

         */

        @Override

        public IMarkerFillPropertiesStyle getMarkerFillProperties() {

                return markerFillProperties;

        }

        @Override

        public void setUnit(int unitIndex) {

                super.setUnit(unitIndex);

                if (getMarker()!=null) {

                        getMarker().setUnit(unitIndex);

                }

        }

        @Override

        public void setReferenceSystem(int system) {

                super.setReferenceSystem(system);

                if (getMarker()!=null) {

                        getMarker().setReferenceSystem(system);

                }

        }

    @Override

    public void setCartographicContext(CartographicContext ctx) {

        super.setCartographicContext(ctx);

        IMarkerSymbol marker = getMarker();

        if (marker != null) {

            marker.setCartographicContext(ctx);

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

            MarkerFillSymbol copy = (MarkerFillSymbol) super.clone();

        // clone marker

        if (markerSymbol != null) {

            copy.markerSymbol = (IMarkerSymbol) markerSymbol.clone();

        }

        // clone selection

        if (selectionSymbol != null) {

            copy.selectionSymbol = (MarkerFillSymbol) selectionSymbol.clone();

        }

        // clone markerFillProperties

        if (markerFillProperties != null) {

            copy.markerFillProperties = (IMarkerFillPropertiesStyle) markerFillProperties.clone();

        }

        // FIXME: clone properties

        return copy;

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        // Set parent style properties

        super.loadFromState(state);

        this.markerSymbol =  (IMarkerSymbol) state.get(MARKER_SYMBOL);

        this.selectionSymbol = (MarkerFillSymbol) state.get(SELECTION_SYMBOL);

        this.markerFillProperties = (IMarkerFillPropertiesStyle) state.get(MARKER_FILL_PROPERTIES);

    }

        @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent fill symbol properties

        super.saveToState(state);

        // Save own properties

        state.set(MARKER_SYMBOL, this.markerSymbol);

        state.set(SELECTION_SYMBOL, this.selectionSymbol);

        state.set(MARKER_FILL_PROPERTIES, this.markerFillProperties);

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                DynStruct definition =

                    manager.addDefinition(MarkerFillSymbol.class,

                                    MARK_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME,

                                    MARK_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME

                            + " Persistence definition",

                        null,

                        null);

                // Extend the Style base definition

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

                definition.addDynFieldObject(MARKER_SYMBOL)

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

                definition.addDynFieldObject(SELECTION_SYMBOL)

                    .setClassOfValue(IMarkerFillSymbol.class).setMandatory(false);

                definition.addDynFieldObject(MARKER_FILL_PROPERTIES)

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

                definition.addDynFieldDouble(PREVIOUS_MARKERSIZE);

            }

            return Boolean.TRUE;

        }

    }

        public static class RegisterSymbol implements Callable {

                @Override

                public Object call() throws Exception {

                int[] shapeTypes;

                SymbolManager manager = MapContextLocator.getSymbolManager();

                shapeTypes =

                    new int[] { Geometry.TYPES.SURFACE, Geometry.TYPES.CIRCLE,

                        Geometry.TYPES.ELLIPSE, Geometry.TYPES.MULTISURFACE };

                manager.registerMultiLayerSymbol(IFillSymbol.SYMBOL_NAME,

                    shapeTypes,

                    MarkerFillSymbol.class);

                        return Boolean.TRUE;

                }

        }

}