Application: gvSIG desktop » gvSIG raster

#

#Thu Mar 07 10:25:56 CET 2013

owner=gvSIG Association

code=org.gvsig.raster.tilecache.io

java-version=j1_5

official=true

type=plugin

version=2.0.0-0

state=devel

operating-system=all

dependencies=

sources-url=https\://devel.gvsig.org/redmine/projects/gvsig-raster/repository/show/org.gvsig.raster.tilecache/tags/2.0.0/org.gvsig.raster.tilecache.io

web-url=http\://www.gvsig.com

architecture=all

model-version=1.0.1

categories=

description=cache service for gvSIG

buildNumber=0

gvSIG-version=2.0.0

name=org.gvsig.raster.tilecache.io

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.tilecache.io.tff;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

/**

 * Parameters for the TileFileFormat explorer provider

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TileFileFormatExplorerParameters extends AbstractDataParameters implements DataServerExplorerParameters {

	public static final String     DYNCLASS_NAME       = "TileFileFormatExplorerParameters";

	protected static DynClass      DYNCLASS            = null;

	private DelegatedDynObject     delegatedDynObject  = null;

	public TileFileFormatExplorerParameters() {

		super();

		initialize();

	}

	protected void initialize() {

		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						DYNCLASS);

	}

	public static void registerDynClass() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass;

		if(dynman == null)

			return;

		if (DYNCLASS == null) {

			dynClass = dynman.add(DYNCLASS_NAME);

			DYNCLASS = dynClass;

		}

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return delegatedDynObject;

	}

	public String getDataStoreName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

	public String getExplorerName() {

		return TileFileFormatProvider.NAME;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 *

 */

package org.gvsig.raster.tilecache.io.tff;

import java.awt.geom.Point2D;

import java.io.File;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.exception.BandAccessException;

import org.gvsig.fmap.dal.coverage.exception.FileNotOpenException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSetViewException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSourceException;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ParsingException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

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

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

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.provider.TileServer;

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.TiledRasterProvider;

