Application: gvSIG desktop » gvSIG legends: base legends

<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</artifactId>

  <version>1.0.16</version>

  <packaging>pom</packaging>

  <name>${project.artifactId}</name>

  <description>Legend for urban horizontal signage.</description>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.desktop</artifactId>

    <version>2.0.401</version>

  </parent>

  <url>https://devel.gvsig.org/sites/org.gvsig.legend.picturemarkersymboltable/${project.version}</url>

  <scm>

    <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.picturemarkersymboltable/tags/org.gvsig.legend.picturemarkersymboltable-1.0.16</connection>

    <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.picturemarkersymboltable/tags/org.gvsig.legend.picturemarkersymboltable-1.0.16</developerConnection>

    <url>https://devel.gvsig.org/redmine/projects/gvsig-base-legends/repository/show/org.gvsig.legend.picturemarkersymboltable/tags/org.gvsig.legend.picturemarkersymboltable-1.0.16</url>

  </scm>

  <repositories>

    <repository>

      <id>gvsig-public-http-repository</id>

      <name>gvSIG maven public HTTP repository</name>

      <url>http://devel.gvsig.org/m2repo/j2se</url>

      <releases>

        <enabled>true</enabled>

        <updatePolicy>daily</updatePolicy>

        <checksumPolicy>warn</checksumPolicy>

      </releases>

      <snapshots>

        <enabled>true</enabled>

        <updatePolicy>daily</updatePolicy>

        <checksumPolicy>warn</checksumPolicy>

      </snapshots>

    </repository>

  </repositories>

  <distributionManagement>

    <site>

      <id>gvsig-repository</id>

      <url>dav:https://devel.gvsig.org/download/projects/gvsig-base-legends/pool/${project.artifactId}/${project.version}</url>

    </site>

  </distributionManagement>

  <build>

    <plugins>

      <plugin>

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

        <artifactId>maven-release-plugin</artifactId>

        <configuration>

          <tagBase>https://devel.gvsig.org/svn/gvsig-base-legends/org.gvsig.legend.picturemarkersymboltable/tags</tagBase>

        </configuration>

      </plugin>

    </plugins>

  </build>

  <dependencyManagement>

    <dependencies>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.16</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.16</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.16</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.16</version>

      </dependency>

      <dependency>

        <groupId>org.gvsig</groupId>

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

        <version>1.0.16</version>

      </dependency>

    </dependencies>

  </dependencyManagement>

  <modules>

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

    <module>org.gvsig.legend.picturemarkersymboltable.swing</module>

    <module>org.gvsig.legend.picturemarkersymboltable.app</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>

  <parent>

    <groupId>org.gvsig</groupId>

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

    <version>1.0.16</version>

  </parent>

  <groupId>org.gvsig</groupId>

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

  <packaging>pom</packaging>

  <name>org.gvsig.legend.picturemarkersymboltable.app</name>

  <modules>

    <module>org.gvsig.legend.picturemarkersymboltable.app.mainplugin</module>

  </modules>

</project>

#Sun Nov 20 22:57:39 CET 2022

buildNumber=18

<!-- 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. -->

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <include>org.gvsig:org.gvsig.legend.picturemarkersymboltable.lib.api</include>

        <include>org.gvsig:org.gvsig.legend.picturemarkersymboltable.lib.impl</include>

        <include>org.gvsig:org.gvsig.legend.picturemarkersymboltable.swing.api</include>

        <include>org.gvsig:org.gvsig.legend.picturemarkersymboltable.swing.impl</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

# ---------------------------------------

# Picture marker symbol table legend

#

_Picture_marker_symbol_table_legend=Valores \u00fanicos de marcador de imagen en tabla

_Legend_table_fields=Campos de la tabla de la leyenda

_Images_table_fields=Campos de la tabla de las imagenes

_Unit=Unidad

_Line_to_offset_color=Color de la linea al offset

_Draw_line_to_offset=Pinta la linea al offset

_Classifying_field=Campo para clasificar

_OffsetX_field=Campo para el offset X

_OffsetY_field=Campo para el offset Y

_Rotation_field=Campo para la rotaci\u00f3n

_Line_to_offset_color_field=Campo para el color de la linea al offset

_Table_name=Nombre de tabla

_Image_field=Campo de la imagen

_Image_selected_field=Campo de la imagen seleccionada

# ---------------------------------------

# Picture marker symbol table legend

#

_Picture_marker_symbol_table_legend=Picture marker unique values in table

