Application: gvSIG desktop » gvSIG raster

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.raster.tilecache.provider;

import java.io.File;

import java.io.IOException;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

/**

 * Filesystem Provider for JIMI. Initially, accepts png files

 * @author dmartinezizquierdo

 *

 */

public class TileCacheFileSystemServerProvider extends AbstractFilesystemServerExplorerProvider

implements FilesystemServerExplorerProvider, ResourceConsumer{

    protected FilesystemServerExplorerProviderServices serverExplorer;

    public int getMode() {

        return DataServerExplorer.MODE_RASTER;

    }

    @Override

    public boolean canCreate() {

        return false;

    }

    @Override

    public boolean canCreate(NewDataStoreParameters arg0) {

        return false;

    }

    @Override

    public void create(NewDataStoreParameters arg0, boolean arg1)

        throws CreateException {

        throw new UnsupportedOperationException();

    }

    @Override

    public NewDataStoreParameters getCreateParameters() throws DataException {

        throw new UnsupportedOperationException();

    }

    @Override

    public void initialize(FilesystemServerExplorerProviderServices serverExplorer) {

        this.serverExplorer = serverExplorer;

    }

    @Override

    public void remove(DataStoreParameters parameters) throws RemoveException {

        //FIXME

//        TileCacheStoreProviderParameters params = (TileCacheStoreProviderParameters) parameters;

//        File file = params.getFile();

//        if (!file.exists()) {

//            throw new RemoveException(this.getDataStoreProviderName(),

//                    new FileNotFoundException(params.getFile()));

//        }

//        if (!file.delete()) {

//            throw new RemoveException(this.getDataStoreProviderName(),

//                    new IOException("Error deleting file: "+file.getName()));

//        }

    }

    @Override

    public String getDataStoreProviderName() {

        return TileCacheStoreProvider.NAME;

    }

    @Override

    public String getDescription() {

        return TileCacheStoreProvider.DESCRIPTION;

    }

    @Override

    public boolean accept(File pathname) {

        //TODO Creo que deber?a de preguntar al provider que a su vez preguntar?a a la librer?a

        return (pathname.getName().toLowerCase().endsWith(".png"));

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return !(this.equals(resource));

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        //Do nothing

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.raster.tilecache.provider;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

import org.gvsig.fmap.dal.raster.api.BandAttributeDescriptor;

import org.gvsig.fmap.dal.raster.api.BandDescriptor;

import org.gvsig.fmap.dal.raster.api.BandQuery;

import org.gvsig.fmap.dal.raster.api.RasterQuery;

import org.gvsig.fmap.dal.raster.spi.AbstractRasterStoreProvider;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.raster.lib.buffer.api.BandInfo;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.BufferManager;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.api.PageManager;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Provider for Tile Cache

 * @author dmartinezizquierdo

 *

 */

public class TileCacheStoreProvider extends AbstractRasterStoreProvider implements

ResourceConsumer{

    private static final Logger logger =

        LoggerFactory.getLogger(TileCacheStoreProvider.class);

    public static String NAME = "TileCache";

    public static String DESCRIPTION = "Tile cache provider";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private ResourceProvider resource;

    private final SimpleTaskStatus taskStatus;

    private TileStructImage tileStructImage = null;

    private Envelope envelope = null;

    private IProjection projection= null;

    protected static void registerMetadataDefinition()

        throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

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

            manager.addDefinition(METADATA_DEFINITION_NAME,

                TileCacheStoreProviderParameters.class

                    .getResourceAsStream("TileCacheMetadata.xml"),

                TileCacheStoreProviderParameters.class.getClassLoader());

        }

    }

    public TileCacheStoreProvider(TileCacheStoreProviderParameters params,

        DataStoreProviderServices storeServices)

        throws InitializeException {

        super(

                params,

                storeServices,

                FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("TileCache");

        this.init(params, storeServices);

    }

    protected TileCacheStoreProvider(TileCacheStoreProviderParameters params,

            DataStoreProviderServices storeServices, DynObject metadata)

            throws InitializeException {

        super(params, storeServices, metadata);

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("TileCache");

        this.init(params, storeServices);

    }

    protected void init(TileCacheStoreProviderParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

        if (params == null) {

            throw new InitializeException(

                new NullPointerException("params is null"));

        }

//        File file = getTileCacheParameters().getFile();

//        if (file == null) {

//            throw new InitializeException(

//                new NullPointerException("Jimi file is null"));

//        }

//

        this.projection=params.getCRS();

        //FIXME

        File file = new File("/home/daniel/pruebas/datosPruebaRaster/tileCache/valencia1980");

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

    }

    private TileCacheStoreProviderParameters getTileCacheParameters() {

        return (TileCacheStoreProviderParameters) this.getParameters();

    }

    @Override

    public BandDescriptor getBandDescriptor(int band) {

        if(band > this.getBands()){

            throw new IllegalArgumentException("Invalid band");

        }

        return getStoreServices().createBandDescriptor(band,

            new ArrayList<BandAttributeDescriptor>());

    }

    @Override

    public int getBands() {

        return tileStructImage.getBandNumber();

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        int[] bandDataTypes;

        List<PageManager> pageManagers = new ArrayList<PageManager>();

        NoData[] bandNoData;

        if (rasterQuery != null) {

            List<BandQuery> bands;

            bands = rasterQuery.getBands();

            bandDataTypes = new int[bands.size()];

            bandNoData = new NoData[bands.size()];

            for (BandQuery bandQuery : bands) {

                int band = bandQuery.getBand();

                bandDataTypes[band] = tileStructImage.getDataTypes()[band];

                bandNoData[band] = null;

                pageManagers.add(new TileCacheBandPageManager(tileStructImage, rasterQuery.getPixelSize(), band));

            }

        } else {

            int bands = getBands();

            bandDataTypes = new int[bands];

            bandNoData = new NoData[bands];

            for (int i = 0; i < bands; i++) {

                bandDataTypes[i] = tileStructImage.getDataTypes()[i];

                bandNoData[i] = null;

                pageManagers.add(new TileCacheBandPageManager(tileStructImage, rasterQuery.getPixelSize(), i));

            }

        }

        int zoomLevel=tileStructImage.getZoomLvlForPixelSize(rasterQuery.getPixelSize());

        envelope=tileStructImage.getEnvelopePerZoomLevel(zoomLevel);

        Buffer buffer =

            bufferManager.createBuffer(tileStructImage.getRows(zoomLevel), tileStructImage.getColumns(zoomLevel), bandDataTypes, bandNoData,

                projection, envelope, pageManagers);

        return buffer;

    }

    @Override

    public BandInfo getBandInfo(int band) {

        //FIXME

        return null;//tileStructImage.getBandInfo(band);

    }

    @Override

    public DataServerExplorer getExplorer()

        throws ReadException, ValidateDataParametersException {

//        DataManager manager = DALLocator.getDataManager();

//        FilesystemServerExplorerParameters params;

//        try {

//            params = (FilesystemServerExplorerParameters) manager

//            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

//            params.setRoot(this.getTileCacheParameters().getFile().getParent());

//            return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);

//        } catch (DataException e) {

//            throw new ReadException(this.getProviderName(), e);

//        } catch (ValidateDataParametersException e) {

//            throw new ReadException(this.getProviderName(), e);

//        }

        //FIXME

        return null;

    }

    public void open() throws OpenException {

        if (this.tileStructImage != null) {

            return;

        }

        openEver();

    }

    private void openEver() throws OpenException {

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    try {

                        File folder = (File) resource.get();

                        resource.notifyOpen();

                        //FIXME

                        tileStructImage = new TileStructImage(folder,getTileCacheParameters().getCRS());

//                        if (getTileCacheParameters().getWldParams()!=null){

//                            envelope=createWLDEnvelope(getTileCacheParameters().getWldParams());

//                        }else{

//                        envelope =

//                            GeometryLocator.getGeometryManager().createEnvelope(0, 0,

//                                tileStructImage.getColumns(), tileStructImage.getRows(), Geometry.SUBTYPES.GEOM2D);

//                        }

                        resource.notifyClose();

                        resource.setData(tileStructImage);

                    } finally  {

                        //TODO

                    }

                    return null;

                }

            });

        } catch (Exception e) {

            this.tileStructImage = null;

            try {

                throw new OpenException(resource.getName(), e);

            } catch (AccessResourceException e1) {

                throw new OpenException(getProviderName(), e);

            }

        } finally {

            this.taskStatus.remove();

        }

    }

