gvSIG data provider for OpenStreetMap (raster)

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.downloader;

import java.io.BufferedOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStreamWriter;

import java.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

import org.gvsig.compat.net.ICancellable;

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

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

import org.gvsig.raster.impl.provider.tile.BaseTileDownloader;

import org.gvsig.raster.osm.io.OSMDataParameters;

import org.gvsig.raster.osm.io.OSMProvider;

/** 

 * Tile getter for Open Street Map

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

 */

public class TileDownloaderForOSM extends BaseTileDownloader {

	private String server   = null;

	private String suffix   = null;

	public TileDownloaderForOSM(OSMProvider prov, 

			int tileSize) {

		super(prov, tileSize, tileSize);

		server = ((OSMDataParameters)prov.getDataParameters()).getURI();

		suffix = ((OSMDataParameters)prov.getDataParameters()).getTileSuffix();

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.provider.Downloader#getTile(org.gvsig.raster.cache.tile.Tile)

	 */

	public synchronized Tile downloadTile(Tile tile) throws TileGettingException {

		int level = tile.getLevel();

		int y = tile.getRow();

		int x = tile.getCol();

		String url = server + 

					(server.endsWith(File.separator) ? "" : File.separator) + 

					level + File.separator + 

					x + File.separator + 

					y + "." + suffix;

		try {

			//System.out.println("====>>>>" + url);

			downloadFile(new URL(url), tile.getFile(), tile.getCancelled());

		} catch (MalformedURLException e) {

			throw new TileGettingException(e);

		}

		readTileFromDisk(tile);

		return tile;

	}

	 public synchronized void downloadFile(URL url, File file, ICancellable cancel) throws TileGettingException {

	    	int IO_BUFFER_SIZE = 8 * 1024;

			int timeout =  30000;

			DataOutputStream dos;

			try {

				DataInputStream is;

				OutputStreamWriter os = null;

				HttpURLConnection connection = null;

				connection = (HttpURLConnection)url.openConnection();

				connection.setConnectTimeout(timeout);

				is = new DataInputStream(url.openStream());

				dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(file)));

				byte[] buffer = new byte[IO_BUFFER_SIZE];

				int read;

				while ((read = is.read(buffer)) != -1) {

					dos.write(buffer, 0, read);

					if(cancel != null && cancel.isCanceled())

						return;

				}

				if(os != null) {

					os.close();

				}

				dos.close();

				is.close();

				is = null;

				dos = null;

			} catch (Exception e) {

				throw new TileGettingException(e);

			}

	    }

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.downloader;

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

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

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

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

import org.gvsig.raster.osm.cachestruct.OSMCacheStruct;

import org.gvsig.raster.osm.io.OSMDataParameters;

import org.gvsig.raster.osm.io.OSMProvider;

/** 

* Data server for the tile cache in a OSMProvider 

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

*/

public class OSMTileServer implements TileServer {

	private CacheStruct                struct               = null;

	private Downloader                 downloader           = null;

	private OSMProvider                provider             = null;

	private String                     suffix               = null;

	private int                        tileSize             = 256;

	private int                        levels               = 0;

	/**

	 * Creates a OSMTileServer

	 * @param prov

	 * @param suffix

	 * 			it depends on the layer

	 * @param levels

	 * 			it depends on the layer

	 */

