gvSIG data provider for OpenStreetMap (raster)

org.gvsig.raster.osm.io.DefaultOSMIOLibrary

/* 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.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import org.gvsig.compat.net.ICancellable;

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

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;

/** 

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

	private String slash    = "/";

	public TileDownloaderForOSM(RasterDataStore store, 

			int tileSize) {

		super(store, tileSize, tileSize);

		server = ((OSMDataParameters)store.getParameters()).getURI();

		suffix = ((OSMDataParameters)store.getParameters()).getTileSuffix();

	}

	public synchronized Tile downloadTile(Tile tile) throws TileGettingException {

		int level = tile.getLevel();

		int y = tile.getRow();

		int x = tile.getCol();

		try {

			URI uri = new URI(

					server + 

					(server.endsWith(slash) ? "" : slash) + 

					level + slash + 

					x + slash + 

					y + "." + suffix);

			downloadFile(uri.toURL(), tile.getFile(), tile.getCancelled());

		} catch (MalformedURLException e) {

			throw new TileGettingException(e);

		} catch (URISyntaxException 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;

				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;

				}

				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.fmap.dal.coverage.store.RasterDataStore;

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;

/** 

* 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 RasterDataStore            store                = 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(RasterDataStore store, String suffix, int levels) {

		this.store = store;

		this.suffix = suffix;

		this.levels = levels;

	}

	public Downloader getDownloader() {

		if(downloader == null) {

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

		}

		return downloader;

	}

	public CacheStruct getStruct() {

		if(struct == null) {

			struct = new OSMCacheStruct(levels, 

					tileSize, 

					tileSize, 

					((OSMDataParameters)store.getParameters()).getOSMLayerName(), 

					RasterLibrary.pathTileCache, 

					suffix, 

					0);

		}

		return struct;

	}

	public void setStruct(CacheStruct struct) {

		//La structura de cache es proporcionada por el servidor

	}

	public String getFileSuffix() {

		return suffix;

	}

	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;

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 {

		OSMProvider.register();

		OSMDataParametersImpl.registerDynClass();

	}

}

/* 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.List;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

public class OSMServerExplorer {

	public static final String NAME       = OSMProvider.NAME;

	public String getProviderName() {

		return OSMProvider.NAME;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public List<?> list() throws DataException {

		return null;

	}

	public List<?> list(int mode) throws DataException {

		return null;

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public void remove(DataStoreParameters parameters) throws DataException {

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	public DataServerExplorerParameters getParameters() {

		return null;

	}

	public List<?> getDataStoreProviderNames() {

		return null;

	}

	public void dispose() {

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public DataStoreParameters getStoredParameters() {

		return null;

	}

	public void connect(ICancellable cancellable) throws ConnectException {

	}

	public boolean isHostReachable(int timeout) {

		return false;

	}

	public boolean isHostReachable() {

		return isHostReachable(RasterDataServerExplorer.TIME);

	}

}

/* 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.Extent;

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Data provider for OSM servers

 *

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

 */

public class OSMProvider extends AbstractRasterProvider {

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

		Extent ext = getExtent();

		ownTransformation = new AffineTransform(

				ext.width() / getWidth(), 0, 

				0, -(ext.height() / getHeight()), 

				getExtent().getMin().getX(), 

				getExtent().getMax().getY());

		externalTransformation = (AffineTransform)ownTransformation.clone();