//    private Envelope createWLDEnvelope(List<String> wldParams){

//        double pixelSizeX=Double.valueOf(wldParams.get(0));

//        double rotationAxisY = Double.valueOf(wldParams.get(1));

//        double rotationAxisX = Double.valueOf(wldParams.get(2));

//        double pixelSizeY = Double.valueOf(wldParams.get(3));

//        double upperLeftPixelCenterCoordX = Double.valueOf(wldParams.get(4));

//        double upperLeftPixelCenterCoordY = Double.valueOf(wldParams.get(5));

//

//        if (0.0 != rotationAxisX || 0.0 != rotationAxisY) {

//            logger.warn(

//                "Rotation in wld file not implemented yet. It will be ignored");

//        }

//

//        double leftMostX = upperLeftPixelCenterCoordX - (pixelSizeX * 0.5);

//        double upperMostY = upperLeftPixelCenterCoordY - (pixelSizeY * 0.5);

//        double height=tileStructImage.getRows()*pixelSizeY;

//        double width=tileStructImage.getColumns()*pixelSizeX;

//

//        // double minX, double minY, double maxX, double maxY, int subType

//        try {

//            envelope = GeometryLocator.getGeometryManager().createEnvelope(

//                Math.min(leftMostX,leftMostX + width),

//                Math.min(upperMostY,upperMostY + height),