	public OSMTileServer(OSMProvider prov, String suffix, int levels) {

		this.provider = prov;

		this.suffix = suffix;

		this.levels = levels;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.provider.TileServer#getDownloader()

	 */

	public Downloader getDownloader() {

		if(downloader == null) {

			downloader = new TileDownloaderForOSM(provider, getStruct().getTileSizeByLevel(0)[0]);

		}

		return downloader;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.provider.TileServer#getStruct()

	 */

	public CacheStruct getStruct() {

		if(struct == null) {

			struct = new OSMCacheStruct(levels, 

					tileSize, 

					tileSize, 

					((OSMDataParameters)provider.getDataParameters()).getOSMLayerName(), 

					RasterLibrary.pathTileCache, 

					suffix, 

					0);

		}

		return struct;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.provider.TileServer#setStruct(org.gvsig.raster.cache.tile.provider.CacheStruct)

	 */

	public void setStruct(CacheStruct struct) {

		//La structura de cache es proporcionada por el servidor

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.provider.TileServer#getFileSuffix()

	 */

	public String getFileSuffix() {

		return suffix;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.provider.TileServer#setFileExtension(java.lang.String)

	 */

	public void setFileSuffix(String extension) {

		this.suffix = extension;

	}

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.io;

public class OSMServerExplorer {

	public static final String NAME       = OSMProvider.NAME;

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.io;

import java.awt.geom.AffineTransform;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

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

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

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

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

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

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

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.provider.TileListener;

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

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

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

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

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.osm.cachestruct.OSMCacheStruct;

import org.gvsig.raster.osm.downloader.OSMTileServer;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.TaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Data provider for OSM servers

 *

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

 */

public class OSMProvider extends DefaultRasterProvider {

	public static String                     NAME                     = "OSM Raster";

	public static String                     DESCRIPTION              = "OSM Raster Server";

	public final String                      METADATA_DEFINITION_NAME = NAME;

	private Extent                           viewRequest              = null;

	private TileServer                       tileServer               = null;

	private boolean                          open                     = false;

    private DataStoreTransparency            fileTransparency         = null;

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

	public static void register() {

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

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

			dataman.registerStoreProvider(NAME,

					OSMProvider.class, OSMDataParametersImpl.class);

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	public OSMProvider() {

	}

	/**

	 * Opens the dataset.

	 * @param proj Projection

	 * @param fName File name

	 * @throws NotSupportedExtensionException

	 */

	public OSMProvider(String params) throws NotSupportedExtensionException, OpenException {

		super(params);

	}

	public OSMProvider (OSMDataParametersImpl params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Build file references

	 * @param proj Projection

	 * @param param Load parameters

	 * @throws NotSupportedExtensionException

	 */

	public void init (OSMDataParametersImpl params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		setParam(storeServices, params);

		setDataType(new int[]{Buffer.TYPE_BYTE, Buffer.TYPE_BYTE, Buffer.TYPE_BYTE, Buffer.TYPE_BYTE});

		bandCount = 4;

		super.init();

		fileSize = (long)(getWidth() * getHeight() * 3);

		open = true;

	}

	public IProjection getProjection() {

		if(proj == null) {

			try {

				proj = CRSFactory.getCRS("EPSG:3785");

			} catch(Exception e) {

				logger.info("Projection not loaded", e);

			}

		}

		return proj;

	}

	/**

	 * Gets the bounding box in world coordinates. 

	 * @return Extent

	 */

	public Extent getExtent() {

		return ((OSMCacheStruct)getTileServer().getStruct()).getWorldExtent();

	}

	/**

	 * Reloads metadata using the selected grid

	 */

	@SuppressWarnings("unused")

	private void reloadMetadataFromGrid() {

		//wktProjection = null;

		//CrsWkt crs = new CrsWkt(wktProjection);

		//IProjection proj = CRSFactory.getCRS("EPSG:23030");

		/*ownTransformation = new AffineTransform(

				scaleX, 0, 

				0, -scaleY, 

				pRect.getMinX(), 

				pRect.getMaxY());*/

		externalTransformation = (AffineTransform)ownTransformation.clone();

		bandCount = 3; 

		setDataType(new int[]{Buffer.TYPE_BYTE, Buffer.TYPE_BYTE, Buffer.TYPE_BYTE});

	}

	public RasterProvider load() {

		return this;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

	}

	public String translateFileName(String fileName) {

		return fileName;

	}

	/**

	 * Asigna el extent de la vista actual. existe un fichero .rmf debemos hacer una transformaci�n

	 * de la vista asignada ya que la petici�n viene en coordenadas del fichero .rmf y la vista (v)

	 * ha de estar en coordenadas del fichero.

	 */

	public void setView(Extent e) {

		viewRequest = new ExtentImpl(e);

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		int n = getTileServer().getStruct().getNumberOfLevels() - 1;

		return getExtent().width() / getTileServer().getStruct().getPixelSizeByLevel(n);

	}

	public double getHeight() {

		int n = getTileServer().getStruct().getNumberOfLevels() - 1;

		return getExtent().width() / getTileServer().getStruct().getPixelSizeByLevel(n);

	}

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

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

		return null;

	}

	public Object getData(int x, int y, int band)throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		return null;

	}

	public int getBlockSize(){

		return 0;

	}

	public DataStoreTransparency getTransparency() {

		if(fileTransparency == null)

			fileTransparency = new DataStoreTransparency();

		return fileTransparency;

	}

	/**

	 * Informa de si el driver ha supersampleado en el �ltimo dibujado. Es el driver el que colocar�

	 * el valor de esta variable cada vez que dibuja.

	 * @return true si se ha supersampleado y false si no se ha hecho.

	 */

	public boolean isSupersampling() {

		return false;

	}

	public void setAffineTransform(AffineTransform t){

		super.setAffineTransform(t);

	}

	public int getOverviewCount(int band) throws BandAccessException, RasterDriverException {

		if(band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

	public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException {

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

	public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException {

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

	public boolean isOverviewsSupported() {

		return true;

	}

	public boolean isReproyectable() {

		return true;

	}

	public String getName() {

		return NAME;

	}

	public ColorInterpretation getColorInterpretation() {

		if(super.getColorInterpretation() == null) {

			super.setColorInterpretation(DataStoreColorInterpretation.createRGBInterpretation());

		}

		return super.getColorInterpretation();

	}

	public void setStatus(RasterProvider provider) {

		if(provider instanceof OSMProvider) {

			//Not implemented yet

		}

	}

	public boolean isTimeSupported() {

		return true;

	}

	public TileServer getTileServer() {

		if(tileServer == null)

			tileServer = new OSMTileServer(this, 

					((OSMDataParameters)param).getTileSuffix(), 

					((OSMDataParameters)param).getNumberOfLevels());

		return tileServer;

	}

	@Override

	public void getWindow(Extent ex, int bufWidth, int bufHeight,

			BandList bandList, TileListener listener, TaskStatus taskStatus)

			throws ProcessInterruptedException, RasterDriverException {

	}

	@Override

	public Buffer getWindow(Extent extent, BandList bandList,

			Buffer rasterBuf, TaskStatus status)

			throws ProcessInterruptedException, RasterDriverException {

		return null;

	}

	@Override

	public Buffer getWindow(double x, double y, double w, double h,

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent,

			TaskStatus status) throws ProcessInterruptedException,

			RasterDriverException {

		return null;

	}

	@Override

	public Buffer getWindow(Extent extent, int bufWidth, int bufHeight,

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent,

			TaskStatus status) throws ProcessInterruptedException,

			RasterDriverException {

		return null;

	}

	@Override

	public Buffer getWindow(int x, int y, int w, int h, BandList bandList,

			Buffer rasterBuf, TaskStatus status)

			throws ProcessInterruptedException, RasterDriverException {

		return null;

	}

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.io;

/**

 * Parameters for the WMS provider

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

 */

public interface OSMDataParameters {

	public void setURI(String string);

	public String getURI();

	public int getWidth();

	public int getHeight();

	public void setWidth(int w);

	public void setHeight(int h);

	public String getOSMLayerName();

	public void setOSMLayerName(String name);

	public int getNumberOfLevels();

	public void setNumberOfLevels(int levels);

	public String getTileSuffix();

	public void setTileSuffix(String suffix);

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.io;

import java.util.Hashtable;

import java.util.Map;

/**

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

 */

public class OSMException extends Exception {

    private static final long serialVersionUID = 1476084093500156070L;

    private String            wmtsCode         = null;

    protected String          formatString     = null;

    protected String          messageKey       = null;

    protected long            code             = 0;

    public OSMException() {		

        init();			

    }	

    public OSMException(Throwable cause) {	

    	super(cause);

        init();	

        initCause(cause);

    }

    public OSMException(String msg, Throwable cause) {	

    	super(msg, cause);

        init();	

        this.formatString = msg;

    }

    public OSMException(String wfsCode,String message) {		

        init();	

        formatString = message;

        this.wmtsCode = wfsCode;

    }	

    public OSMException(String message) {        

        init(); 

        formatString = message;       

    }   

	@SuppressWarnings("unchecked")

	protected Map values() {		

        Hashtable params;

        params = new Hashtable();		

        return params;

    }

    public void init() {

        messageKey = "wmts_exception";

        formatString = "WMTS Exception";

        code = serialVersionUID;

    }

    /**

     * @return Returns the wfsCode.

     */

    public String getWfsCode() {

        return wmtsCode;

    }	

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.io;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

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 OSM provider

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

 */

public class OSMDataParametersImpl extends AbstractRasterDataParameters implements OSMDataParameters {

	public static final String            PARAMETERS_DEFINITION_NAME = "OSMRasterDataParameters";

	private static DynClass               DYNCLASS                   = null;

	private DelegatedDynObject            delegatedDynObject         = null;

	private static final String           FIELD_WIDTH                = "width";

	private static final String           FIELD_HEIGHT               = "height";

	private static final String           FIELD_MAX_RES_LEVEL        = "maxResolutionLevel";

	private static final String           FIELD_NAME                 = "name";

	private static final String           FIELD_SUFFIX               = "suffix";

	public OSMDataParametersImpl() {

		super();

		initialize();

	}

	protected void initialize() {

		delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						DYNCLASS);

	}

	@SuppressWarnings("deprecation")

	public static void registerDynClass() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass;

		DynField field;

		if(dynman == null)

			return;

		if (DYNCLASS == null) {

			dynClass = AbstractRasterDataParameters.registerDynClass(PARAMETERS_DEFINITION_NAME);

			//dynClass = dynman.add(AbstractRasterDataParameters.DYNCLASS_NAME);

			field = dynClass.addDynField(FIELD_WIDTH);

			field.setTheTypeOfAvailableValues(DynField.ANY);

			field.setDescription("Width");

			field.setType(DataTypes.INT);

			field.setMandatory(false);

			field = dynClass.addDynField(FIELD_HEIGHT);

			field.setTheTypeOfAvailableValues(DynField.ANY);

			field.setDescription("Height");

			field.setType(DataTypes.INT);

			field.setMandatory(false);

			field = dynClass.addDynField(FIELD_MAX_RES_LEVEL);

			field.setTheTypeOfAvailableValues(DynField.ANY);

			field.setDescription("Maximun levels of resolution");

			field.setType(DataTypes.INT);

			field.setMandatory(false);

			field = dynClass.addDynFieldString(FIELD_NAME);

			field.setDescription("Layer name");

			field.setClassOfValue(String.class);

			field.setMandatory(false);

			field = dynClass.addDynFieldString(FIELD_SUFFIX);

			field.setDescription("Tile suffix");

			field.setClassOfValue(String.class);

			field.setMandatory(false);

			DYNCLASS = dynClass;

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.DataStoreParameters#getDataStoreName()

	 */

	public String getDataStoreName() {

		return OSMProvider.NAME;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.DataStoreParameters#getDescription()

	 */

	public String getDescription() {

		return OSMProvider.DESCRIPTION;

	}

	public static void registerPersistence() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

		if( definition == null ) {

			definition = manager.addDefinition(

					OSMDataParametersImpl.class,

					"OSMDataParameters_Persistent",

					"OSM DataParameters Persistency",

					null, 

					null

			);

			AbstractRasterDataParameters.registerPersistence(definition);

			/*definition.addDynFieldString(FIELD_VARIABLE).setMandatory(false);

			definition.addDynFieldInt(FIELD_LEVEL).setMandatory(false);

			definition.addDynFieldInt(FIELD_TIME).setMandatory(false);

			definition.addDynFieldString(FIELD_XDIM).setMandatory(false);

			definition.addDynFieldString(FIELD_YDIM).setMandatory(false);*/

		}

	}

	@Override

	public void saveToState(PersistentState state) throws PersistenceException {

		super.saveToState(state);

		/*state.set(FIELD_VARIABLE, getStringVariable());	

		state.set(FIELD_LEVEL, getFieldLevel());

		state.set(FIELD_TIME, getFieldTime());

		state.set(FIELD_XDIM, getXDimVariable());

		state.set(FIELD_YDIM, getYDimVariable());*/

	}

	@Override

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		super.loadFromState(state);

		/*setFieldVariable(state.getString(FIELD_VARIABLE));

		setFieldTime(state.getInt(FIELD_TIME));

		setFieldLevel(state.getInt(FIELD_LEVEL));

		xDimVariable = state.getString(FIELD_XDIM);

		yDimVariable = state.getString(FIELD_YDIM);*/

	}

	@Override

	protected DelegatedDynObject getDelegatedDynObject() {

		return delegatedDynObject;

	}

	public boolean isOverridingHost() {

		return false;

	}

	public void setOverrideHost(boolean over) {

	}

	public void setWidth(int w) {

		this.setDynValue(FIELD_WIDTH, new Integer(w));

	}

	public void setHeight(int h) {

		this.setDynValue(FIELD_HEIGHT, new Integer(h));

	}

	public int getWidth() {

		Integer b = (Integer)getDynValue(FIELD_WIDTH);

		if(b != null)

			return ((Integer)b).intValue();

		return 0;

	}

	public int getHeight() {

		Integer b = (Integer)getDynValue(FIELD_HEIGHT);

		if(b != null)

			return ((Integer)b).intValue();

		return 0;

	}

	public String getOSMLayerName() {

		String b = (String)getDynValue(FIELD_NAME);

		if(b != null)

			return b;

		return null;

	}

	public void setOSMLayerName(String name) {

		this.setDynValue(FIELD_NAME, name);

	}

	public int getNumberOfLevels() {

		Integer b = (Integer)getDynValue(FIELD_MAX_RES_LEVEL);

		if(b != null)

			return ((Integer)b).intValue();

		return 0;

	}

	public void setNumberOfLevels(int levels) {

		this.setDynValue(FIELD_MAX_RES_LEVEL, new Integer(levels));

	}

	public String getTileSuffix() {

		String b = (String)getDynValue(FIELD_SUFFIX);

		if(b != null)

			return b;

		return null;

	}

	public void setTileSuffix(String suffix) {

		this.setDynValue(FIELD_SUFFIX, suffix);

	}

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.io;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 *

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

 */

public class DefaultOSMIOLibrary extends AbstractLibrary {	

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		OSMDataParametersImpl.registerDynClass();

		OSMProvider.register();

		OSMDataParametersImpl.registerPersistence();

	}

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.cachestruct;

/**

 * Description of a tile matrix

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

 */

public class TileMatrix {

    private double                      scaleXDenominator    = 0;

    private double                      scaleYDenominator    = 0;

    private double[]                    topLeftCorner       = null;

    private int                         tileWidth           = 0;

    private int                         tileHeight          = 0;

    private long                        matrixWidth         = 0;

    private long                        matrixHeight        = 0;

    private static final double         MTS_X_GRADO         = 111319.490793274;

	public double getScaleXDenominator() {

		return scaleXDenominator;

	}

	public void setScaleXDenominator(double scaleXDenominator) {

		this.scaleXDenominator = scaleXDenominator;

	}

	public double getScaleYDenominator() {

		return scaleYDenominator;

	}

	public void setScaleYDenominator(double scaleYDenominator) {

		this.scaleYDenominator = scaleYDenominator;

	}

	public int getTileWidth() {

		return tileWidth;

	}

	public void setTileWidth(int tileWidth) {

		this.tileWidth = tileWidth;

	}

	public int getTileHeight() {

		return tileHeight;

	}

	public void setTileHeight(int tileHeight) {

		this.tileHeight = tileHeight;

	}

	public long getMatrixWidth() {

		return matrixWidth;

	}

	public void setMatrixWidth(long matrixWidth) {

		this.matrixWidth = matrixWidth;

	}

	public long getMatrixHeight() {

		return matrixHeight;

	}

	public void setMatrixHeight(long matrixHeight) {

		this.matrixHeight = matrixHeight;

	}

	public double[] getTopLeftCorner() {

		return topLeftCorner;

	}

	public void setTopLeftCorner(double[] topLeftCorner) {

		this.topLeftCorner = topLeftCorner;

	}

    /**

     * Gets the width in meters of a tile

     * @param projected

     * @return

     */

    public double getWidthMtsTile(boolean projected) {

    	if(!projected) {

    		return (scaleXDenominator * tileWidth * 0.28) / (MTS_X_GRADO * 1000);

    	} else {

    		return (scaleXDenominator * tileWidth * 0.28) / 1000;

    	}

    }

    /**

     * Gets the height in meters of a tile

     * @param projected

     * @return

     */

    public double getHeightMtsTile(boolean projected) {

    	if(!projected) {

    		return (scaleYDenominator * tileHeight * 0.28) / (MTS_X_GRADO * 1000);

    	} else {

    		return (scaleYDenominator * tileHeight * 0.28) / 1000;

    	}

    }

	public void print() {

		System.out.println("   *****TileMatrix******");

		System.out.println("   scaleXDenominator:" + getScaleXDenominator());

		System.out.println("   scaleYDenominator:" + getScaleYDenominator());

		if(topLeftCorner != null)

			System.out.println("   topLeftCorner:" + topLeftCorner[0] + ", " + topLeftCorner[1]);

		System.out.println("   tileWidth:" + getTileWidth());

		System.out.println("   tileHeight:" + getTileHeight());

		System.out.println("   matrixWidth:" + getMatrixWidth());

		System.out.println("   matrixHeight:" + getMatrixHeight());

	}

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.cachestruct;

import java.awt.geom.Point2D;

/**

 * Limits of a tile matrix

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

 */

public class TileMatrixLimits {

	private TileMatrix             tileMatrix           = null;

	private int                    minTileRow           = 0;

	private int                    maxTileRow           = 0;

	private int                    minTileCol           = 0;

	private int                    maxTileCol           = 0;

	public TileMatrix getTileMatrix() {

		if(tileMatrix == null)

			tileMatrix = new TileMatrix();

		return tileMatrix;

	}

	/**

	 * Gets the upper left corner and the lower right corner of the 

	 * selected tile

	 * @param x X tile position

	 * @param y Y tile position

	 * @return

	 */

	public Point2D[] getTileExtent(int x, int y) {

		double sizeXTile = getTileMatrix().getTileWidth() * getTileMatrix().getScaleXDenominator();

		double sizeYTile = getTileMatrix().getTileWidth() * getTileMatrix().getScaleYDenominator();

		double initX = getTileMatrix().getTopLeftCorner()[0] + (sizeXTile * x);

		double initY = getTileMatrix().getTopLeftCorner()[1] - (sizeYTile * y);

		Point2D[] p = new Point2D[2];

		p[0] = new Point2D.Double(initX, initY);

		p[1] = new Point2D.Double(initX + sizeXTile, initY - sizeYTile);

		return p;

	}

	public int getMinTileRow() {

		return minTileRow;

	}

	public void setMinTileRow(int minTileRow) {

		this.minTileRow = minTileRow;

	}

	public int getMaxTileRow() {

		return maxTileRow;

	}

	public void setMaxTileRow(int maxTileRow) {

		this.maxTileRow = maxTileRow;

	}

	public int getMinTileCol() {

		return minTileCol;

	}

	public void setMinTileCol(int minTileCol) {

		this.minTileCol = minTileCol;

	}

	public int getMaxTileCol() {

		return maxTileCol;

	}

	public void setMaxTileCol(int maxTileCol) {

		this.maxTileCol = maxTileCol;

	}

	public void print() {

		System.out.println("  *****TileMatrixLimits******");

		System.out.println("  MaxTileCol:" + getMaxTileCol());

		System.out.println("  MaxTileRow:" + getMaxTileRow());

		System.out.println("  MinTileCol:" + getMinTileCol());

		System.out.println("  MinTileRow:" + getMinTileRow());

		if(tileMatrix != null)

			tileMatrix.print();

	}

}

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.cachestruct;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.List;

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

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

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

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

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

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

/**

 * Implementation for a structure of a cache

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

 */

public class OSMCacheStruct implements CacheStruct {

    private TileMatrixSet                 tileMatrixSet  = null;

    private ArrayList<TileMatrixLimits>   limits         = null;

    private String                        layerName      = null;

	private Rectangle2D                   worldExtent    = null;

	private String                        fileSuffix     = null;

	private String                        epsg           = null;

	private long                          fileSize       = 0;

	private double                        realPixelSize  = 0;

    public OSMCacheStruct(int levels, 

    		int tilePxWidth,

    		int tilePxHeight,

    		String layerName,

    		String baseDir,

    		String fileSuffix,

    		long size) {

    	this.layerName = layerName;

    	this.fileSuffix = fileSuffix;

    	this.fileSize = size;

    	this.epsg = "EPSG:3857"; //WGS87 Pseudomercator

    	//Coordenadas del mundo en geogr?ficas y planas

    	//worldExtent = new Rectangle2D.Double(-180, -85.0511, 360, 170.1022); // arctan(sin(PI)) = 85.0511

    	//worldExtent = new Rectangle2D.Double(-180, -180, 360, 360);

    	worldExtent = new Rectangle2D.Double(-20037508, -20037508, 40075016, 40075016);

    	double[][] pixelSizeList = buildWorldMatrix(levels, tilePxWidth, tilePxHeight, worldExtent);

        buildLayerMatrix(levels, tilePxWidth, tilePxHeight, worldExtent, pixelSizeList);

    }

    private void buildLayerMatrix(int levels, 

    		int tilePxWidth, 

    		int tilePxHeight,

    		Rectangle2D worldExtent,

    		double[][] pixelSizeList) {

    	limits = new ArrayList<TileMatrixLimits>();

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

    		//Calculo de tiles para ese nivel en la capa actual

    		int minTileCol = 0;

    		int minTileRow = 0;

    		int maxTileCol = (i == 0) ? 0 : (int)Math.pow(2, i) - 1;

    		int maxTileRow = (i == 0) ? 0 : (int)Math.pow(2, i) - 1;

    		TileMatrixLimits limit = new TileMatrixLimits();

    		limit.setMinTileRow(minTileRow);

    		limit.setMinTileCol(minTileCol);

    		limit.setMaxTileRow(maxTileRow);

    		limit.setMaxTileCol(maxTileCol);

    		//Calcula las coordenadas de la esquina superior izquierda del TileMatrixLimits

    		double ulx = worldExtent.getMinX() + (minTileCol * tilePxWidth * pixelSizeList[0][i]);

    		double uly = worldExtent.getMaxY() - (minTileRow * tilePxHeight * pixelSizeList[1][i]);

    		limit.getTileMatrix().setTopLeftCorner(new double[]{ulx, uly});

    		limit.getTileMatrix().setScaleXDenominator(pixelSizeList[0][i]);

    		limit.getTileMatrix().setScaleYDenominator(pixelSizeList[1][i]);

    		limit.getTileMatrix().setTileWidth(tilePxWidth);

    		limit.getTileMatrix().setTileHeight(tilePxHeight);

    		limits.add(limit);

    	}

    }

    private double[][] buildWorldMatrix(int levels, 

    		int tilePxWidth, 

    		int tilePxHeight,

    		Rectangle2D worldExtent) {

    	double[] pixelSizeXList = new double[levels];

    	double[] pixelSizeYList = new double[levels];

    	limits = new ArrayList<TileMatrixLimits>();

    	tileMatrixSet = new TileMatrixSet();

    	tileMatrixSet.setBbox(worldExtent);

    	int nTilesWidth = 0;

    	int nTilesHeight = 0;

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

    		TileMatrix tm = new TileMatrix();

    		tm.setTileWidth(tilePxWidth);

    		tm.setTileHeight(tilePxHeight);

    		nTilesWidth = (i == 0) ? 1 : nTilesWidth * 2;

    		nTilesHeight = (i == 0) ? 1 : nTilesHeight * 2;

    		tm.setMatrixWidth(nTilesWidth);

    		tm.setMatrixHeight(nTilesHeight);

    		if((tilePxWidth * nTilesWidth) != 0)

    			pixelSizeXList[i] = worldExtent.getWidth() / ((long)tilePxWidth * (long)nTilesWidth);

    		else

    			pixelSizeXList[i] = 0;

    		if((tilePxHeight * nTilesHeight) != 0)

    			pixelSizeYList[i] = worldExtent.getHeight() / ((long)tilePxHeight * (long)nTilesHeight);

    		else

    			pixelSizeYList[i] = 0;

    		//System.out.println("-Level:" + i + " " + nTilesWidth + " " + nTilesHeight + " " + pixelSizeList[i]);

    		tm.setScaleXDenominator(pixelSizeXList[i]);

    		tm.setScaleYDenominator(pixelSizeYList[i]);

    		tileMatrixSet.getTileMatrix().add(tm);

    	}

    	double[][] r = new double [2][];

    	r[0] = pixelSizeXList;

    	r[1] = pixelSizeYList;

    	return r;

    }

    public Extent getWorldExtent() {

    	return RasterLocator.getManager().getDataStructFactory().createExtent(worldExtent);

    }

	public int getNumberOfLevels() {

		return tileMatrixSet.getTileMatrix().size();

	}

	public String getLayerName() {

		return layerName;

	}