_Legend_table_fields=Legend table fields

_Images_table_fields=Images table fields

_Unit=Unit

_Line_to_offset_color=Line to offset color

_Draw_line_to_offset=Draw line to offset

_Classifying_field=Classifying field

_OffsetX_field=OffsetX field

_OffsetY_field=OffsetY field

_Rotation_field=Rotation field

_Line_to_offset_color_field=Line to offset color field

_Table_name=Table name

_Image_field=Image field

_Image_selected_field=Image selected field

<?xml version="1.0" encoding="ISO-8859-1"?>

<!-- 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. -->

<plugin-config>

  <depends plugin-name="org.gvsig.app.mainplugin" />

  <resourceBundle name="text" />

  <libraries library-dir="lib" />

  <extensions>

      <extension class-name="org.gvsig.andami.LibraryExtension"

                 description="" active="true" priority="1">

      </extension>

  </extensions>

</plugin-config>

<?xml version="1.0"?>

<!--

Definitions of plugin persistence org.gvsig.legend.picturemarkersymboltable.app.mainplugin

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="org.gvsig.legend.picturemarkersymboltable.app.mainplugin">

      <extends>

      </extends>

      <description>Persistence of the legend of picture marker symbols in a table</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

<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.app</artifactId>

    <version>1.0.16</version>

  </parent>

  <groupId>org.gvsig</groupId>

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

  <version>1.0.16</version>

  <name>org.gvsig.legend.picturemarkersymboltable.app.mainplugin</name>

    <properties>

    <!-- Package info property values -->

    <gvsig.package.info.state>testing</gvsig.package.info.state>

    <gvsig.package.info.dependencies>required: org.gvsig.app.mainplugin -ge 2.6.0-A</gvsig.package.info.dependencies>

    <gvsig.package.info.official>true</gvsig.package.info.official>

    <gvsig.package.info.name>Vector legend: Picture marker symbols in a table</gvsig.package.info.name>

    <gvsig.package.info.description>Legend for work with picture marker symbols in a table.</gvsig.package.info.description>

    <gvsig.package.info.categories>View,Vector,Symbology</gvsig.package.info.categories>

    <gvsig.package.info.javaVM>j1_8</gvsig.package.info.javaVM>

    <gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-base-legends/pool</gvsig.package.info.poolURL>

  </properties>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.andami</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>compile</scope>

    </dependency>

    <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.legend.picturemarkersymboltable.lib.impl</artifactId>

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <scope>runtime</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.app.mainplugin</artifactId>

      <scope>compile</scope>

    </dependency>

  </dependencies>

</project>

/* 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, ISingleSymbolLegend 

    {

    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);

}

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.16</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.16</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>

/**

 * 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.primitive.Point;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

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

    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) {

            Point p;

            try {

                p = geom.centroid();

            } catch (Exception ex) {

                return;

            }

            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 double toCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

            return this.parent.toCartographicSize(viewPort, dpi, geom); //To change body of generated methods, choose Tools | Templates.

        }

        @Override

        public void setCartographicSize(double cartographicSize, Geometry geom) {

            this.parent.setCartographicSize(cartographicSize, geom); //To change body of generated methods, choose Tools | Templates.

        }

        @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) {

            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 double toCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

            return this.parent.toCartographicSize(viewPort, dpi, geom); //To change body of generated methods, choose Tools | Templates.

        }

        @Override

        public void setCartographicSize(double cartographicSize, Geometry geom) {

            this.parent.setCartographicSize(cartographicSize, geom); //To change body of generated methods, choose Tools | Templates.

        }

        @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) {

        Point p;

        try {

            p = geom.centroid();

        } catch (Exception ex) {

            return;

        }

        if (affineTransform != null) {

            p.transform(affineTransform);

        }

        double x, y;

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

        double halfSize = getEfectiveSize(f) / 2;

        x = p.getX() - halfSize;

        y = p.getY() - halfSize;

        Point2D theOffset = this.getEfectiveOffset(f);

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

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

        if (size > 0) {

            if( isDrawLineToOffset() ) {

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

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

            }

            Rectangle rect = new Rectangle(size, size);

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

            double auxRotation = getEfectiveRotationInRadians(f);

            g.rotate(auxRotation, halfSize, halfSize);

            this.drawInsideRectangle(g, rect, true);

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

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

        }

    }

    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;

    }

}

/* 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 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.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)) {

            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;

    }