//                Math.max(leftMostX,leftMostX + width),

//                Math.max(upperMostY,upperMostY + height),

//                Geometry.SUBTYPES.GEOM2D);

//        } catch (LocatorException | CreateEnvelopeException e) {

//            logger.warn(

//                "Failed to create envelope from wld file with coords: minx:"+leftMostX+

//                ", miny:"+upperMostY+", maxX: "+leftMostX + width+", maxY: "+upperMostY + height);

//            e.printStackTrace();

//        }

//

//        return envelope;

//    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {

            return this.envelope;

        } else if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {

            IProjection pro = this.getTileCacheParameters().getCRS();

            if (pro != null) {

                return pro;

            }

        }

        return super.getDynValue(name);

    }

    @Override

    public void close() throws CloseException {

        this.tileStructImage = null;

    }

    @Override

    public ResourceProvider getResource() {

        return this.resource;

    }

    @Override

    public Object getSourceId() {

        return this.getTileCacheParameters().getName();

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() {

        String name = this.getTileCacheParameters().getName();

        return name; //FilenameUtils.getBaseName(name);

    }

    @Override

    public String getFullName() {

        return this.getTileCacheParameters().getName();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

     * gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

            DataStoreNotification.RESOURCE_CHANGED,

            resource);

    }

    @Override

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider#doDispose()

     */

    protected void doDispose() throws BaseException {

        super.doDispose();

        resource.removeConsumer(this);

    }

    public TileStructImage getTileStructImage() {

        return tileStructImage;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.raster.tilecache.provider;

import java.io.File;

import java.io.IOException;

import java.util.List;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.FileHelper;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

import org.gvsig.fmap.dal.raster.spi.OpenRasterStoreParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.spi.AbstractDataParameters;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Parameters to create a JIMI Provider

 * @author dmartinezizquierdo

 *

 */

public class TileCacheStoreProviderParameters extends AbstractDataParameters implements

OpenRasterStoreParameters{

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

    public static final String PARAMETERS_DEFINITION_NAME = "TileCacheStoreProviderParameters";

    public static final String TILECACHE_NAME_PARAMTER_NAME = "name";

    public static final String CRS_PARAMTER_NAME = "crs";

    public static final String WLD_PARAMS_NAME= "wldParams";

    private DelegatedDynObject parameters;

    /**

     * Constructor

     */

    public TileCacheStoreProviderParameters() {

        this(PARAMETERS_DEFINITION_NAME);

    }

    protected TileCacheStoreProviderParameters(String parametersDefinitionName) {

        this(parametersDefinitionName, TileCacheStoreProvider.NAME);

    }

    /**

     * Constructor

     * @param parametersDefinitionName

     * @param name

     */

    public TileCacheStoreProviderParameters(String parametersDefinitionName, String name) {

        super();

        this.parameters = (DelegatedDynObject) FileHelper.newParameters(parametersDefinitionName);

        this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, name);

    }

    @Override

    public String getDataStoreName() {

        return (String) this.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

    }

    @Override

    public boolean isValid() {

        return (this.getName() != null);

    }

    @Override

    public String getDescription() {

        return this.getDynClass().getDescription();

    }

    public String getName() {

        return (String) this.getDynValue(TILECACHE_NAME_PARAMTER_NAME);

    }

    public void setName(String name) {

        this.setDynValue(TILECACHE_NAME_PARAMTER_NAME, name);

    }

    /**

     * Sets CRS

     * @param crsCode

     */

    public void setCRS(String crsCode) {

        IProjection crs=CRSFactory.getCRS(crsCode);

        setDynValue(CRS_PARAMTER_NAME, crs);

    }

    /**

     * Sets CRS

     * @param crs

     */

    public void setCRS(IProjection crs) {

        setDynValue(CRS_PARAMTER_NAME, crs);

    }

    /**

     * Gets CRS

     * @return IProjection

     */

    public IProjection getCRS() {

        return (IProjection) getDynValue(CRS_PARAMTER_NAME);

    }

    /**

     * Gets the 6 params of a WLD file as Strings.

     * @return Returns WLD parameters

     */

    public List<String> getWldParams(){

        return (List<String>) getDynValue(WLD_PARAMS_NAME);

    }

    /**

     * Sets the params of a wld file

     * @param wldParams

     */

    public void setWldParams(List<String> wldParams){

        setDynValue(WLD_PARAMS_NAME,wldParams);

    }

    @Override

    protected DelegatedDynObject getDelegatedDynObject() {

        return parameters;

    }

//    private void loadPRJ(File file){

//        File prjFile = new File(FilenameUtils.removeExtension(file.getAbsolutePath())+".prj");

//        if (prjFile.exists()) {

//            try {

//                String contentFile = FileUtils.readFileToString(prjFile);

//                if (StringUtils.isNotEmpty(contentFile)){

//                    IProjection crs=CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT_ESRI, contentFile);

//                    setCRS(crs);

//                }

//

//            } catch (IOException e) {

//                logger.warn("Couldn't read wld file");

//            }

//        }

//    }

//

//    private void loadWLD(File file){

//        File wldFile = new File(FilenameUtils.removeExtension(file.getAbsolutePath())+".wld");

//        if (wldFile.exists()) {

//            try {

//                List<String> lines = FileUtils.readLines(wldFile);

//                if (lines!=null && lines.size()==6){

//                    setWldParams(lines);

//                }

//

//            } catch (IOException e) {

//                logger.warn("Couldn't read wld file");

//            }

//        }

//    }

}