import org.gvsig.raster.impl.store.DefaultStoreFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Provider for <code>TileFileFormat</code>

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TileFileFormatProvider extends AbstractRasterProvider implements TiledRasterProvider {

	public static String                NAME                     = "TileFileFormat Store";

	public static String                DESCRIPTION              = "Tile file format Source";

	public static final String          METADATA_DEFINITION_NAME = "TileFileFormatStore";

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

	protected static String[]           formatList               = null;

	private boolean                     open                     = false;

	public static void register() {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		registerFormats();

		ExtensionPoint point = extensionPoints.get("DefaultRasterProvider");

		point.append("reader", TileFileFormatProvider.NAME, TileFileFormatProvider.class);

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

			dataman.registerStoreProvider(NAME,

					TileFileFormatProvider.class, TileFileFormatDataParameters.class);

		}

		if(DALFileLocator.getFilesystemServerExplorerManager() != null)

			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

					NAME, DESCRIPTION,

					TileFileFormatFilesystemServerExplorer.class);

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	private static void registerFormats() {

		formatList      = new String[] {"tff"};

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

			RasterLocator.getManager().getProviderServices().addFormat(formatList[i], TileFileFormatProvider.class);

	}

	public String[] getFormatList() {

		return formatList;

	}

	public boolean isExtensionSupported(String ext) {

		if(ext.indexOf(".") != -1)

			ext = ext.substring(ext.lastIndexOf(".") + 1, ext.length());

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

			if(formatList[i].compareTo(ext) == 0)

				return true;

		}

		return false;

	}

	public TileFileFormatProvider() throws NotSupportedExtensionException {

		super();

	}

	public TileFileFormatProvider(TileFileFormatDataParameters params,

			DataStoreProviderServices storeServices) throws InitializeException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		try {

			init(params, storeServices);

		} catch (OpenException e) {

			throw new InitializeException("Error open the source", e);

		} catch (NotSupportedExtensionException e) {

			throw new InitializeException("Not supported extension", e);

		}

	}

	/**

	 * Build file references

	 * @param proj Projection

	 * @param param Load parameters

	 * @throws NotSupportedExtensionException

	 */

	public void init(TileFileFormatDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		openFromTff();

		uri = getParameters().getURI();

		super.init();

		try {

			loadFromRmf(getRmfBlocksManager());

		} catch (ParsingException e) {

			logger.debug("Problems reading from RMF", e);

		}

		open = true;

	}

	/**

	 * Open from a .mff file.

	 * This method loads all providers and adds these to the parameters

	 * @throws OpenException

	 */

	private void openFromTff() throws OpenException {

	}

	public TileFileFormatDataParameters getParameters() {

		try {

			return (TileFileFormatDataParameters)parameters;

		} catch (ClassCastException e) {

			return null;

		}

	}

	@Override

	public int getBlockSize() {

		return 0;

	}

	@Override

	public Object getData(int x, int y, int band)

			throws InvalidSetViewException, FileNotOpenException,

			RasterDriverException {

		return null;

	}

	@Override

	public double getHeight() {

		return 0;

	}

	@Override

	public int getOverviewHeight(int band, int overview)

			throws BandAccessException, RasterDriverException {

		return 0;

	}

	@Override

	public int getOverviewWidth(int band, int overview)

			throws BandAccessException, RasterDriverException {

		return 0;

	}

	@Override

	public Extent getView() {

		return null;

	}

	@Override

	public double getWidth() {

		return 0;

	}

	@Override

	public boolean isOverviewsSupported() {

		return false;

	}

	@Override

	public RasterProvider load() {

		return null;

	}

	@Override

	public void setView(Extent e) {

	}

	public Extent getCoordsInLevel(Point2D viewCenter, int level, int w, int h) {

		return null;

	}

	public Extent getCoordsInTheNearestLevel(Extent extent, int w, int h) {

		return null;

	}

	public RasterProvider getInternalProvider() {

		return null;

	}

	public int getNearestLevel(double pixelSize) {

		return 0;

	}

	public Tile getTile(SpiRasterQuery q) throws TileGettingException {

		return null;

	}

	public int getZoomLevels() {

		return 0;

	}

	public int getOverviewCount(int band) throws BandAccessException,

			RasterDriverException {

		return 0;

	}

	public TileServer getTileServer() {

		return null;

	}

	public boolean isOpen() {

		return open;

	}

	public Object readBlock(int pos, int blockHeight, double scale)

			throws InvalidSetViewException, FileNotOpenException,

			RasterDriverException, ProcessInterruptedException {

		return null;

	}

	public void setStatus(RasterProvider provider) {

	}

	public String getProviderName() {

		return NAME;

	}

	@Override

	public void loadBuffer(SpiRasterQuery query)

			throws ProcessInterruptedException, RasterDriverException {

		// TODO Auto-generated method stub

	}

    /* (non-Javadoc)

     * @see org.gvsig.raster.impl.provider.RasterProvider#addFile(java.io.File)

     */

    @Override

    public void addFile(File file) throws InvalidSourceException {

        //Do nothing

    }

    /* (non-Javadoc)

     * @see org.gvsig.raster.impl.provider.RasterProvider#removeFile(java.io.File)

     */

    @Override

    public void removeFile(File file) {

        //Do nothing

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

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

*

*/

package org.gvsig.raster.tilecache.io.tff;

import org.gvsig.raster.impl.store.AbstractNewRasterStoreParameters;

/**

 * Parameters for creating a <code>TileFileFormat</code> store

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TileFileFormatNewRasterStoreParameters extends AbstractNewRasterStoreParameters {

	public String getDataStoreName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

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

*

*/

package org.gvsig.raster.tilecache.io.tff;

import java.io.File;

import java.util.List;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

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

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

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

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

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

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

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

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

import org.gvsig.raster.impl.store.AbstractRasterFileDataParameters;

public class TileFileFormatFilesystemServerExplorer extends AbstractFilesystemServerExplorerProvider {

	public TileFileFormatFilesystemServerExplorer() {

	}

	public TileFileFormatFilesystemServerExplorer(

			TileFileFormatExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

		System.out.println();

	}

	public String getDataStoreProviderName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

	public DataStoreParameters getStoreParameters() {

		DataManager manager = DALLocator.getDataManager();

		try {

			return  manager.createStoreParameters(this.getDataStoreProviderName());

		} catch (InitializeException e) {

			e.printStackTrace();

		} catch (ProviderNotRegisteredException e) {

			e.printStackTrace();

		}

		return null;

	}

	@SuppressWarnings("unchecked")

	public List getDataStoreProviderNames() {

		return null;

	}

	public String getProviderName() {

		return TileFileFormatProvider.NAME;

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public boolean canCreate() {

		return false;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		return false;

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		throw new UnsupportedOperationException();

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		return null;

	}

	public void initialize(

			FilesystemServerExplorerProviderServices serverExplorer) {

	}

	public boolean accept(File pathname) {

		return RasterLocator.getManager().getProviderServices().isExtensionSupported(

				pathname.getAbsolutePath(), 

				TileFileFormatProvider.class);

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		throw new UnsupportedOperationException();

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		AbstractRasterFileDataParameters params = (AbstractRasterFileDataParameters) manager

				.createStoreParameters(this.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public DataServerExplorerParameters getParameters() {

		return null;

	}

	@SuppressWarnings("unchecked")

	public List list() throws DataException {

		return null;

	}

	@SuppressWarnings("unchecked")

	public List list(int mode) throws DataException {

		return null;

	}

	public void dispose() {

	}

	public int getMode() {

		return DataServerExplorer.MODE_RASTER;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

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

*

*/

package org.gvsig.raster.tilecache.io.tff;

import org.gvsig.raster.impl.store.AbstractRasterDataParameters;

import org.gvsig.raster.impl.store.AbstractRasterFileDataParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * Parameters for the <code>TileFileFormatProvider</code>

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TileFileFormatDataParameters extends AbstractRasterFileDataParameters {

	public String getDataStoreName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		super.loadFromState(state);

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		super.saveToState(state);

	}	

	public static void registerPersistence() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition("TileFileFormatDataParameters_Persistent");

		if( definition == null ) {

			definition = manager.addDefinition(

					TileFileFormatDataParameters.class,

					"TileFileFormatDataParameters_Persistent",

					"TileFileFormatDataParameters Persistent",

					null, 

					null

			);

			AbstractRasterDataParameters.registerDynClass(definition);

		}

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 *

 */

package org.gvsig.raster.tilecache.io;

import org.gvsig.raster.cache.tile.impl.TileCacheDefaultImplLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class DefaultCacheIOLibrary extends AbstractLibrary {	

	public DefaultCacheIOLibrary() {

		registerAsServiceOf(TileCacheDefaultImplLibrary.class);

	}

	@Override

	protected void doInitialize() throws LibraryException {

		//RasterLibrary.wakeUp();

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		TileDataParametersImpl.registerDynClass();

		TileProvider.register();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.tilecache.io;

import java.io.File;

import java.io.FileInputStream;

import java.util.List;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

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

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

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

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

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

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

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

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

import org.gvsig.raster.impl.store.AbstractRasterFileDataParameters;

public class TileServerExplorer extends AbstractFilesystemServerExplorerProvider implements DataServerExplorerProvider {

	public static final String               NAME                     = "TileServerExplorer";

	public TileServerExplorer() {

	}

	public TileServerExplorer(

			TileServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

	}

	public boolean canCreate() {

		return false;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		return false;

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		throw new UnsupportedOperationException();

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		return null;

	}

	public void initialize(

			FilesystemServerExplorerProviderServices serverExplorer) {

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		throw new UnsupportedOperationException();

	}

	public String getDataStoreProviderName() {

		return TileProvider.NAME;

	}

	/**

	 * When the source is a file then this method will check if exists a 

	 * provider that can manage it

	 */

	public boolean accept(File pathname) {

		if (pathname.getParentFile() != null && 

				pathname.getParentFile().getName().equals("cellhd")) {

			if (pathname.getName().endsWith(".rmf")

					|| pathname.getName().endsWith(".rmf~")) {

				return false;

			}

			return true;

		}

		// Comprobamos que no sea un rmf propio, osea, que contenga xml

		if (pathname.getName().toLowerCase().endsWith(".rmf")) {

			FileInputStream reader = null;

			try {

				reader = new FileInputStream(pathname);

				String xml = "";

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

					xml += (char) reader.read();

				}

				if (xml.equals("<?xml ")) {

					return false;

				}

			} catch (Exception e) {

			} finally {

				try {

					reader.close();

				} catch (Exception e) {

				}

			}

		}

		//The formats will be registered if it hasn't been done yet

		RasterLocator.getManager().getProviderServices().registerTileProviderFormats(TileProvider.class);

		return RasterLocator.getManager().getProviderServices().isExtensionSupported(

				pathname.getName(), 

				TileProvider.class);

	}

	public String getDescription() {

		return TileProvider.DESCRIPTION;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		AbstractRasterFileDataParameters params = (AbstractRasterFileDataParameters) manager

				.createStoreParameters(this.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public DataServerExplorerParameters getParameters() {

		return null;

	}

	public int getMode() {

		return DataServerExplorer.MODE_RASTER;

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	@SuppressWarnings("unchecked")

	public List getDataStoreProviderNames() {

		return null;

	}

	public String getProviderName() {

		return null;

	}

	@SuppressWarnings("unchecked")

	public List list() throws DataException {

		return null;

	}

	@SuppressWarnings("unchecked")

	public List list(int mode) throws DataException {

		return null;

	}

	public void dispose() {

	}

}

package org.gvsig.raster.tilecache.io;

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.net.URI;

import java.util.List;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLibrary;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.BandList;

import org.gvsig.fmap.dal.coverage.datastruct.DatasetBand;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.exception.BandAccessException;

import org.gvsig.fmap.dal.coverage.exception.BandNotFoundInListException;

import org.gvsig.fmap.dal.coverage.exception.FileNotOpenException;

import org.gvsig.fmap.dal.coverage.exception.FileNotSupportedException;

import org.gvsig.fmap.dal.coverage.exception.InfoByPointException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSetViewException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSourceException;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ParsingException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.QueryException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.exception.RmfSerializerException;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

import org.gvsig.fmap.dal.coverage.store.parameter.MultiDimensionalStoreParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.RemoteStoreParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.TileDataParameters;

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

import org.gvsig.fmap.dal.coverage.util.MathUtils;

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.serverexplorer.filesystem.FilesystemServerExplorer;

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

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

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

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.TileCache;

import org.gvsig.raster.cache.tile.TileCacheLibrary;

import org.gvsig.raster.cache.tile.TileCacheLocator;

import org.gvsig.raster.cache.tile.TileCacheManager;

import org.gvsig.raster.cache.tile.exception.TileBuildException;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.layer.TiledLayer;

import org.gvsig.raster.cache.tile.provider.CacheStruct;

import org.gvsig.raster.cache.tile.provider.TileServer;

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

import org.gvsig.raster.impl.datastruct.BandListImpl;

import org.gvsig.raster.impl.datastruct.DatasetBandImpl;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.MemoryTileMatrixBuffer;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.RemoteRasterProvider;

import org.gvsig.raster.impl.provider.TiledRasterProvider;

import org.gvsig.raster.impl.store.DefaultRasterStore;

import org.gvsig.raster.impl.store.DefaultStoreFactory;

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.gvsig.raster.impl.store.properties.DataStoreTransparency;

import org.gvsig.raster.impl.store.properties.RemoteDataStoreStatistics;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.locator.LocatorException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Provider for WMTS service

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TileProvider extends AbstractRasterProvider implements TiledRasterProvider {

	public static String                NAME                     = "Tile Store";

	public static String                DESCRIPTION              = "Raster Tiled Source";

	public static final String          METADATA_DEFINITION_NAME = "TileStore";

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

	private RasterProvider              provider                 = null;

	private boolean                     open                     = false;

	private Extent                      viewRequest              = null;

	private TiledLayer                  tiledLayer               = null;

	private MathUtils                   math                     = RasterLocator.getManager().getMathUtils();

	private TileServer                  secondLevelTileServer    = null;

	public static void register() {

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

			dataman.registerStoreProvider(NAME,

					TileProvider.class, TileDataParametersImpl.class);

		}

		/*if(DALFileLocator.getFilesystemServerExplorerManager() != null)

			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

					NAME, DESCRIPTION,

					TileServerExplorer.class);*/

		if (!dataman.getExplorerProviders().contains(TileServerExplorer.NAME)) {

			dataman.registerExplorerProvider(TileServerExplorer.NAME, TileServerExplorer.class, TileServerExplorerParameters.class);

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	/**

	 * Loads the specific provider to download data

	 * @param file

	 * @return

	 * @throws NotSupportedExtensionException

	 * @throws FileNotSupportedException

	 */

	@SuppressWarnings("unchecked")

	private RasterProvider loadProvider(TileDataParametersImpl params, DataStoreProviderServices storeServices) throws ProviderNotRegisteredException, InitializeException {

		Object obj = params.getDataParameters();

		DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

		DataStoreProvider prov = null;

		if(obj != null && obj instanceof DataStoreParameters) //Remote

			prov = dataManager.createProvider(storeServices, (DataStoreParameters)obj);

		else { //File

			if(params.getFile() != null) {

				//We have to locate a provider's name which manages the selected file

				//A FilesystemServerExplorer will give a getProviderNames service

				FilesystemServerExplorerParameters paramsExplorer = (FilesystemServerExplorerParameters)dataManager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

				FilesystemServerExplorer serverExplorer = null;

				try {

					paramsExplorer.setRoot(File.separator);

					serverExplorer = (FilesystemServerExplorer)dataManager.openServerExplorer(FilesystemServerExplorer.NAME, paramsExplorer);

				} catch (ValidateDataParametersException e) {

					throw new InitializeException(e);

				}

				//Gets the list of provider's name to manage the file

				List<String> provName = serverExplorer.getProviderNameList(params.getFile());

				if(provName.size() > 0) {

					for (int i = 0; i < provName.size(); i++) {

						//Gets the first provider what is not a TileProvider

						if(provName.get(i).compareTo(NAME) != 0) {

							DataStoreParameters newparams = dataManager.createStoreParameters(provName.get(i));

							((FilesystemStoreParameters)newparams).setFile(params.getFile());

							prov = dataManager.createProvider(storeServices, newparams);

						}

					}

				}

			}

		}

		if(prov != null && prov instanceof RasterProvider) {

			if(((RasterProvider)prov).isRotated())

				throw new InitializeException("Rotation not supported tiling files", new Throwable());

			return (RasterProvider)prov;

		}

		return null;

	}

	/**

	 * Gets the internal provider used to feed the TileProvider

	 * @return

	 */

	public RasterProvider getInternalProvider() {

		return provider;

	}

	public Image getImageLegend() {

		return provider.getImageLegend();

	}

	public ColorInterpretation getColorInterpretation() {

		return provider.getColorInterpretation();

	}

	public String getFileSuffix() {

		try {

			return provider instanceof RemoteRasterProvider ? provider.getFileSuffix() : "tif";

		} catch(Throwable e) {

			//if wmts doesn't exists in the classpath

			return "tif";

		}

	}

	public File getRMFFile() {

		TileCacheManager  manager = TileCacheLocator.getManager();

		TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

		String metadataDir = tiledLayer.getBaseLayerDirectory().substring(0, tiledLayer.getBaseLayerDirectory().lastIndexOf(File.separator) + 1) +

				  			tileCache.getConfigurationDirectory();

		File metadaDirFile = new File(metadataDir);

		if(!metadaDirFile.exists())

			metadaDirFile.mkdir();

		String path = metadataDir + File.separator + tiledLayer.getID() + ".rmf";

		try {

            if (!new File(path).exists() && provider != null && provider.getRMFFile() != null

                && provider.getRMFFile().exists()) {

                RasterLocator.getManager().getFileUtils().copyFile(provider.getRMFFile().getAbsolutePath(), path);

            }

			if(provider != null && provider.getColorTable() != null) {

				ColorTable colorTable = provider.getColorTable();

				RasterLocator.getManager().getProviderServices().saveObjectToRmfFile(path, ColorTable.class, colorTable);

			}

		} catch (LocatorException e) {

			logger.info("No se ha podido copiar el fichero RMF a la capa tileada", e);

		} catch (FileNotFoundException e) {

			logger.info("No se ha podido copiar el fichero RMF a la capa tileada", e);

		} catch (IOException e) {

			logger.info("No se ha podido copiar el fichero RMF a la capa tileada", e);

		} catch (RmfSerializerException e) {

			logger.info("No se ha podido copiar la tabla de color a la capa tileada", e);

		}

		return new File(path);

	}

	public TileProvider() throws NotSupportedExtensionException {

		super();

	}

	public void registerTileProviderFormats(Class<RasterProvider> c) {

	}

	/**

	 * Assigns the provider associated to this tile server

	 * @param prov

	 * @throws NotSupportedExtensionException

	 */

	public void setProvider(RasterProvider prov) throws InitializeException  {

		this.provider = prov;

		init(getDataStoreParameters(), getStoreServices());

	}

	public TileProvider(TileDataParametersImpl params,

			DataStoreProviderServices storeServices) throws InitializeException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		if(!params.isSecondLevelCache()) {

			try {

				provider = loadProvider(params, storeServices);

			} catch (ProviderNotRegisteredException e) {

				throw new InitializeException("Provider not registered", e);

			}

			init(params, storeServices);

			if(provider.getFileSizeByProvider() != null && provider.getFileSizeByProvider().length > 0)

				fileSize = provider.getFileSizeByProvider()[0];

		}

	}

	/**

	 * Creates the second level cache if the client has set a <code>TileServer</code> and the

	 * <code>CacheStruct</code> is different that the old one.

	 * <UL>

	 * <LI>First level cache without TileServer from the client: do nothing</LI>

	 * <LI>First level cache with TileServer from the client and the structure is

	 * different to the old one: Builds a second level TileProvider</LI>

	 * <LI>First level cache with TileServer from the client and the structure is

	 * equal to the old one: do nothing</LI>

	 * <LI>Second level cache: sets the TileServer</LI>

	 * </UL>

	 * @param params

	 * @param storeServices

	 * @throws NotSupportedExtensionException

	 */

	/*private void createsSecondLevelCache(TileDataParametersImpl params) throws NotSupportedExtensionException {

		//Se obtiene el TileServer que haya pasado el cliente en los par?metros si ha pasado alguno.

		TileServer tileServer = params.getTileServer();

		//Se obtiene el CacheStruct y se compara con el del provider

		CacheStruct cacheStruct = null;

		if(tileServer != null)

			cacheStruct = tileServer.getStruct();

		if(params.isSecondLevelCache()) { //Cache de segundo nivel

			this.secondLevelTileServer = tileServer;

		} else if(cacheStruct != null && !provider.getTileServer().getStruct().compare(cacheStruct)) { //Cache de primer nivel

			//Si son distintos habr? que crear una cach? de segundo nivel por lo que creamos un nuevo TileProvider

			//que tenga como par?metro el provider viejo

			TileDataParametersImpl par = new TileDataParametersImpl();

			par.setDataParameters(provider.getDataParameters());

			par.setTileServer(tileServer);

			par.setSecondLevelCache(true);

			TileProvider newProvider = new TileProvider(par, null);

			newProvider.setProvider(this.provider);

			//Al TileProvider actual se le asigna como provider el TileProvider creado

			this.provider = newProvider;

		}

	}*/

	/**

	 * Crea las referencias al fichero y carga

	 * las estructuras con la informaci?n y los metadatos.

	 * @param proj Proyecci?n

	 * @param param Parametros de carga

	 * @throws NotSupportedExtensionException

	 */

	public void init (DataStoreParameters params,

			DataStoreProviderServices storeServices) throws InitializeException  {

		setParam(storeServices, params);

		open = true;

		calculateDataType();

		calculateBandCount();

		calculateColorInterpretation();

		calculateTransparency();

		setColorTable(provider.getColorTable());

		noData = provider.getNoDataValue();

		uri = provider.getURIOfFirstProvider();

		proj = provider.getProjection();

		ownTransformation = provider.getAffineTransform();

		externalTransformation = (AffineTransform)ownTransformation.clone();

		createTiledLayer();

		//Force to deletes the layer if the flag is to true

		if(tiledLayer != null) {

			if(param instanceof TileDataParameters) {

				if(((TileDataParameters)param).isDeletingCache()) {

					TileCacheManager  manager = TileCacheLocator.getManager();

					TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

					tileCache.removeLayer(tiledLayer);

					((TileDataParameters)param).deleteCache(false);

				}

			}

		}

		if(provider instanceof RemoteRasterProvider)

			stats = new RemoteDataStoreStatistics(provider);

	}

	/**

	 * Calculates the data type of this provider

	 * @return

	 */

	public void calculateDataType() {

		int[] datatype = null;

		if(provider.getDataType()[0] == Buffer.TYPE_BYTE && provider.getBandCount() == 3)

			datatype = new int[provider.getBandCount() + 1];

		else

			datatype = new int[provider.getBandCount()];

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

			datatype[i] = provider.getDataType()[i];

		}

		if(provider.getDataType()[0] == Buffer.TYPE_BYTE && provider.getBandCount() == 3)

			datatype[datatype.length - 1] = Buffer.TYPE_BYTE;

		setDataType(datatype);

	}

	/**

	 * Calculates the number of bands

	 */

	public void calculateBandCount() {

		bandCount = provider.getBandCount();

		if(provider.getDataType()[0] == Buffer.TYPE_BYTE && provider.getBandCount() == 3)

			bandCount ++;

	}

	/**

	 * Calculates the color interpretation

	 */

	public void calculateColorInterpretation() {

		ColorInterpretation ci = provider.getColorInterpretation();

		if(ci != null) {

			if(ci.isRGB() || ci.isBGR()) {

				ci = DataStoreColorInterpretation.createRGBAInterpretation();

			} else

				ci = ci.cloneColorInterpretation();

		} else {

			if(provider.getDataType()[0] == Buffer.TYPE_BYTE) {

				if(provider.getBandCount() == 3)

					ci = DataStoreColorInterpretation.createRGBAInterpretation();

				else

					ci = DataStoreColorInterpretation.createDefaultInterpretation(getBandCount());

			} else {

				if(getBandCount() == 1)

					ci = DataStoreColorInterpretation.createGrayInterpretation();

				else

					ci = DataStoreColorInterpretation.createDefaultInterpretation(getBandCount());

			}

		}

		super.setColorInterpretation(ci);

	}

	public void calculateTransparency() {

		if(provider.getTransparency() != null)

			transparency = provider.getTransparency().cloneTransparency();

		else

			transparency = new DataStoreTransparency(getColorInterpretation());

		if(getColorInterpretation() != null) {

			transparency.setColorInterpretation(getColorInterpretation());

			transparency.setTransparencyBand(getColorInterpretation().getAlphaBand());

			transparency.activeTransparency();

		}

	}

	/**

	 * Creates a new tiled layer if this hasn't been created yet or the ID has changed.

	 * An ID could changed because the file type has changed when the user uses WMTS properties.

	 */

	private void createTiledLayer() {

		TileCacheManager  manager = TileCacheLocator.getManager();

		TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

		TiledLayer newLayer = tileCache.createLayer(provider.getTileServer(), TileCacheLibrary.DEFAULT_STRUCTURE);

		if(tiledLayer == null || newLayer.getID().compareTo(tiledLayer.getID()) != 0)

			tiledLayer = newLayer;

	}

	public void reload() {

		try {

			loadFromRmf(getRmfBlocksManager());

			calculateColorInterpretation();

			calculateTransparency();

		} catch (ParsingException e) {

			logger.debug("No se ha podido leer el RMF", e);

		}

	}

	public int getZoomLevels() {

		if(provider.getTileServer() != null)

			return provider.getTileServer().getStruct().getNumberOfLevels();

		return 0;

	}

	public int getNearestLevel(double pixelSize) {

		double[] pixelSizes = getPixelSizeByLevel();

		for (int i = 0; i < pixelSizes.length - 1; i++) {

			if(pixelSize <= pixelSizes[i] && pixelSize > pixelSizes[i + 1]) {

				return i;

			}

		}

		if(pixelSize < pixelSizes[getZoomLevels() - 1])

			return getZoomLevels() - 1;

		return 0;

	}

	/**

	 * Returns a list of pixel sizes by level

	 * @return

	 */

	public double[] getPixelSizeByLevel() {

		double[] list = new double[getZoomLevels()];

		CacheStruct struct = provider.getTileServer().getStruct();

		for (int i = 0; i < struct.getNumberOfLevels(); i++) {

			list[i] = math.adjustDouble(struct.getPixelSizeByLevel(i));

		}

		return list;

	}

	public Extent getCoordsInTheNearestLevel(Extent extent, int w, int h) {

		double[] pixelSizes = getPixelSizeByLevel();

		double currentPixelSize = extent.width() / (double)w;

		int level = 0;

		for (int i = 0; i < (pixelSizes.length - 1); i++) {

			if(currentPixelSize < pixelSizes[i] && currentPixelSize >= pixelSizes[i + 1]) {

				level = i + 1;