Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.wms.provider;

import java.awt.Image;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import javax.imageio.ImageIO;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.CompatLocator;

import org.gvsig.compat.net.Downloader;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

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

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

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

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

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

import org.gvsig.remoteclient.exceptions.ServerErrorException;

import org.gvsig.remoteclient.exceptions.WMSException;

import org.gvsig.remoteclient.wms.WMSClient;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.remoteclient.wms.WMSStyle;

import org.gvsig.tools.dataTypes.DataTypes;

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

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public class WMSRasterProvider extends AbstractRasterStoreProvider {

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

    public static String NAME = "WMSRaster";

    public static String DESCRIPTION = "WMS Raster Provider";

    public static final String METADATA_DEFINITION_NAME = "WMSRaster";

    public static final int DEFAULT_BUFFER_SIZE = 1024;

    public static final int MAX_ZOOM_LEVEL = 22;

    // WMS Parameters

    private WMSClient wmsClient;

    private WMSStatus wmsStatus;

    private Envelope envelope = null;

    private IProjection projection = null;

    protected WMSRasterProvider(DataStoreParameters params, DataStoreProviderServices storeServices) throws InitializeException {

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

        initParams();

    }

    private void initParams() throws InitializeException {

        WMSRasterProviderParameters parameters = (WMSRasterProviderParameters) getParameters();

        URL service = parameters.getService();

        try {

            wmsClient = new WMSClient(service.toString());

        } catch (IOException e) {

            throw new InitializeException("Can't create WMSClient with host '"+service+"'", e);

        }

        wmsStatus = new WMSStatus();

        // Setting the envelope for the layer

        wmsClient.getCapabilities(wmsStatus, false, null);

        @SuppressWarnings("unchecked")

        List<String> layerNames =

            (List<String>) parameters.getDynValue(WMSRasterProviderParameters.WMS_LAYERS_PARAMETER_NAME);

        for (Iterator<String> iterator = layerNames.iterator(); iterator.hasNext();) {

            String layerName = (String) iterator.next();

            wmsStatus.addLayerName(layerName);

        }

        Rectangle2D extent = wmsClient.getLayersExtent(layerNames.toArray(new String[0]), getProjection().getAbrev());

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        try {

            this.envelope =

                geomManager.createEnvelope(extent.getMinX(), extent.getMinY(), extent.getMaxX(), extent.getMaxY(),

                    SUBTYPES.GEOM2D);

        } catch (CreateEnvelopeException e) {

            throw new InitializeException("Can't create envenlope.", e);

        }

        @SuppressWarnings("unchecked")

        List<WMSStyle> wmsStyles =

            (List<WMSStyle>) parameters.getDynValue(WMSRasterProviderParameters.WMS_STYLES_PARAMETER_NAME);

        wmsStatus.setStyles(new Vector<WMSStyle>(wmsStyles));

        wmsStatus.setFormat((String) parameters.getDynValue(WMSRasterProviderParameters.WMS_FORMAT_PARAMETER_NAME));

        wmsStatus.setInfoFormat((String) parameters.getDynValue(WMSRasterProviderParameters.WMS_INFO_FORMAT_PARAMETER_NAME));

        Boolean xyAxisOrder = (Boolean) parameters.getDynValue(WMSRasterProviderParameters.WMS_XYAXISORDER_PARAMETER_NAME);

        if(xyAxisOrder!=null && xyAxisOrder.booleanValue()){

            wmsStatus.setXyAxisOrder(xyAxisOrder);

        }

        projection  = (IProjection) (parameters.getDynValue(WMSRasterProviderParameters.WMS_CRS_PARAMETER_NAME));

        wmsStatus.setSrs(projection.getAbrev());

        Boolean transparency = (Boolean) parameters.getDynValue(WMSRasterProviderParameters.WMS_TRANSPARENCY_PARAMETER_NAME);

        if(transparency!=null && transparency.booleanValue()){

            wmsStatus.setTransparency(transparency);

        }

    }

    protected static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

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

            manager.addDefinition(METADATA_DEFINITION_NAME,

                WMSRasterProviderParameters.class.getResourceAsStream("WMSRasterMetadata.xml"),

                WMSRasterProviderParameters.class.getClassLoader());

        }

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        int[] bandDataTypes;

        NoData[] bandNoData;

        //

        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] = null;

            }

        } 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] = null;

            }

        }

        Envelope envelope = getEnvelope();

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

            envelope = rasterQuery.getClip();

        }

        wmsStatus.setExtent(

            new Rectangle2D.Double(

                envelope.getMinimum(DIMENSIONS.X),

                envelope.getMinimum(DIMENSIONS.Y),

                envelope.getLength(DIMENSIONS.X),

                envelope.getLength(DIMENSIONS.Y)));

        double ratio = Math.abs(envelope.getLength(DIMENSIONS.X)/envelope.getLength(DIMENSIONS.Y));

        double pixelSize = rasterQuery.getPixelSize();

        int columns = WMSRasterProvider.DEFAULT_BUFFER_SIZE;

        int rows = WMSRasterProvider.DEFAULT_BUFFER_SIZE;

        if(pixelSize == 0){

            if(ratio >= 1){

                wmsStatus.setWidth(columns);

                rows = (int)Math.round(WMSRasterProvider.DEFAULT_BUFFER_SIZE/ratio);

                wmsStatus.setHeight((int)Math.round(WMSRasterProvider.DEFAULT_BUFFER_SIZE/ratio));

            } else {

                columns = (int)Math.round(WMSRasterProvider.DEFAULT_BUFFER_SIZE/ratio);

                wmsStatus.setWidth(columns);

                wmsStatus.setHeight(rows);

            }

        } else {

            columns = (int)Math.round(envelope.getLength(DIMENSIONS.X)/pixelSize);

            wmsStatus.setWidth(columns);

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

            wmsStatus.setHeight(rows);

        }

        URL url;

        Downloader downloader = CompatLocator.getDownloader();

        BufferedImage img;

        try {

            url = wmsClient.getGetMapURL(wmsStatus, null);

            logger.info("URL: "+url.toString());

            File file = downloader.downloadFile(url, "WMS_map", null);

            img = ImageIO.read(file);

        } catch (Exception e) {

            throw new BufferException(e);

        }

        Buffer buffer = bufferManager.createRGBABuffer(img, projection, envelope);

        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 {

        DataManager manager = DALLocator.getDataManager();

        WMSRasterServerExplorerParameters params;

        try {

            params =

                (WMSRasterServerExplorerParameters) manager

                    .createServerExplorerParameters(WMSRasterServerExplorer.NAME);

            params.setService(((WMSRasterProviderParameters) getParameters()).getService());

//            params.setXYAxisOrder(((WMSRasterProviderParameters) getParameters()).getXYAxisOrder());

            return manager.openServerExplorer(WMSRasterServerExplorer.NAME, (DataServerExplorerParameters) params);

        } catch (Exception e) {

            throw new ReadException(this.getName(), e);

        }

    }

    @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 getParameters().getDynValue(WMSRasterProviderParameters.WMS_SERVICE_PARAMETER_NAME);

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() { //lista de capas

        @SuppressWarnings("unchecked")

        List<String> layers = (List<String>) getParameters().getDynValue("layers");

        StringBuilder builder = new StringBuilder();

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

            if (i != 0) {

                builder.append(",");

            }

            builder.append(layers.get(i));

        }

        return builder.toString();

    }

    @Override

    public String getFullName() { // host:port - lista de capas

        StringBuilder builder = new StringBuilder();

        URL service = (URL)this.getParameters().getDynValue(WMSRasterProviderParameters.WMS_SERVICE_PARAMETER_NAME);

        builder.append(service.getHost());

        int port = service.getPort();

        if(port < 0){

            int defaultPort = service.getDefaultPort();

            if(defaultPort>=0){

                builder.append(":");

                builder.append(service.getDefaultPort());

            }

        } else {

            builder.append(":");

            builder.append(port);

        }

        builder.append(" - ");

        builder.append(getName());

        return builder.toString();

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

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

            return this.getParameters().getDynValue(name);

        }

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

            return this.getEnvelope();

        }

        return super.getDynValue(name);

    }

    private Envelope getEnvelope() {

        return this.envelope;

    }

    private IProjection getProjection() {

        return (IProjection) this.getParameters().getDynValue(WMSRasterProviderParameters.WMS_CRS_PARAMETER_NAME);

    }

    @Override

    public TileStruct getTileStruct() {

        TileStruct tileStruct = new DefaultTileStruct();

        tileStruct.setColumnsPerTile(DEFAULT_BUFFER_SIZE);

        tileStruct.setRowsPerTile(DEFAULT_BUFFER_SIZE);

        try {

            Envelope envelope = getEnvelope();

            tileStruct.setEnvelope(envelope);

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

            double pixelSize;

            double length;

            if (envelope.getLength(DIMENSIONS.X) >= envelope.getLength(DIMENSIONS.Y)) {

                length = envelope.getLength(DIMENSIONS.X);

            } else {

                length = envelope.getLength(DIMENSIONS.Y);

            }

            pixelSize = length / DEFAULT_BUFFER_SIZE;

            for (int zoomLevel = 0; (zoomLevel <= MAX_ZOOM_LEVEL) && ((length/pixelSize)<Integer.MAX_VALUE); zoomLevel++) {

                zoomLevels.put(zoomLevel, pixelSize);

                pixelSize = pixelSize / 2;

            }

            tileStruct.setPixelSizePerZoomLevel(zoomLevels);

        } catch (LocatorException e) {

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

        }

        return tileStruct;

    }

    @Override

    public Image getImageLegend() {

        Vector layerNames = wmsStatus.getLayerNames();

        if(layerNames.size()>1){

            return null;

        }

        File file;

        BufferedImage img=null;

        try {

            file = wmsClient.getLegendGraphic(wmsStatus, layerNames.get(0).toString(), null);

            img = ImageIO.read(file);

        } catch (WMSException | ServerErrorException | IOException e) {

            logger.warn("Can't read image legend of WMS Provider", e);

        }

        return img;

    }

}