		open = true;

	}

	public IProjection getProjection() {

		if(proj == null) {

			try {

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

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

	}

	public NoData getNoDataValue() {

		NoData nodata = super.getNoDataValue();

		if(nodata != null)

			nodata.setNoDataTransparent(false);

		return noData;

	}

	/**

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

	}

	/**

	 * 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 getProviderName() {

		return NAME;

	}

        public String getName() {

            return this.getParameters().getOSMLayerName();

        }

	public OSMDataParameters getParameters() {

		return (OSMDataParameters)this.param;

	}

	public DataStoreTransparency getTransparency() {

		if(fileTransparency == null)

			fileTransparency = new DataStoreTransparency(getColorInterpretation());

		return fileTransparency;

	}

	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 boolean isTiled() {

		return true;

	}

	public TileServer getTileServer() {

		if(tileServer == null) {

			DefaultRasterStore store = new DefaultRasterStore();

			store.setProvider(this);

			tileServer = new OSMTileServer(store, 

					((OSMDataParameters)param).getTileSuffix(), 

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

		}

		return tileServer;

	}

	@Override

	public void loadBuffer(SpiRasterQuery query)

			throws ProcessInterruptedException, RasterDriverException {

	}

}

/* 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.fmap.dal.coverage.store.RasterDataServerExplorer;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

/**

 * Parameters for OSM provider

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

 */

public class OSMDataParametersImpl extends AbstractRasterDataParameters implements OSMDataParameters {

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

		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(registerDynClass());

	}

	public static DynStruct registerDynClass() {

		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.registerDynClass(definition);

		definition.addDynFieldInt(FIELD_MAX_RES_LEVEL)

		.setDescription("Maximun levels of resolution")

		.setMandatory(false);

		definition.addDynFieldInt(FIELD_WIDTH)

		.setDescription("Width")

		.setMandatory(false);

		definition.addDynFieldInt(FIELD_HEIGHT)

		.setDescription("Height")

		.setMandatory(false);

		definition.addDynFieldString(FIELD_NAME)

		.setDescription("Layer name")

		.setMandatory(false);		

		definition.addDynFieldString(FIELD_SUFFIX)

		.setDescription("Field suffix")

		.setMandatory(false);

		return definition;

	}

	public void assignFields(RasterDataParameters par, RasterDataServerExplorer explorer) {

		super.assignFields(par, explorer);

		OSMDataParameters p = null;

		if(par instanceof OSMDataParameters)

			p = (OSMDataParameters)par;

		else

			return;

		setTileSuffix(p.getTileSuffix());

		setOSMLayerName(p.getOSMLayerName());

		setWidth(p.getWidth());

		setHeight(p.getHeight());

		setNumberOfLevels(p.getNumberOfLevels());

	}

	public String getDataStoreName() {

		return OSMProvider.NAME;

	}

	public String getDescription() {

		return OSMProvider.DESCRIPTION;

	}

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

	}

	public String getServerURL() {

		return layerName;

	}

	public String getFileSuffix() {

		return fileSuffix;

	}

	public int[] getTileSizeByLevel(int level) {

		return new int[] {

			tileMatrixSet.getTileMatrix().get(level).getTileWidth(),

			tileMatrixSet.getTileMatrix().get(level).getTileHeight()

		};

	}

	public double[] getTileSizeInRealCoordsByLevel(int level) {

		return new double[] {

				tileMatrixSet.getTileMatrix().get(level).getScaleXDenominator() * tileMatrixSet.getTileMatrix().get(level).getTileWidth(),

				tileMatrixSet.getTileMatrix().get(level).getScaleYDenominator() *  tileMatrixSet.getTileMatrix().get(level).getTileHeight()

			};

	}

	public int getLayerWidthOfTileMatrixByLevel(int level) {

		TileMatrixLimits l = limits.get(level);

		return l.getMaxTileRow() - l.getMinTileRow();

	}

	public int getLayerHeightOfTileMatrixByLevel(int level) {

		TileMatrixLimits l = limits.get(level);

		return l.getMaxTileCol() - l.getMinTileCol();

	}

	public int getLayerInitXTilePositionByLevel(int level) {

		TileMatrixLimits l = limits.get(level);

		return l.getMinTileCol();

	}

	public int getLayerInitYTilePositionByLevel(int level) {

		TileMatrixLimits l = limits.get(level);

		return l.getMinTileRow();

	}

	public long getWorldHeightOfTileMatrixByLevel(int level) {

		return tileMatrixSet.getTileMatrix().get(level).getMatrixWidth();

	}

	public long getWorldWidthOfTileMatrixByLevel(int level) {

		return tileMatrixSet.getTileMatrix().get(level).getMatrixHeight();

	}

	public double getPixelSizeByLevel(int level) {

		if(level < 0)

			return realPixelSize;

		return tileMatrixSet.getTileMatrix().get(level).getScaleXDenominator();

	}

	public Point2D[] getTileExtent(Tile tile) {

		return limits.get(tile.getLevel()).getTileExtent(tile.getRow(), tile.getCol());

	}

	public Point2D[] getTileExtent(int level, int col, int row) {

		return limits.get(level).getTileExtent(row, col);

	}

	public List<Tile> getTileList(Rectangle2D r) {

		//No se necesita el nivel de resoluci?n real ya que es solo para dibujado

		return null;

	}

	public List<Tile> getTileList(Point2D ul, Point2D lr, double mtsPixelXRequest) {

		//Selecci?n de nivel de resoluci?n

		int tilePxWidth = 0;

		int tilePxHeight = 0;

		double tileWCWidth = 0;

		double tileWCHeight = 0;

		int level = 0;

		double mtsPixelXLevel = 0;

		double mtsPixelYLevel = 0;

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

			mtsPixelXLevel = tileMatrixSet.getTileMatrix().get(i).getScaleXDenominator();

			mtsPixelYLevel = tileMatrixSet.getTileMatrix().get(i).getScaleYDenominator();

			if(clipDecimals(mtsPixelXRequest, 6) >= clipDecimals(mtsPixelXLevel, 6) 

				|| i == (tileMatrixSet.getTileMatrix().size() - 1)) {

				level = Math.max(i, 0);

				//Se ajusta al m?ximo nivel disponible para esa capa

				if(level > (limits.size() - 1)) {

					level = limits.size() - 1;

					mtsPixelXLevel = tileMatrixSet.getTileMatrix().get(level).getScaleXDenominator();

					mtsPixelYLevel = tileMatrixSet.getTileMatrix().get(level).getScaleYDenominator();

				}

				tilePxWidth = tileMatrixSet.getTileMatrix().get(level).getTileWidth();

				tilePxHeight = tileMatrixSet.getTileMatrix().get(level).getTileHeight();

				//mtsPixelLevel = tileMatrixSet.getTileMatrix().get(i - 1).getScaleDenominator();

				tileWCWidth = tilePxWidth * mtsPixelXLevel;

				tileWCHeight = tilePxHeight * mtsPixelYLevel;

				break;

			}

		}

		//Calculo del rectangulo de tiles

		int minTileCol = (int)((Math.abs(ul.getX() - worldExtent.getMinX()) / mtsPixelXLevel) / tilePxWidth);

		int minTileRow = (int)((Math.abs(ul.getY() - worldExtent.getMaxY()) / mtsPixelYLevel) / tilePxHeight);

		double maxTC = ((Math.abs(lr.getX() - worldExtent.getMinX()) / mtsPixelXLevel) / tilePxWidth);

		double maxTR = ((Math.abs(lr.getY() - worldExtent.getMaxY()) / mtsPixelYLevel) / tilePxHeight);

		int maxTileCol = ((maxTC - ((int)maxTC)) == 0) ? (int)(maxTC - 1) : (int)maxTC;

		int maxTileRow = ((maxTR - ((int)maxTR)) == 0) ? (int)(maxTR - 1) : (int)maxTR;

		//Calculo de tiles con sus coordenadas

		List<Tile> tileList = new ArrayList<Tile>();

		for (int i = minTileRow; i <= maxTileRow; i++) {

			for (int j = minTileCol; j <= maxTileCol; j++) {

				Point2D ulTile = new Point2D.Double(

						worldExtent.getMinX() + (tileWCWidth * j),

						worldExtent.getMaxY() - (tileWCHeight * i));

				Point2D lrTile = new Point2D.Double(ulTile.getX() + tileWCWidth, ulTile.getY() - tileWCHeight);

				Tile t = TileCacheLocator.getManager().createTile(tilePxWidth, tilePxHeight, i, j, ulTile, lrTile);

				t.setLevel(level);

				tileList.add(t);

			}

		}

		return tileList;

	}

	public boolean compare(CacheStruct struct) {

		//Compara: n?mero de niveles, tama?o de tile, 

		//anchoXalto de la matriz, tama?o de pixel por nivel, 

		//coordenadas de al menos un tile de la matriz

		if(struct.getNumberOfLevels() == getNumberOfLevels()) {

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

				if(	struct.getTileSizeByLevel(i)[0] == getTileSizeByLevel(i)[0] && 

					struct.getTileSizeByLevel(i)[1] == getTileSizeByLevel(i)[1] &&

					struct.getWorldHeightOfTileMatrixByLevel(i) == getWorldHeightOfTileMatrixByLevel(i) &&

					struct.getWorldWidthOfTileMatrixByLevel(i) == getWorldWidthOfTileMatrixByLevel(i) &&

					clipDecimals(struct.getPixelSizeByLevel(i), 2) == clipDecimals(getPixelSizeByLevel(i), 2) &&

					compareExtents(struct.getTileExtent(i, 0, 0), getTileExtent(i, 0, 0))) {

					return true;

				}

			}

		}

		return false;

	}

	public String getEPSG() {

		return epsg;

	}

	public String getFileSize() {

		return fileSize + "";

	}

	private boolean compareExtents(Point2D[] p, Point2D[] p1) {

		return (p[0].getX() == p1[0].getX() && p[0].getY() == p1[0].getY() &&

				p[1].getX() == p1[1].getX() && p[1].getY() == p1[1].getY());

	}

	public double clipDecimals(double num, int n) {

		long m = (long) Math.pow(10, n);

		long aux = Math.round(num * m);

		return (double) aux / (double) m;

	}

	public Tile getTileStructure(int level, int tileCol, int tileRow,

			Point2D ul, Point2D lr) throws TileBuildException {

		int[] size = getTileSizeByLevel(level);

		Tile tile = TileCacheLocator.getManager().createTile(level, tileRow, tileCol);

		tile.setUl(ul);

		tile.setLr(lr);

		tile.setWidthPx(size[0]);

		tile.setHeightPx(size[1]);

		return tile;

	}

}

/* 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.Rectangle2D;

import java.io.IOException;

import java.util.ArrayList;

import org.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 * <p>Defines a set of tiles</p>

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

 */

public class TileMatrixSet {

    protected Rectangle2D                 bbox                = null;

    private String                        supportedCRS        = null;

    protected ArrayList<TileMatrix>       tileMatrix          = null;

	public void setBbox(Rectangle2D bbox) {

		this.bbox = bbox;

	}

    public Rectangle2D getBoundingBox() {

    	return bbox;

    }

	public ArrayList<TileMatrix> getTileMatrix() {

		if(tileMatrix == null)

			tileMatrix = new ArrayList<TileMatrix>();

		return tileMatrix;

	}

	public String getSupportedCRS() {

		return supportedCRS;

	}

	public void setSupportedCRS(String supportedCRS) {