Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.googlemaps.provider;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

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

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

import org.gvsig.googlemaps.lib.api.MapTypes;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

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

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

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

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

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

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

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

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

import org.gvsig.raster.lib.buffer.spi.DefaultTileStruct;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public class GoogleMapsRasterProvider extends AbstractRasterStoreProvider {

    private static final Logger logger =

        LoggerFactory.getLogger(GoogleMapsRasterProvider.class);

    public static String NAME = "GoogleMaps";

    public static String DESCRIPTION = "Google Maps";

    public static final String METADATA_DEFINITION_NAME = "GoogleMaps";

    static IProjection GOOGLE_MAPS_PROJECTION = CRSFactory.getCRS("EPSG:3857");

    private GoogleMapsImage image;

    TileStruct tileStruct = null;

    Map<Integer,List<PageManager>> pageManagersPerZoomLevel = null;

    private Envelope worldExtent;

    protected static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

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

            manager.addDefinition(METADATA_DEFINITION_NAME,

                GoogleMapsRasterProviderParameters.class.getResourceAsStream("GoogleMapsRasterMetadata.xml"),

                GoogleMapsRasterProviderParameters.class.getClassLoader());

        }

    }

    protected GoogleMapsRasterProvider(DataStoreParameters params, DataStoreProviderServices storeServices) {

        super(params, storeServices, FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME));

        pageManagersPerZoomLevel = new HashMap<Integer, List<PageManager>>();

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        int[] bandDataTypes;

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

        NoData[] bandNoData;

        Envelope envelope = getTileStruct().getEnvelope();

        double pixelSize = rasterQuery.getPixelSize();

        int zoomLevel;

        if(pixelSize == 0){

            zoomLevel = 0;

        } else {

            zoomLevel = getZoomLvlForPixelSize(pixelSize);

        }

            if (!rasterQuery.getBands().isEmpty()) {

                List<BandQuery> bands;

                bands = rasterQuery.getBands();

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

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

                for (BandQuery bandQuery : bands) {

                    int band = bandQuery.getBand();

                    bandDataTypes[band] = this.getBandDescriptor(band).getDataType();

                    bandNoData[band] = this.getNoData(rasterQuery, band);

                    try {

                        pageManagers.add(getPageManagersInZoom(zoomLevel).get(band));

                    } catch (ValidateDataParametersException | CreateEnvelopeException | DataException

                        | CloneNotSupportedException e) {

                        // TODO Auto-generated catch block

                        throw new BufferException(e);

                    }

                }

            } else {

                int bands = getBands();

                bandDataTypes = new int[bands];

                bandNoData = new NoData[bands];

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

                    bandDataTypes[i] = this.getBandDescriptor(i).getDataType();

                    bandNoData[i] = this.getNoData(rasterQuery, i);

                    try {

                        pageManagers.add(getPageManagersInZoom(zoomLevel).get(i));

                    } catch (ValidateDataParametersException | CreateEnvelopeException | DataException

                        | CloneNotSupportedException e) {

                        throw new BufferException(e);

                    }

                }

            }

        Buffer buffer =

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

                GOOGLE_MAPS_PROJECTION, envelope, pageManagers);

        if(rasterQuery.getClip()!=null){

            Buffer completeBuffer = buffer;

            envelope  = rasterQuery.getClip();

            buffer = completeBuffer.clip(envelope);

            DisposeUtils.dispose(completeBuffer);

        }

        return buffer;

    }

    @Override

    public BandDescriptorServices getBandDescriptor(int band) {

        BandDescriptorServices descriptor = super.getBandDescriptor(band);

      switch (band) {

      case 0:

          descriptor.setName("RED");

          descriptor.setDescription("RED");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      case 1:

          descriptor.setName("GREEN");

          descriptor.setDescription("GREEN");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      case 2:

          descriptor.setName("BLUE");

          descriptor.setDescription("BLUE");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      case 3:

          descriptor.setName("ALPHA");

          descriptor.setDescription("ALPHA");

          descriptor.setDataType(BufferManager.TYPE_BYTE);

      }

      return descriptor;

    }

    @Override

    public int getBands() {

        return 4;

    }

    @Override

    public DataServerExplorer getExplorer() throws ReadException, ValidateDataParametersException {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public void open() throws OpenException {

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

            this.getBandDescriptor(i).setDataType(DataTypes.BYTE);

        }

    }

    @Override

    public ResourceProvider getResource() {

        return null;

    }

    @Override

    public Object getSourceId() {

        return NAME+"-"+getParameters().getDynValue("mapType");

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        String mapId = (String) getParameters().getDynValue("mapType");

        MapTypes mapType = MapTypes.valueOf(StringUtils.upperCase(mapId));

        return i18nManager.getTranslation("_google_maps")+" "+mapType.toString();

    }

    @Override

    public String getFullName() {

        return NAME+"-"+getParameters().getDynValue("mapType");

    }

    public TileStruct getTileStruct() {

        if(tileStruct == null){

            autoOpen();

            tileStruct = new DefaultTileStruct();

            tileStruct.setColumnsPerTile(GoogleMapsRasterLibrary.TILE_SIZE);

            tileStruct.setRowsPerTile(GoogleMapsRasterLibrary.TILE_SIZE);

            //FIXME: ??

//            tileStruct.setProviderName("GTIFF");

            try {

                worldExtent = GeometryLocator.getGeometryManager().createEnvelope(-20037508, -20037508, 20037508, 20037508, SUBTYPES.GEOM2D);

                tileStruct.setEnvelope(worldExtent);

                Map<Integer, Double> zoomLevels = new HashMap<Integer, Double>();

                double pixelSize = worldExtent.getLength(DIMENSIONS.X)/GoogleMapsRasterLibrary.GOOGLE_MAPS_TILE_SIZE;

                for (int zoomLevel = 0; zoomLevel <= GoogleMapsRasterLibrary.MAX_ZOOM_LEVEL; zoomLevel++) {

                    zoomLevels.put(zoomLevel, pixelSize);

                    pixelSize = pixelSize/2;

                }

                tileStruct.setPixelSizePerZoomLevel(zoomLevels);

            } catch (LocatorException | CreateEnvelopeException e) {

                logger.warn("Can't create world extent of GoogleMaps", e);

            }

        }

        return this.tileStruct;

    }

    private GoogleMapsImage getGoogleMapsImage() {

        if(this.image == null){

            this.image = new GoogleMapsImage(getTileStruct(), this);

        }

        return this.image;

    }

    /**

     * @param pixelSize

     * @return The appropriate zoom level for the pizelSize

     */

    private int getZoomLvlForPixelSize(double pixelSize) {

        int zoom = 0;

        Map<Integer, Double> pixelSizePerZoomLevel = getTileStruct().getPixelSizePerZoomLevel();

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

            zoom = i;

            double levelPixelSize = pixelSizePerZoomLevel.get(zoom);

            if (pixelSize >= levelPixelSize) {

                return zoom;

            }

        }

        return zoom;

    }

    private List<PageManager> getPageManagersInZoom(int zoomLevel) throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {

        List<PageManager> pageManagersInZoom = this.pageManagersPerZoomLevel.get(zoomLevel);

        if (pageManagersInZoom == null) {

            pageManagersInZoom = new ArrayList<PageManager>();

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

                pageManagersInZoom.add(new GoogleMapsBandTileManager(getTileStruct(), this.getGoogleMapsImage(), zoomLevel, i, this));

            }

            this.pageManagersPerZoomLevel.put(zoomLevel, pageManagersInZoom);

        }

        return pageManagersInZoom;

    }

    /**

     * @param zoomLevel

     * @return rows per zoom level

     */

    public int getRows(int zoomLevel) {

        return (int) (Math.round(getTileStruct().getEnvelope().getLength(DIMENSIONS.Y) / this.getTileStruct().getPixelSizePerZoomLevel().get(zoomLevel)));

    }

    /**

     * @param zoomLevel

     * @return columns per zoom level

     */

    public int getColumns(int zoomLevel) {

        return (int) (Math.round(getTileStruct().getEnvelope().getLength(DIMENSIONS.X) / this.getTileStruct().getPixelSizePerZoomLevel().get(zoomLevel)));

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

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

            return this.getTileStruct().getEnvelope(); //.worldExtent;

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

            return GOOGLE_MAPS_PROJECTION;

        }

        return super.getDynValue(name);

    }

    @Override

    public BufferDimensions getDimensions() throws InitializeException {

        if(this.dimensions==null){;

            Double pixelSize = getTileStruct().getPixelSizePerZoomLevel().get(GoogleMapsRasterLibrary.MAX_ZOOM_LEVEL);

            Envelope envelope = getTileStruct().getEnvelope();

            int rows = (int)Math.round(envelope.getLength(DIMENSIONS.Y)/pixelSize);

            int columns = rows;

            this.dimensions = BufferLocator.getBufferManager().createBufferDimensions(rows, columns, envelope);

        }

        return this.dimensions;

    }

    @Override

    public void doDispose() throws BaseException {

        super.doDispose();

        for (Iterator<Entry<Integer, List<PageManager>>> iterator = pageManagersPerZoomLevel.entrySet().iterator(); iterator.hasNext();) {

            Entry<Integer, List<PageManager>> entry = iterator.next();

            List<PageManager> pageManagers = entry.getValue();

            for(Iterator<PageManager> it = pageManagers.iterator(); it.hasNext();){

                PageManager pageManager = it.next();

                DisposeUtils.dispose(pageManager);

                it.remove();

            }

            iterator.remove();

        }

        DisposeUtils.dispose((Disposable) tileStruct);

        DisposeUtils.dispose(image);

        tileStruct=null;

        image=null;

    }

}