Application: gvSIG desktop » gvSIG legends: base legends

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 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., 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.legend.picturemarkersymboltable.lib.api;

import org.gvsig.tools.locator.AbstractLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

public class PictureMarkerSymbolTableLocator extends AbstractLocator {

    /**

     * HeatmapLegend locator name

     */

    private static final String LOCATOR_NAME = "PictureMarkerSymbolTableLocator";

    /**

     * HeatmapLegend manager name

     */

    public static final String MANAGER_NAME = "PictureMarkerSymbolTableManager";

    /**

     * HeatmapLegend manager description

     */

    private static final String MANAGER_DESCRIPTION =

        "PictureMarkerSymbolTable Manager of gvSIG";

    /**

     * Unique instance

     */

    private static final PictureMarkerSymbolTableLocator instance = new PictureMarkerSymbolTableLocator();

    @Override

    public String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Registers the Class implementing the UrbanHorizontalSignageManager interface.

     *

     * @param clazz

     *            implementing the UrbanHorizontalSignageManager interface

     */

    public static void registerPictureMarkerSymbolTableManager(Class clazz){

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    public static void registerDefaultPictureMarkerSymbolTableManager(Class clazz){

        getInstance().registerDefault(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    public static PictureMarkerSymbolTableManager getPictureMarkerSymbolTableManager() throws LocatorException {

        return (PictureMarkerSymbolTableManager) getInstance().get(MANAGER_NAME);

    }

    /**

     * @return

     */

    public static Locator getInstance() {

        return instance;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 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., 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.legend.picturemarkersymboltable.lib.api;

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendWriter;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

public class PictureMarkerSymbolTableLibrary extends AbstractLibrary {

    @Override

    protected void doInitialize() throws LibraryException {

        registerAsAPI(PictureMarkerSymbolTableLibrary.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        // Validate there is any implementation registered.

        PictureMarkerSymbolTableManager manager = PictureMarkerSymbolTableLocator.getPictureMarkerSymbolTableManager();

        if (manager == null) {

            throw new ReferenceNotRegisteredException(

                PictureMarkerSymbolTableLocator.MANAGER_NAME, PictureMarkerSymbolTableLocator.getInstance());

        }

        SymbologyManager symbolManager = SymbologyLocator.getSymbologyManager();

        ILegendWriter legendWriter = symbolManager.getDefaultLegendWriter();

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.legend.picturemarkersymboltable.lib.api;

public interface PictureMarkerSymbolTableManager {

    public PictureMarkerSymbolTableLegend createPictureMarkerSymbolTableLegend();

    public Class<? extends PictureMarkerSymbolTableLegend> getPictureMarkerSymbolTableLegendClass();

}

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

import java.awt.Color;

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

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

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

public interface PictureMarkerSymbolTableLegend 

        extends IVectorLegend, IClassifiedLegend

    {

    public static final int DEFAULT_IMAGE_SIZE = 15;

    public double getImageSize();

    public int getUnits();

    public boolean isDrawLineToOffset();

    public Color getDefaultLineToOffsetColor();

    public String getClassifyingFieldName();

    public String getOffsetXFieldName();

    public String getOffsetYFieldName();

    public String getRotationFieldName();

    public String getLineToOffsetColorFieldName();

    public String getImagesTableName();

    public String getImageFieldName();

    public String getImageSelectedFieldName();

    public String getImagesTableClassifyingFieldName();

    public double getScale();

    public void setImageSize(double size);

    public void setUnits(int unit);

    public void setDefaultLineToOffsetColor(Color color);

    public void setDrawLineToOffset(boolean drawLineToOffset);

    public void setLineToOffsetColorFieldName(String fieldName);

    public void setOffsetXFieldName(String fieldName);

    public void setOffsetYFieldName(String fieldName);

    public void setRotationFieldName(String fieldName);

    public void setClassifyingFieldName(String classifyingFieldName);

    public void setImagesTableName(String imagesTableName);

    public void setImageFieldName(String imageFieldName);

    public void setImageSelectedFieldName(String imageSelectedFieldName);

    public void setImagesTableClassifyingFieldName(String imagesTableClassifyingFieldName);

    public void setScale(double scale);

    public void setReverseDirectionOfAngle(boolean reverse);

    public boolean isReverseDirectionOfAngle();

}

org.gvsig.legend.picturemarkersymboltable.lib.api.PictureMarkerSymbolTableLibrary

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.picturemarkersymboltable.lib.api</artifactId>

  <name>org.gvsig.legend.picturemarkersymboltable.lib.api</name>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.legend.picturemarkersymboltable.lib</artifactId>

    <version>1.0.45</version>

  </parent>

  <build>

    <plugins>

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-jar-plugin</artifactId>

        <configuration>

        </configuration>

        <executions>

          <!-- Generates a jar file only with the test classes -->

          <execution>

            <goals>

              <goal>test-jar</goal>

            </goals>

          </execution>

        </executions>

      </plugin>

    </plugins>

  </build>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.mapcontext.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.symbology.lib.api</artifactId>

    </dependency>

  </dependencies>

</project>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.legend.picturemarkersymboltable</artifactId>

    <version>1.0.45</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.legend.picturemarkersymboltable.lib</artifactId>

  <packaging>pom</packaging>

  <modules>

    <module>org.gvsig.legend.picturemarkersymboltable.lib.api</module>

    <module>org.gvsig.legend.picturemarkersymboltable.lib.impl</module>

  </modules>

</project>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.legend.picturemarkersymboltable.lib.impl</artifactId>

    <name>org.gvsig.legend.picturemarkersymboltable.lib.impl</name>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.legend.picturemarkersymboltable.lib</artifactId>

        <version>1.0.45</version>

    </parent>

    <groupId>org.gvsig</groupId>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.legend.picturemarkersymboltable.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.symbology.lib.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.ui</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

<!--

            <artifactId>${org.gvsig.h2spatial.provider}</artifactId>

-->

            <artifactId>org.gvsig.h2spatial.h2gis132.provider</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.fmap.geometry.impl}</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.geometry.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.proj.lib.impl}</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.se</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.impl</artifactId>

            <scope>test</scope>

        </dependency>      

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.timesupport.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.csv</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.util.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.db.jdbc</artifactId>

            <scope>compile</scope>

        </dependency>

    </dependencies>

</project>

<?xml version="1.0"?>

<definitions>

    <version>1.0.0</version>

    <classes>

        <class name="DefaultPictureMarkerSymbolTableLegend">

            <extends>

                <class name="VectorialLegend" namespace="persistence"/>

            </extends>

            <fields>

                <field name="scale" type="Double" defaultValue="1" mandatory="false">

                    <description></description>

                </field>

                <field name="size" type="Double" defaultValue="15" mandatory="false">

                    <description></description>

                </field>

                <field name="units" type="Integer" defaultValue="-1" mandatory="false">

                    <description></description>

                </field>

                <field name="lineToOffsetColor" type="Object" ClassOfValue="java.awt.Color" defaultValue="darkgrey" mandatory="false">

                    <description></description>

                </field>

                <field name="drawLineToOffset" type="Boolean" defaultValue="true" mandatory="false">

                    <description></description>

                </field>

                <field name="reverseDirectionOfAngle" type="Boolean" defaultValue="false" mandatory="false">

                    <description></description>

                </field>

                <field name="classifyingFieldName" type="String" defaultValue="" mandatory="true">

                    <description></description>

                </field>

                <field name="offsetXFieldName" type="String" defaultValue="" mandatory="false">

                    <description></description>

                </field>

                <field name="offsetYFieldName" type="String" defaultValue="" mandatory="false">

                    <description></description>

                </field>

                <field name="rotationFieldName" type="String" defaultValue="" mandatory="false">

                    <description></description>

                </field>

                <field name="lineToOffsetColorFieldlName" type="String" defaultValue="" mandatory="false">

                    <description></description>

                </field>

                <field name="imagesTableName" type="String" defaultValue="" mandatory="true">

                    <description></description>

                </field>

                <field name="imagesTableClassifyingFieldName" type="String" defaultValue="" mandatory="true">

                    <description></description>

                </field>

                <field name="imageFieldName" type="String" defaultValue="" mandatory="true">

                    <description></description>

                </field>

                <field name="imageSelectedFieldName" type="String" defaultValue="" mandatory="false">

                    <description></description>

                </field>

            </fields>

        </class>

    </classes>

</definitions>

org.gvsig.legend.picturemarkersymboltable.lib.impl.PictureMarkerSymbolTableLibraryImpl

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 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., 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.legend.picturemarkersymboltable.lib.impl;

import java.io.InputStream;

import java.util.Map;

import org.gvsig.fmap.mapcontext.MapContextLibrary;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

import org.gvsig.symbology.impl.SymbologyDefaultImplLibrary;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.persistence.PersistenceManager;

public class PictureMarkerSymbolTableLibraryImpl extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(PictureMarkerSymbolTableLibrary.class);

        this.require(MapContextLibrary.class);

        this.require(SymbologyDefaultImplLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        PictureMarkerSymbolTableLocator.registerPictureMarkerSymbolTableManager(DefaultPictureMarkerSymbolTableManager.class);

        MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

        mapContextManager.registerLegend("PictureMarkerSymbolTableLegend", DefaultPictureMarkerSymbolTableLegend.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        InputStream is = this.getClass().getResourceAsStream("PictureMarkerSymbolTablePersistence.xml");

        Map<String,DynStruct> definitions;

        try {

            definitions = ToolsLocator.getDynObjectManager().importDynClassDefinitions(is, this.getClass().getClassLoader());

        } catch (Exception ex) {

            throw new LibraryException(this.getClass(), ex);

        }

        persistenceManager.addDefinition(

                DefaultPictureMarkerSymbolTableLegend.class,

                "DefaultPictureMarkerSymbolTableLegend",

                definitions,

                null,

                null

        );

    }

}

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

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

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.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.AbstractLineSymbol;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.impl.AbstractMarkerSymbol;

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

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class ImageMarkerSymbol extends AbstractMarkerSymbol implements  IMarkerSymbol, IMultiLayerSymbol, TransparencySupport {

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

    private ImageMarkerSymbol selectionSym;

    private boolean selected;

    private BufferedImage image;

    private BufferedImage imagesel;

    private ISymbol[] layers;

    private static class ImageSymbol extends AbstractMarkerSymbol implements IMarkerSymbol {

        private final ImageMarkerSymbol parent;

        public ImageSymbol(ImageMarkerSymbol parent) {

            this.parent = parent;

        }

        @Override

        public ISymbol getSymbolForSelection() {

            return ((ImageMarkerSymbol)(this.parent.getSymbolForSelection())).getLayer(1);

        }

        @Override

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

            Point p;

            if(r != null){

                GeometryManager geometryManager = GeometryLocator.getGeometryManager();

                try {

                    p = (Point) geometryManager.createPoint(r.getCenterX(), r.getCenterY(), Geometry.SUBTYPES.GEOM2D);

                } catch (CreateGeometryException ex) {

                    return;

                }

            } else {

                try {

                    p = geom.centroid();

                } catch (Exception ex) {

                    return;

                }

                try {

                    if( geom.getType()==Geometry.TYPES.LINE ) {

                        // Si es una linea, intenta coger un punto aproximadamente 

                        // sobre el centro de la linea.

                        p = (Point) geom.closestPoints(p)[0];

                    } else if( geom.getType()==Geometry.TYPES.MULTILINE && ((Aggregate)geom).getPrimitivesNumber()==1 ) {

                        // Si es una multilinea compuesta por solo una linea, intenta

                        // coger un punto aproximadamene sobre el centro de esa linea

                        p = (Point) ((Aggregate)geom).getPrimitiveAt(0).closestPoints(p)[0];

                    }

                } catch(Throwable th) {

                    // Do nothing, ignore error and use centroid

                    LOGGER.debug("Problems calculating the center of geometry",th);

                }

                if (affineTransform != null) {

                    p.transform(affineTransform);

                }

            }

            double x, y;

            int size = (int) Math.round(this.parent.getEfectiveSize(f));

            double halfSize = this.parent.getEfectiveSize(f) / 2;

            x = p.getX() - halfSize;

            y = p.getY() - halfSize;

            Point2D theOffset = this.parent.getEfectiveOffset(f);

            int xOffset = (int) theOffset.getX();

            int yOffset = (int) theOffset.getY();

            if (size > 0) {

                Rectangle rect = new Rectangle(size, size);

                g.translate(x + xOffset, y + yOffset);

                double auxRotation = this.parent.getEfectiveRotationInRadians(f);

                g.rotate(auxRotation, halfSize, halfSize);

                this.parent.drawInsideRectangle(g, rect, true);

                g.rotate(-auxRotation, halfSize, halfSize);

                g.translate(-(x + xOffset), -(y + yOffset));

            }

        }

        @Override

        public void setCartographicContext(CartographicContext ctx) {

            super.setCartographicContext(ctx);

            this.parent.setCartographicContext(ctx);

        }

        @Override

        public int getUnit() {

            return this.parent.getUnit();

        }

    }

    private static class LineSymbol extends AbstractLineSymbol implements ILineSymbol {

        private final ImageMarkerSymbol parent;

        public LineSymbol(ImageMarkerSymbol parent) {

            this.parent = parent;

        }

        @Override

        public ISymbol getSymbolForSelection() {

            return ((ImageMarkerSymbol)(this.parent.getSymbolForSelection())).getLayer(0);

        }

        @Override

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

            Point p;

            try {

                p = geom.centroid();

            } catch (Exception ex) {

                return;

            }

            if (affineTransform != null) {

                p.transform(affineTransform);

            }

            int size = (int) Math.round(this.parent.getEfectiveSize(f));

            Point2D theOffset = this.parent.getEfectiveOffset(f);

            int xOffset = (int) theOffset.getX();

            int yOffset = (int) theOffset.getY();

            if (size > 0) {

                if (this.parent.isDrawLineToOffset()) {

                    g.setColor(this.parent.getEfectiveLineToOffsetColor(f));

                    g.drawLine((int) p.getX(), (int) p.getY(), (int) p.getX() + xOffset, (int) p.getY() + yOffset);

                }

            }

        }

        @Override

        public void setLineWidth(double d) {

        }

        @Override

        public double getLineWidth() {

            return 1;

        }

        @Override

        public void setCartographicContext(CartographicContext ctx) {

            super.setCartographicContext(ctx);

            this.parent.setCartographicContext(ctx);

        }

        @Override

        public int getUnit() {

            return this.parent.getUnit();

        }

    }

    public ImageMarkerSymbol() {

        this.layers = new ISymbol[] {new LineSymbol(this), new ImageSymbol(this)};

    }

    void setImage(BufferedImage img) {

        this.image = img;

    }

    void setImageSel(BufferedImage img) {

        this.imagesel = img;

    }

    @Override

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

        for (int i = 0; (cancel == null || !cancel.isCanceled())

                && layers != null && i < layers.length; i++) {

            ISymbol layer = layers[i];

            if (layer == null) {

                continue;

            }

            if(layer instanceof CartographicSupport){

                ((CartographicSupport)layer).setCartographicContext(this.getCartographicContext());

            }

            if(layer instanceof ISymbol_v2){

                ((ISymbol_v2)layer).draw(g, affineTransform, geom, f, cancel, r);

            } else {

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

            }

        }

    }

    private void drawInsideRectangle(Graphics2D g, Rectangle r, boolean keepAspectRatio) {

        BufferedImage theImage = (!selected) ? this.image : this.imagesel;

        if (theImage != null) {

            double xOffset = 0;

            double yOffset = 0;

            @SuppressWarnings("UnusedAssignment")

            double xScale = 1;

            @SuppressWarnings("UnusedAssignment")

            double yScale = 1;

            if (keepAspectRatio) {

                double scale;

                if (theImage.getWidth() > theImage.getHeight()) {

                    scale = r.getWidth() / theImage.getWidth();

                    yOffset = 0.5 * (r.getHeight() - theImage.getHeight() * scale);

                } else {

                    scale = r.getHeight() / theImage.getHeight();

                    xOffset = 0.5 * (r.getWidth() - theImage.getWidth() * scale);

                }

                xScale = yScale = scale;

            } else {

                xScale = r.getWidth() / theImage.getWidth();

                yScale = r.getHeight() / theImage.getHeight();

                yOffset = theImage.getHeight() * 0.5 * yScale;

            }

            AffineTransform at = AffineTransform.getTranslateInstance(xOffset, yOffset);

            at.concatenate(AffineTransform.getScaleInstance(xScale, yScale));

            g.drawRenderedImage(theImage, at);

        }

    }

    @Override

    public ISymbol getSymbolForSelection() {

        if (selectionSym == null) {

            try {

                selectionSym = (ImageMarkerSymbol) this.clone();

            } catch (CloneNotSupportedException e) {

//                LOG.warn("Error creating the selection symbol for the symbol "+ this, e);

            }

            selectionSym.selected = true;

            selectionSym.selectionSym = selectionSym; // avoid too much lazy creations

        } else {

            selectionSym.setColor(MapContext.getSelectionColor());

        }

        return selectionSym;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

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

        copy.layers = new ISymbol[] {new LineSymbol(copy), new ImageSymbol(copy)};

        return copy;

    }

    @Override

    public void setTransparency(double d) {

    }

    @Override

    public double getTransparency() {

        return 0;

    }

    @Override

    public void setLayer(int i, ISymbol is) throws IndexOutOfBoundsException {

    }

    @Override

    public void swapLayers(int i, int i1) {

    }

    @Override

    public ISymbol getLayer(int i) {

        return getLayers()[i];

    }

    @Override

    public int getLayerCount() {

        return 2;

    }

    @Override

    public void addLayer(ISymbol is) {

    }

    @Override

    public void addLayer(ISymbol is, int i) throws IndexOutOfBoundsException {

    }

    @Override

    public boolean removeLayer(ISymbol is) {

        return false;

    }

    public ISymbol[] getLayers() {

        return layers;

    }

    @Override

    public void setCartographicContext(CartographicContext ctx) {

        super.setCartographicContext(ctx);

//        ((CartographicSupport)this.layers[0]).setCartographicContext(ctx);

//        ((CartographicSupport)this.layers[1]).setCartographicContext(ctx);

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 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., 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.legend.picturemarkersymboltable.lib.impl;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultPictureMarkerSymbolTableManager implements PictureMarkerSymbolTableManager {

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

    @Override

    public PictureMarkerSymbolTableLegend createPictureMarkerSymbolTableLegend() {

        return new DefaultPictureMarkerSymbolTableLegend();

    }

    @Override

    public Class<? extends PictureMarkerSymbolTableLegend> getPictureMarkerSymbolTableLegendClass() {

        return DefaultPictureMarkerSymbolTableLegend.class;

    }

}

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;

    }