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

        }

        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 {

        }

}