package org.gvsig.raster.tilecache.provider;

import java.io.IOException;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.DoubleBuffer;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

import java.nio.ShortBuffer;

import org.gvsig.raster.lib.buffer.api.BandInfo;

import org.gvsig.raster.lib.buffer.api.BandPageManager;

import org.gvsig.raster.lib.buffer.api.BandTileManager;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.BufferManager;

/**

 * Band Page Managaer for a Memory Image

 * @author dmartinezizquierdo

 *

 */

public class TileCacheBandPageManager implements BandTileManager{

    private TileStructImage tileStructImage;

    private int band;

    private int dataSize = -1;

    private int dataType = BufferManager.TYPE_UNDEFINED;

    private double pixelSize;

    private int zoomLevel;

    /**

     * @param image

     * @param band

     */

    public TileCacheBandPageManager(TileStructImage tileStructImage, double pixelSize, int band){

        this.tileStructImage=tileStructImage;

        this.pixelSize=pixelSize;

        this.band=band;

        this.zoomLevel=tileStructImage.getZoomLvlForPixelSize(pixelSize);

    }

    @Override

    public boolean isSupportedSave() {

        return false;

    }

    @Override

    public void load(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException {

//        int xOffset = col;

//        int xSize = cols;

//        int yOffset = row;

//        int ySize = rows;

        buffer.rewind();

//        int completeRasterRows=tileStructImage.getRows(this.zoomLevel);

//        int completeRasterColumns=tileStructImage.getColumns(this.zoomLevel);

        int tileRow=(int)row/getRowsPerTile();

        int tileCol=(int)col/getColumnsPerTile();

        tileStructImage.fetchTile(buffer, band, this.zoomLevel,tileRow,tileCol);

//

//        buffer.rewind();

//

//        int offset=0;

//        for (int i=row; i<=rows; i++){

//            int tileRow=(int)i/getRowsPerTile();

//            int rowInTile=i-(tileRow*getRowsPerTile());

//            int j =col;

//            while (j<cols){

//                int tileCol=(int)j/getColumnsPerTile();

//                int firstColInTile=j-(tileCol*getColumnsPerTile());

//                int lastColInTile=getColumnsPerTile();

//                if ( cols<(tileCol+1)*getColumnsPerTile() ){

//                    lastColInTile=cols-(tileRow*getRowsPerTile());

//                }

//                Tile tile=tileStructImage.getTile(this.zoomLevel,tileRow,tileCol);

//                byte[] tileBuffer= tile.getBuffer(rowInTile,firstColInTile, lastColInTile);

//                int length=lastColInTile-firstColInTile;

//                ((ByteBuffer) buffer).put(tileBuffer, offset, length);

//                offset+=length;

//

//                j=( tileCol*getColumnsPerTile() ) +1;

//            }

//

//        }

    }

    @Override

    public BandInfo getBandInfo() {

        //FIXME

        return null;

    }

    @Override

    public void save(Buffer buffer, int row, int rows, int col, int cols,

        int dataType) throws IOException {

        throw new UnsupportedOperationException();

    }

    @Override

    public int getRowsPerTile() {

        return tileStructImage.getRowsPerTile();

    }

    @Override

    public int getColumnsPerTile() {

        return tileStructImage.getColumnsPerTile();

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.raster.tilecache.provider;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStoreProvider;

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

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

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

import org.gvsig.fmap.dal.raster.api.RasterStore;

import org.gvsig.fmap.dal.raster.spi.AbstractRasterStoreProviderFactory;

import org.gvsig.fmap.dal.raster.spi.RasterStoreProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.locator.LocatorException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Factory for JIMI provider

 * @author dmartinezizquierdo

 *

 */

public class TileCacheStoreProviderFactory extends AbstractRasterStoreProviderFactory {

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

    protected TileCacheStoreProviderFactory(String name, String description) {

        super(name, description);

    }

    @Override

    public DataStoreProvider createProvider(DataParameters parameters,

        DataStoreProviderServices providerServices) throws InitializeException {

        return (DataStoreProvider) new TileCacheStoreProvider((TileCacheStoreProviderParameters)parameters,providerServices);

    }

    @Override

    public DynObject createParameters() {

        return new TileCacheStoreProviderParameters();

    }

    public TileCacheStoreProvider createJimiProvider(TileCacheStoreProviderParameters parameters,

        DataStoreProviderServices providerServices) throws InitializeException {

        return new TileCacheStoreProvider(parameters,providerServices);

    }

    public TileCacheStoreProviderParameters createJimiParameters(){

        return new TileCacheStoreProviderParameters();

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.raster.tilecache.provider;

import java.io.File;

import java.nio.Buffer;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.SortedMap;

import java.util.TreeMap;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

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

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

import org.gvsig.fmap.dal.raster.api.RasterStore;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerManager;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderFactory;

import org.gvsig.fmap.dal.spi.DALSPILocator;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

/**

 * Represents a tiled image

 * @author dmartinezizquierdo

 *

 */

public class TileStructImage{

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

    private int rowsPerTile;

    private int columnsPerTile;

    private String providerName;

    private FilesystemServerExplorerProviderFactory factory;

    private SortedMap<Integer,Double> pixelSizePerZoomLevel;

//    private SortedMap<Integer,Integer> rowsPerZoomLevel;

//    private SortedMap<Integer,Integer> columnsPerZoomLevel;

    private SortedMap<Integer,List<Integer>> rowsInZoomLevel;

    private SortedMap<Integer,List<Integer>> columnsInZoomLevel;

    private SortedMap<Integer,Envelope> envelopePerZoomLevel;

//    private SortedMap<Integer,Integer[][]> tileMatrixPerZoomLevel;

    private File tilesFolder;

    private int bandNumber;

    private int[] dataTypes;

    private RasterStore tileStore;

    private IProjection crs;

    public TileStructImage(File folder, IProjection crs){

        this.crs=crs;

        rowsInZoomLevel=new TreeMap<Integer,List<Integer>>();

        columnsInZoomLevel=new TreeMap<Integer,List<Integer>>();

        envelopePerZoomLevel=new TreeMap<Integer,Envelope>();

        pixelSizePerZoomLevel=new TreeMap<Integer,Double>();

        //FIXME

        File tilePropertiesFile=new File(folder, "tileCacheStruct.xml");

        tilesFolder=new File (folder,"V"+File.separatorChar+"Z"+File.separatorChar+"T");

        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

        DocumentBuilder dBuilder;

        try {

            dBuilder = dbFactory.newDocumentBuilder();

            Document doc = dBuilder.parse(tilePropertiesFile);

            doc.getDocumentElement().normalize();

            NodeList nList = doc.getElementsByTagName("TileCacheStruct");

            for (int temp = 0; temp < nList.getLength(); temp++) {

                Node nNode = nList.item(temp);

                if (nNode.getNodeType() == Node.ELEMENT_NODE) {

                    Element eElement = (Element) nNode;

                    NamedNodeMap tileSizeAttributes = eElement.getElementsByTagName("tileSize").item(0).getAttributes();

                    rowsPerTile=Integer.valueOf(tileSizeAttributes.getNamedItem("rows").getNodeValue());

                    columnsPerTile=Integer.valueOf(tileSizeAttributes.getNamedItem("columns").getNodeValue());

                    NodeList elementsByTagName = eElement.getElementsByTagName("format");

                    providerName=elementsByTagName.item(0).getTextContent();

                    FilesystemServerExplorerManager explorerManager = DALFileLocator.getFilesystemServerExplorerManager();

                    Iterator it = explorerManager.getRegisteredProviders();

                    while(it.hasNext()){

                        Extension ext = (Extension) it.next();

                        FilesystemServerExplorerProviderFactory providerFactory;

                        try {

                            providerFactory = (FilesystemServerExplorerProviderFactory) ext.create();

                            if(providerFactory.getName().equalsIgnoreCase(providerName)){

                                this.factory = providerFactory;

                                break;

                            }

                        } catch (Exception e) {

                            throw new RuntimeException(e);// FIXME !!!

                        }

                    }

                    NodeList levelsTag = eElement.getElementsByTagName("levels");

                    Element levels = (Element)levelsTag.item(0);

                    NodeList levelList=levels.getElementsByTagName("level");

                    for (int i = 0; i < levelList.getLength(); i++) {

                        Element level = (Element)levelList.item(i);

                        int zoomLevel=Integer.valueOf(level.getElementsByTagName("index").item(0).getTextContent());

                        double pixelSize=Double.valueOf(level.getElementsByTagName("pixelSize").item(0).getTextContent());

                        pixelSizePerZoomLevel.put(zoomLevel, pixelSize);

                        readFolderTileStructure(zoomLevel);

                    }

                }

            }

        } catch (Exception e) {

            throw new RuntimeException();

        }

    }

    /**

     * @param zoomLevel

     */

    private void readFolderTileStructure(int zoomLevel){

        File zoomFolder=new File(tilesFolder,String.valueOf(zoomLevel));

        String[] columnsNames = zoomFolder.list();

        Set<Integer> columns = new HashSet<Integer>();

        for (int i = 0; i < columnsNames.length; i++) {

            columns.add(Integer.valueOf(FilenameUtils.getBaseName(columnsNames[i])));

        }

        ArrayList<Integer> columnsList = new ArrayList<Integer>();

        columnsList.addAll(columns);

        Collections.sort(columnsList);

        this.columnsInZoomLevel.put(zoomLevel, columnsList);

//        columnsPerZoomLevel.put(zoomLevel, columnsNames.length*getColumnsPerTile());

        int maxRows=0;

        Integer firstColumn=columnsList.get(0);

        Integer firstRow=null;

        for (String columnName:columnsNames){

            File columnFolder=new File(zoomFolder,columnName);

            String[] filenames = columnFolder.list();

            Set<Integer> rows = new HashSet<Integer>();

            for (int i = 0; i < filenames.length; i++) {

                rows.add(Integer.valueOf(FilenameUtils.getBaseName(filenames[i])));

            }

            if (rows.size()>maxRows){

                maxRows=rows.size();

            }

            if (firstRow==null){

                ArrayList<Integer> rowsList = new ArrayList<Integer>();

                rowsList.addAll(rows);

                Collections.sort(rowsList);

                this.rowsInZoomLevel.put(zoomLevel, rowsList);

                firstRow=rowsList.get(0);

            }

        }

//        rowsPerZoomLevel.put(zoomLevel, maxRows*getColumnsPerTile());

        //FIXME:  leer el primer tile para obtener el upperLeftPoint

        File firstRowFile=null;

        File firstColumnFolder=new File(zoomFolder,String.valueOf(firstColumn));

        String rowBaseName = String.valueOf(firstRow);

        File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory);

        for (int i = 0; i < providerAcceptedFiles.length; i++) {

            File providerAcceptedFile = providerAcceptedFiles[i];

            if(FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase(rowBaseName)){

                firstRowFile = providerAcceptedFile;

            }

        }

        if ( firstRowFile!=null ){

            DataManagerProviderServices manager =  DALSPILocator.getDataManagerProviderServices();

            DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName);

            DynObject params = providerFactory.createParameters();

            if (params.getDynClass().getDynField("file")!=null){

                params.setDynValue("file", firstRowFile);

            }

            if (params.getDynClass().getDynField("crs")!=null){

                params.setDynValue("crs", this.crs);

            }

            try {

                this.tileStore = (RasterStore) manager.openStore(providerName,params);

                this.bandNumber=this.tileStore.getBands();

                this.dataTypes=new int[this.bandNumber];

                for (int i=0;i<this.bandNumber;i++){

                    dataTypes[i]=this.tileStore.getBandInfo(i).getDataType();

                }

                Envelope firstTileEnvelope=this.tileStore.getEnvelope();

                GeometryManager geoManager=GeometryLocator.getGeometryManager();

                double minX = firstTileEnvelope.getMinimum(DIMENSIONS.X);

                double maxY = firstTileEnvelope.getMaximum(DIMENSIONS.Y);

                Envelope levelEnvelope=geoManager.createEnvelope(

                    minX,

                    maxY - ( getRows(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) ),

                    minX + ( getColumns(zoomLevel)*pixelSizePerZoomLevel.get(zoomLevel) ),

                    maxY,

                    SUBTYPES.GEOM2D);

                envelopePerZoomLevel.put(zoomLevel, levelEnvelope);

            } catch (ValidateDataParametersException |

                  CreateEnvelopeException | DataException e) {

                logger.info("Can't read tile", e);

                // TODO exception

            }

        }else{

            logger.info("Can't read tile structure");

        }

    }

    public int getZoomLvlForPixelSize(double pixelSize){

        int zoom=0;

        for (int i:pixelSizePerZoomLevel.keySet()){

            zoom=i;

            double levelPixelSize=pixelSizePerZoomLevel.get(zoom);

            if (pixelSize>=levelPixelSize){

                return zoom;

            }

        }

        return zoom;

    }

    public void fetchTile(Buffer buffer, int band, int zoomLevel, int tileRow, int tileCol){

        Integer structCol = columnsInZoomLevel.get(zoomLevel).get(tileCol);

        Integer structRow = rowsInZoomLevel.get(zoomLevel).get(tileRow);

        File tileFile=null;

        File zoomFolder=new File(tilesFolder,String.valueOf(zoomLevel));

        File firstColumnFolder=new File(zoomFolder,String.valueOf(structCol));

        String rowBaseName = String.valueOf(structRow);

        File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory);

        for (int i = 0; i < providerAcceptedFiles.length; i++) {

            File providerAcceptedFile = providerAcceptedFiles[i];

            if(FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase(rowBaseName)){

                tileFile = providerAcceptedFile;

            }

        }

        if ( tileFile!=null ){

            DataManagerProviderServices manager =  DALSPILocator.getDataManagerProviderServices();

            DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName);

            DynObject params = providerFactory.createParameters();

            if (params.getDynClass().getDynField("file")!=null){

                params.setDynValue("file", tileFile);

            }

            if (params.getDynClass().getDynField("crs")!=null){

                params.setDynValue("crs", this.crs);

            }

//            RasterStore store;

            try {

                this.tileStore = (RasterStore) manager.openStore(providerName,params);

                Band tileBand = tileStore.getRasterSet().getBand(band);

                Object rowBuffer = tileBand.createRowBuffer();

                for(int r=0; r<tileBand.getRows(); r++){

                    tileBand.fetchRow(r, rowBuffer);

                    System.arraycopy(rowBuffer, 0, buffer.array(), r*tileBand.getColumns(), tileBand.getColumns());

                }

            } catch (ValidateDataParametersException | DataException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

    }

    public int getBandNumber(){

        return this.bandNumber;

    }

    public int[] getDataTypes(){

        return this.dataTypes;

    }

    public int getRows(int zoomLevel){

        return rowsInZoomLevel.get(zoomLevel).size()*rowsPerTile;

        //rowsPerZoomLevel.get(zoomLevel);

    }

    public int getColumns(int zoomLevel){

        return columnsInZoomLevel.get(zoomLevel).size()*columnsPerTile;

//        return columnsPerZoomLevel.get(zoomLevel);

    }

    public Envelope getEnvelopePerZoomLevel(int zoomLevel){

        return envelopePerZoomLevel.get(zoomLevel);

    }

    public int getRowsPerTile() {

        return rowsPerTile;

    }

    public int getColumnsPerTile() {

        return columnsPerTile;

    }

    public String getProviderName() {

        return providerName;

    }

    public RasterStore getTileStore() {

        return tileStore;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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.raster.tilecache.provider;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.FileHelper;

import org.gvsig.fmap.dal.spi.DALSPILocator;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 * Jimi Library to register provider commponents

 * @author dmartinezizquierdo

 *

 */

public class TileCacheLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(DALFileLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		List<Throwable> exs = new ArrayList<Throwable>();

		FileHelper.registerParametersDefinition(

				TileCacheStoreProviderParameters.PARAMETERS_DEFINITION_NAME,

				TileCacheStoreProviderParameters.class, "TileCacheParameters.xml");

		try {

			FileHelper.registerMetadataDefinition(

					TileCacheStoreProvider.METADATA_DEFINITION_NAME,

					TileCacheStoreProvider.class, "TileCacheMetadata.xml");

		} catch (MetadataException e) {

			exs.add(e);

		}

		DataManagerProviderServices dataman = DALSPILocator.getDataManagerProviderServices();

		try {

            if (!dataman.getStoreProviders()

                .contains(TileCacheStoreProvider.NAME)) {

                dataman.registerStoreProviderFactory(

                    new TileCacheStoreProviderFactory(

                        TileCacheStoreProvider.NAME,

                        TileCacheStoreProvider.DESCRIPTION));

            }

		} catch (RuntimeException e) {

			exs.add(e);

		}

//		try {

//			DALFileLocator.getFilesystemServerExplorerManager()

//					.registerProvider(TileCacheStoreProvider.NAME,

//					    TileCacheStoreProvider.DESCRIPTION,

//							TileCacheFileSystemServerProvider.class);

//		} catch (RuntimeException e) {

//			exs.add(e);

//		}

		if (exs.size() > 0) {

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

		}

	}

}

org.gvsig.raster.tilecache.provider.TileCacheLibrary

<?xml version="1.0"?>

<!--

Definitions of metadata fields of a Tile Cache file.

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="TileCache" namespace="Metadata">

      <extends>

      	<class namespace="Metadata" name="SpatialProvider"/>

      </extends>

      <description>Metadata of a Tile Cache store</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="TileCacheStoreProviderParameters">

       <extends>

      	<class namespace="dal" name="ProviderParameters"/>

      </extends>

      <description>Store the parameters need to open a tile cache file</description>

      <fields>

        <field name="name" type="string" mandatory="true" group="Basic">

          <description>Name to identify the tile structure</description>

        </field>

        <field name="crs" type="crs" mandatory="true" group="Basic">

          <description>The coordinate reference system used in this jimi file</description>

        </field>

        <field name="wldParams" type="object" mandatory="false" group="Basic" classOfValue="java.util.List">

          <description>Info given by a wld file with geolocation</description>

        </field>

      </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.raster.tilecache</artifactId>

    <version>2.4.1-SNAPSHOT</version>

  </parent>

  <artifactId>org.gvsig.raster.tilecache.provider</artifactId>

  <name>org.gvsig.raster.tilecache.provider</name>

  <description>Provider for tiled cache</description>

<dependencies>

  <dependency>

   <groupId>org.gvsig</groupId>

   <artifactId>org.gvsig.fmap.dal.raster.spi</artifactId>

  </dependency>

  <dependency>

   <groupId>org.gvsig</groupId>

   <artifactId>org.gvsig.tools.lib</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.raster.tilecache</artifactId>

    <version>2.4.1-SNAPSHOT</version>

  </parent>

  <artifactId>org.gvsig.raster.tilecache.app</artifactId>

  <packaging>pom</packaging>

  <name>org.gvsig.raster.tilecache.app</name>

  <modules>

   <module>org.gvsig.raster.tilecache.app.mainplugin</module>

  </modules>

</project>