Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.Hashtable;

/**

 * Class defining the node of the layer tree of a common WCS service.

 * @author jaume

 */

@SuppressWarnings("unchecked")

public class WCSLayerNode {

	private String       name                  = null;

	private ArrayList    srs                   = null;

	private String       title                 = null;

	private String       nativeSRS             = null;

	private ArrayList    formats               = null;

	private Point2D      maxRes                = null;

	private int          width                 = 0;

	private int          height                = 0;

	private ArrayList    timePositions         = null;

	private String       description           = null;

	private ArrayList    interpolationMethods  = null;

	private ArrayList    pList                 = null;

	private Hashtable    extents               = null;

	private String       latLonBox             = null;

	private String       lAbstract             = null;

	private ArrayList    children              = new ArrayList();

	private boolean      transparency;

	public void setName(String name) {

		this.name = name;

	}

	public void addAllSrs(ArrayList srs) {

		if (this.srs == null)

			this.srs = new ArrayList();

		this.srs.addAll(srs);

	}

	public void setTitle(String title) {

		this.title = title;

	}

	public void setNativeSRS(String nativeSRS) {

		this.nativeSRS = nativeSRS;

	}

	public String getName() {

		return name;

	}

	public void setFormats(ArrayList formats) {

		this.formats = formats;

	}

	public ArrayList getFormats() {

		return formats;

	}

	public ArrayList getSRSs() {

		if (!srs.contains(nativeSRS)) {

			ArrayList l = new ArrayList(srs);

			l.add(nativeSRS);

			return l;

		}

		return srs;

	}

	public String getTitle() {

		return title;

	}

	public Rectangle2D getExtent(String srs) {

		if ( extents != null ) {

			return (Rectangle2D) extents.get(srs);

		}

		return null;

	}

	public void addExtent(String srs, Rectangle2D extent) {

		if ( extents == null ) extents = new Hashtable();

		extents.put(srs, extent);

	}

	public Point2D getMaxRes() {

		return maxRes;

	}

	public void setMaxRes(Point2D maxRes) {

		this.maxRes = maxRes;

	}

	public String toString(){

    	String str;

    	if (getName()==null)

    		str = getTitle();

    	else

    		str = "["+getName()+"] "+getTitle();

        return str;

    }

	public void setTimePositions(ArrayList timePositions) {

		this.timePositions = timePositions;

	}

	public ArrayList getTimePositions() {

		return this.timePositions;

	}

	public String getDescription() {

		return this.description;

	}

	public void setDescription(String descr) {

		this.description = descr;

	}

	public String getLonLatEnvelope() {

		return "yet unimplemented";

	}

	public void setInterpolationMethods(ArrayList interpolationMethods) {

		this.interpolationMethods = interpolationMethods;

	}

	public ArrayList getInterpolationMethods() {

		return interpolationMethods;

	}

	public ArrayList getParameterList() {

		return pList;

	}

	public void addParameter(FMapWCSParameter p) {

		if (pList == null) pList = new ArrayList();

		pList.add(p);

	}

	/**

     * Gets the layer abstract.

     * @return Returns the abstract.

     */

    public String getAbstract() {

        return lAbstract;

    }

    /**

     * Sets the layer abstract.

     * @param abstract The abstract to set.

     */

    public void setAbstract(String _abstract) {

        lAbstract = _abstract;

    }

    public void setLatLonBox(String _latLonBox) {

        latLonBox = _latLonBox;

    }

    public String getLatLonBox() {

        return latLonBox;

    }

    /**

     * Gets the list of sons of this layer.

     */

    public ArrayList getChildren() {

        return children;

    }

    /**

     * Sets the list of sons of this layer.

     * @param children

     */

    public void setChildren(ArrayList children) {

        this.children = children;

    }

    /**

     * @return Returns the transparency.

     */

    public boolean isTransparent() {

        return transparency;

    }

    /**

     * @param transparency The transparency to set.

     */

    public void setTransparency(boolean transparency) {

        this.transparency = transparency;

    }

	public int getWidth() {

		return width;

	}

	public void setWidth(int width) {

		this.width = width;

	}

	public int getHeight() {

		return height;

	}

	public void setHeight(int height) {

		this.height = height;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

* 

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

import java.util.ArrayList;

/**

 * Class abstracting WCS's axis descriptions into FMap

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 * @TODO add interval parameters support

 */

@SuppressWarnings("unchecked")

public class FMapWCSParameter {

	public static final int VALUE_LIST = 0;

	public static final int INTERVAL = 1;

	private String name;

	private int type;

	private ArrayList valueList;

	private String label;

	public void setName(String name) {

		this.name = name;

	}

	public void setType(int type) {

		this.type = type;

	}

	public int getType() {

		return type;

	}

	public void setValueList(ArrayList singleValues) {

		this.valueList = singleValues;

	}

	public void setLabel(String label) {

		this.label = label;

	}

	public String toString() {

		return (label!=null) ? label : name;

	}

	public ArrayList getValueList() {

		return valueList;

	}

	public String getName() {

		return name;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.wcs.io;

import java.awt.geom.Point2D;

import java.io.IOException;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.net.URLConnection;

import java.util.Hashtable;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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.exception.RemoteServiceException;

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

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

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

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

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

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

import org.gvsig.i18n.Messages;

/**

 * Explorer for a WCS server

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

 */

public class WCSServerExplorer implements RasterDataServerExplorer, DataServerExplorerProvider {

	private WCSConnector                connector                = null;

	private WCSServerExplorerParameters parameters               = null;

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

	public WCSServerExplorer(

			WCSServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

		this.parameters = parameters;

	}

	/**

	 * Gets the provider's name

	 * @return

	 */

	public String getDataStoreProviderName() {

		return WCSProvider.NAME;

	}

	public String getDescription() {

		return WCSProvider.DESCRIPTION;

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	public List getDataStoreProviderNames() {

		return null;

	}

	public DataServerExplorerParameters getParameters() {

		return parameters;

	}

	public List list() throws DataException {

		return null;

	}

	public List list(int mode) throws DataException {

		return null;

	}

	public void remove(DataStoreParameters parameters) throws DataException {

	}

	public void dispose() {

	}

	public String getProviderName() {

		return null;

	}

	/**

	 * Gets the online resources

	 * @return

	 */

	public Hashtable getOnlineResources() {

		return null;

	}

	//**********************************************

	//Connector

	//**********************************************

	public DataStoreParameters getStoredParameters() {

		DataManager manager = DALLocator.getDataManager();

		WCSDataParametersImpl params = null;

		try {

			params = (WCSDataParametersImpl) manager.createStoreParameters(this.getDataStoreProviderName());

		} catch (InitializeException e) {

            logger.warn("Can't get DataStoreParameters from WCSServerExplorer", e);

		} catch (ProviderNotRegisteredException e) {

            logger.warn("Can't get DataStoreParameters from WCSServerExplorer", e);

		}

		String host = parameters.getHost();

		URI hostURI;

        try {

            hostURI = new URI(host);

            params.setURI(hostURI);

        } catch (URISyntaxException e) {

            logger.warn("Can't create URI from"+host, e);

        }

		return params;

	}

	/**

	 * Connects to the server and throws a getCapabilities. This loads

	 * the basic information to make requests.

	 * @throws RemoteServiceException

	 */

	public void connect(ICancellable cancellable) throws ConnectException {

		URL url = null;

		boolean override = false;

		try {

			url = new URL(parameters.getHost());

		} catch (Exception e) {

			throw new ConnectException(Messages.getText("malformed_url"), e);

		}

        try {

        	connector = WCSProvider.getConnectorFromURL(url);

        	if (!connector.connect(override, cancellable))

        		throw new ConnectException(Messages.getText("error_connecting"));

        } catch (IOException e) {

			throw new ConnectException(Messages.getText("error_connecting"), e);

		}

	}

	/**

	 * Checks if the network and host are reachable

	 * @param timeout for the host

	 * @return true if both are reachable and false if they are not

	 */

	public boolean isHostReachable(int timeout) {

		URL url = null;

		try {

			url = new URL(parameters.getHost());

			URLConnection con = url.openConnection();

			if(con == null)

				return false;

			con.connect();

			InputStream stream = con.getInputStream();

			if(stream == null)

				return false;

		} catch (MalformedURLException e) {

			return false;

		} catch (IOException e) {

			return false;

		}

		return true;

	}

	/**

	 * Checks if the network and host are reachable

	 * @return true if both are reachable and false if they are not

	 */

	public boolean isHostReachable() {

		int timeout = 10000;

		return isHostReachable(timeout);

	}

	/**

	 * Returns true if this provider is connected to the server

	 * @return

	 */

	public boolean isConnected() {

		if(connector != null)

			return true;

		return false;

	}

	/**

	 * Gets the description of this service

	 * @return

	 */

	public String getAbstract() {

		if(connector != null)

			return connector.getDescription();

		return null;

	}

	/**

	 * Gets the server title

	 * @return

	 */

	public String getServerType() {

		if (getVersion() == null)

			return "WCS";

        return "WCS "+ getVersion();

	}

	/**

	 * Gets the protocol supported by the server

	 * @return

	 */

	public String getVersion() {

		if(connector != null) {

			return (connector.getVersion() == null) ? "" : connector.getVersion();

		}

		return null;

	}

	/**

	 * Gets the host URI

	 * @return

	 */

	public String getHost() {

		return parameters.getHost();

	}

	/**

	 * Gets the title

	 * @return

	 */

	public String getTitle() {

		return null;

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public Point2D getMaxResolution(String layerName) {

		return connector.getMaxResolution(layerName);

	}

	/**

	 * Gets the coverage list

	 * @return

	 */

	public WCSLayerNode[] getCoverageList() {

		return connector.getLayerList();

	}

	/**

	 * Gets a layer searching by its name

	 * @return

	 */

	public WCSLayerNode getCoverageByName(String name) {

		WCSLayerNode[] list = getCoverageList();

		for (int i = 0; i < list.length; i++) {

			if(list[i].getName().compareTo(name) == 0)

				return list[i];

		}

		return null;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.BufferedOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.net.ConnectException;

import java.net.HttpURLConnection;

import java.net.URL;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Set;

import java.util.prefs.Preferences;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import org.gvsig.compat.net.ICancellable;

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

import org.gvsig.remoteclient.exceptions.ServerErrorException;

import org.gvsig.remoteclient.exceptions.WCSException;

import org.gvsig.remoteclient.utils.BoundaryBox;

import org.gvsig.remoteclient.wcs.WCSClient;

import org.gvsig.remoteclient.wcs.WCSCoverage;

import org.gvsig.remoteclient.wcs.WCSStatus;

import org.gvsig.remoteclient.wcs.WCSCoverage.AxisDescription;

import org.gvsig.remoteclient.wcs.WCSCoverage.RectifiedGrid;

/**

 * Connector between a WCS data provider and a WCSClient. 

 *

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

 */

public class WCSConnector  {

	private WCSClient                         client;

	private Hashtable<String, WCSLayerNode>   coverages;

    private WCSLayerNode[]                    layerList;

    public WCSConnector(URL url) throws ConnectException, IOException {

    	client = new WCSClient(url.toString());

    }

	/**

	 * Returns the string "WCSDriver", which is the driver's name.

	 * @return String

	 */

	public String getName() { 

		return "WCSDriver"; 

	}

	/**

	 * Sets the server that we want to connect to.

	 *

	 * @param host

	 * @throws IOException

	 */

	public void setHost(String host) throws IOException{

		client = new WCSClient(host);

	}

	/**

	 * Returns a human-readable string containing the server's name.

	 *

	 * @return String

	 */

	public String getLabel() {

		return client.getServiceTitle();

	}

	/**

	 * Returns a string containing the server's WCS version number.

	 *

	 * @return String

	 */

	public String getVersion(){

		return client.getVersion();

	}

	/**

	 * <p>

	 * Returns name and description of the server. It is supposed to be used

	 * as the source of the abstract field in your application's interface.

	 * </p>

	 * <p>

	 * Devuelve nombre y descripci?n (abstract) del servidor.

	 * </p>

	 * @return String

	 */

	public String getDescription(){

		return client.getDescription();

	}

	/**

	 * Returns the layer descriptor for a given coverage name.

	 * @param layerName

	 * @return WCSLayer

	 */

	public WCSLayerNode getLayer(String layerName) {

		getLayerList();

		return (WCSLayerNode) getCoverages().get(layerName);

	}

	private Hashtable<String, WCSLayerNode> getCoverages() {

		if(coverages == null || coverages.isEmpty()) {

			getLayerList();

		}

		return coverages;

	}

	/**

	 * Returns an array of WCSLayer's with the descriptors of all coverages

	 * @return WCSLayer[]

	 */

	public WCSLayerNode[] getLayerList() {

		if (coverages == null || coverages.isEmpty()) {

			// the WCSLayer collection will be built

			coverages = new Hashtable<String, WCSLayerNode>();

			Hashtable wcsCoverages  = client.getCoverageList();

			int sz = wcsCoverages.size();

			// Create an array with the WCSCoverages

			WCSCoverage[] coverageList = new WCSCoverage[sz];

			Iterator it = wcsCoverages.keySet().iterator();

			int i = 0;

			while (it.hasNext()) {

				coverageList[i] = (WCSCoverage) wcsCoverages.get(it.next());

				i++;

			}

			// Create a WCSLayer array from the previous WCSCoverage array

			layerList = new WCSLayerNode[sz];

			for (int j = 0; j < layerList.length; j++) {

				WCSLayerNode lyr = new WCSLayerNode();

				WCSCoverage cov = coverageList[j];

				// name

				lyr.setName(cov.getName());

				// title

				lyr.setTitle(cov.getTitle());

				// description

				lyr.setDescription(cov.getAbstract());

				// srs

				lyr.addAllSrs(cov.getAllSrs());

				// native srs

				lyr.setNativeSRS(cov.getNativeSRS());

				// extents

				Set k = cov.getBBoxes().keySet();

				if (!k.isEmpty()) {

					it = k.iterator();

					while (it.hasNext()) {

						String srs = (String) it.next();

						BoundaryBox bBox = cov.getBbox(srs);

						Rectangle2D r = new Rectangle2D.Double(

								bBox.getXmin(),

								bBox.getYmin(),

								bBox.getXmax() - bBox.getXmin(),

								bBox.getYmax() - bBox.getYmin()

						);

						lyr.addExtent(srs, r);

					}

				}

				// formats

				lyr.setFormats(cov.getFormats());

				// time positions

				lyr.setTimePositions(cov.getTimePositions());

				RectifiedGrid rf = cov.getRectifiedGrid();

				if(rf != null){

					int w = rf.getHighGridEnvelopLimits()[0][0] - rf.getLowGridEnvelopLimits()[0][0];

					int h = rf.getHighGridEnvelopLimits()[0][1] - rf.getLowGridEnvelopLimits()[0][1];

					lyr.setWidth(w);

					lyr.setHeight(h);

				}

				// max res

				lyr.setMaxRes(new Point2D.Double(cov.getResX(), cov.getResY()));

				// interpolations

				lyr.setInterpolationMethods(cov.getInterpolationMethods());

				// parameters

				k = cov.axisPool.keySet();

				if (!k.isEmpty()) {

					it = k.iterator();

					while (it.hasNext()) {

						AxisDescription ad = (AxisDescription) cov.axisPool.get(it.next());

						FMapWCSParameter p = new FMapWCSParameter();

						p.setName(ad.getName());

						p.setLabel(ad.getLabel());

						p.setType(ad.getInterval() == null ? FMapWCSParameter.VALUE_LIST : FMapWCSParameter.INTERVAL);

						if (p.getType() == FMapWCSParameter.VALUE_LIST) {

							p.setValueList(ad.getSingleValues());

						} /*else {

							p.setInterval(ad.getInterval());

						}*/

						lyr.addParameter(p);

					}

				}

				layerList[j] = lyr;

				coverages.put(lyr.getName(), lyr);

			}

		}

		return layerList;

	}

	/**

	 * Establishes the connection to the WCS server. Connecting to a WCS is

	 * an abstraction.<br>

	 * <p>

	 * Actually, it sends a GetCapabilities and a general DescribeCoverage

	 * request (not a coverage-specific DescribeCoverage request) to read the

	 * necessary data for building further GetCoverage requests.

	 * </p>

	 * @param override

	 * @throws IOException.

	 */

	public boolean connect(boolean override, ICancellable cancel)

			throws IOException {

		coverages = null;

		setHost(client.getHost());

		return client.connect(override, cancel);

	}

	/**

	 * No close operation is needed since WCS service it is a non-session based

	 * protocol. So, this does nothing and you can omit it.<br>

	 */

	public void close() {

//		connected = false;

	}

	/**

	 * Returns the label of an specific coverage given by the coverage name

	 * @param coverage name (string)

	 * @return string

	 */

	public String getLabel(String coverageName) {

		return client.getLabel(coverageName);

	}

	/**

	 * Returns the coverage's MAX extent from the server.

	 * @return Rectangle2D

	 * @throws IOException

	 */

	public Rectangle2D getFullExtent(String coverageName, String srs)

			throws IOException {

		return client.getExtent(coverageName, srs);

	}

	/**

	 * Returns the max resolution of a specific coverage given by the coverage's name.

	 * @param coverage name (string)

	 * @return double

	 */

	public Point2D getMaxResolution(String coverageName) {

		if (getCoverages().containsKey(coverageName)) {

			return ((WCSLayerNode) getCoverages().get(coverageName)).getMaxRes();

		}

		return null;

	}

	/**

	 * Gets the maximum width in pixels of this coverage

	 * @param coverageName

	 * @return

	 */

	public int getWidth(String coverageName) {

		if (getCoverages().containsKey(coverageName)) {

			return ((WCSLayerNode) getCoverages().get(coverageName)).getWidth();

		}

		return 0;

	}

	/**

	 * Gets the maximum height in pixels of this coverage

	 * @param coverageName

	 * @return

	 */

	public int getHeight(String coverageName) {

		if (getCoverages().containsKey(coverageName)) {

			return ((WCSLayerNode) getCoverages().get(coverageName)).getHeight();

		}

		return 0;

	}

	/**

	 * Returns an ArrayList containing a set of Strings with the coverage's SRSs.

	 * @param coverage name (string)

	 * @return ArrayList

	 */

	public ArrayList getSRSs(String coverageName) {

		if (getCoverages().containsKey(coverageName)) {

			return ((WCSLayerNode) getCoverages().get(coverageName)).getSRSs();

		}

		return null;

	}

	/**

	 * Returns a String containing a description of an specific coverage.

	 * @param coverage name (string)

	 * @return string

	 */

	public String getCoverageDescription(String coverageName) {

		if (getCoverages().containsKey(coverageName)) {

			return ((WCSLayerNode) getCoverages().get(coverageName)).getDescription();

		}

		return null;

	}

	/**

	 * Returns an ArrayList containing strings for the time positions of an

	 * specific coverage given by the coverage's name.

	 * @param coverage name (string)

	 * @return ArrayList

	 */

	public ArrayList getTimes(String coverageName) {

		if (getCoverages().containsKey(coverageName)) {

			return ((WCSLayerNode) getCoverages().get(coverageName)).getTimePositions();

		}

		return null;

	}

	/**

	 * Sends a GetCoverage request to the client.

	 * @param status

	 * @return

	 * @throws WCSException

	 */

	public File getCoverage(WCSStatus status, ICancellable cancel) throws RemoteServiceException {

		try {

			return client.getCoverage(status, cancel);

		} catch (ServerErrorException e) {

			throw new RemoteServiceException(getName(), e);

		} catch (org.gvsig.remoteclient.exceptions.WCSException e) {

			throw new RemoteServiceException(e.getMessage(), e);

		}

	}

	/**

	 * Sends a GetCoverage request to the client.

	 * @param status

	 * @return

	 * @throws WCSException

	 */

	public void getCoverageURL(WCSStatus status, ICancellable cancel, File file) throws RemoteServiceException {

		try {

			URL url = client.getCoverageURL(status, cancel);

			downloadFile(url, file, cancel);

			String exceptionMessage = client.getExceptionMessage(file);

			if(exceptionMessage != null)

				throw new RemoteServiceException(exceptionMessage);

		} catch(IOException e) {

			throw new RemoteServiceException("WCS: error downloading the file. File:" + file.getAbsolutePath() + "...." + e.getMessage(),e);

		} catch (ServerErrorException e) {

			throw new RemoteServiceException("WCS Unexpected server error."+e.getMessage(),e);

//		}  catch (org.gvsig.remoteclient.exceptions.WMSException e) {

//			throw new RemoteServiceException(e.getMessage());

		}

	}

	public void downloadFile(URL url, File dstFile, ICancellable cancel) throws IOException {

		Preferences prefs = Preferences.userRoot().node( "gvsig.downloader" );

		// by default 1 minute (60000 milliseconds.

		int timeout = prefs.getInt("timeout", 60000);

		DataOutputStream dos;

		DataInputStream is;

		OutputStreamWriter os = null;

		HttpURLConnection connection = null;

		//If the used protocol is HTTPS

		if (url.getProtocol().equals("https")) {

			try {

				disableHttsValidation();

			} catch (KeyManagementException e) {

				e.printStackTrace();

			} catch (NoSuchAlgorithmException e) {

				e.printStackTrace();

			}

		}

		connection = (HttpURLConnection)url.openConnection();

		connection.setConnectTimeout(timeout);

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

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

		byte[] buffer = new byte[1024 * 4];

		long readed = 0;

		for (int i = is.read(buffer); i > 0; i = is.read(buffer)){

			dos.write(buffer, 0, i);

			readed += i;

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

				return;

		}

		if(os != null) {

			os.close();

		}

		dos.close();

		is.close();

		is = null;

		dos = null;

	}

	/**

	 * This method disables the Https certificate validation.

	 * @throws KeyManagementException

	 * @throws NoSuchAlgorithmException

	 */

	private void disableHttsValidation() throws KeyManagementException, NoSuchAlgorithmException{

		// Create a trust manager that does not validate certificate chains

		TrustManager[] trustAllCerts = new TrustManager[] {

				new X509TrustManager() {

					public java.security.cert.X509Certificate[] getAcceptedIssuers() {

						return null;

					}

					public void checkClientTrusted(

							java.security.cert.X509Certificate[] certs, String authType) {

					}

					public void checkServerTrusted(

							java.security.cert.X509Certificate[] certs, String authType) {

					}

				}

		};

		// Install the all-trusting trust manager

		SSLContext sc = SSLContext.getInstance("SSL");

		sc.init(null, trustAllCerts, new java.security.SecureRandom());

		HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

	}

}

package org.gvsig.raster.wcs.io;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Hashtable;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.impl.store.properties.RemoteDataStoreStatistics;

import org.gvsig.raster.impl.store.properties.RemoteStoreHistogram;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.raster.wcs.io.downloader.WCSTileServer;

import org.gvsig.remoteclient.wcs.WCSStatus;

import org.gvsig.tools.ToolsLocator;

/**

 * Clase que representa al driver de acceso a datos de wcs.

 *

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

 */

public class WCSProvider extends AbstractRasterProvider implements RemoteRasterProvider {

	public static String                NAME                     = "Wcs Store";

	public static String                DESCRIPTION              = "Wcs Raster file";

	public static final String          METADATA_DEFINITION_NAME = "WcsStore";

	private Extent                      viewRequest              = null;

	private static Hashtable<URL, WCSConnector>

	drivers                  = new Hashtable<URL, WCSConnector> ();

	private boolean                     open                     = false;

	private DataStoreTransparency       fileTransparency         = null;

	private File                        lastRequest              = null;

	private AbstractRasterProvider      lastRequestProvider      = null;

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

	public static void register() {

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

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

			dataman.registerStoreProvider(NAME,

					WCSProvider.class, WCSDataParametersImpl.class);

		}

		if (!dataman.getExplorerProviders().contains(NAME)) {

			dataman.registerExplorerProvider(NAME, WCSServerExplorer.class, WCSServerExplorerParameters.class);

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	public WCSProvider() throws NotSupportedExtensionException {

		super();

	}

	/**

	 * Constructor. Abre el dataset.

	 * @throws OpenException

	 * @throws NotSupportedExtensionException

     * @deprecated use {@link #WCSProvider(URI)}, this constructor will be removed in gvSIG 2.5

     */

	public WCSProvider(String params) throws InitializeException, OpenException {

		super(params);

        logger.info("Deprecated use of WCSProvider constructor");

		if(params instanceof String) {

			WCSDataParametersImpl p = new WCSDataParametersImpl();

            try {

                p.setURI(new URI((String) params));

            } catch (URISyntaxException e) {

                throw new OpenException("Can't create URI from" + (String) params, e);

            }

            super.init(p, null, ToolsLocator.getDynObjectManager()

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

									DataStore.METADATA_DEFINITION_NAME)));

			init(p, null);

		}

	}

    public WCSProvider(URI uri) throws InitializeException, OpenException {

        super(uri);

        WCSDataParametersImpl p = new WCSDataParametersImpl();

            p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

                MetadataLocator.getMetadataManager().getDefinition(DataStore.METADATA_DEFINITION_NAME)));

        init(p, null);

    }

	public WCSProvider(WCSDataParametersImpl params,

			DataStoreProviderServices storeServices) throws InitializeException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Gets the connector from the URL

	 * @return

	 * @throws RemoteServiceException

	 */

	public WCSConnector getConnector() throws RemoteServiceException {

		WCSDataParametersImpl p = (WCSDataParametersImpl)parameters;

		URL url = null;

		try {

			url = p.getURI().toURL();

		} catch (Exception e) {

			throw new RemoteServiceException("Malformed URL",e);

		}

		try {

			return WCSProvider.getConnectorFromURL(url);

		} catch (IOException e) {

			throw new RemoteServiceException("Error getting the connector",e);

		}

	}

	/**

	 * Crea las referencias al fichero y carga

	 * las estructuras con la informaci?n y los metadatos.

	 * @param proj Proyecci?n

	 * @param param Parametros de carga

	 * @throws NotSupportedExtensionException

	 * @throws RasterDriverException

	 */

	public void init (DataStoreParameters params,

			DataStoreProviderServices storeServices) throws InitializeException {

		setParam(storeServices, params);

		open = true;

		try {

			loadInitialInfo();

		} catch (RasterDriverException e) {

			throw new InitializeException(e.getMessage(), e);

		}

		stats = new RemoteDataStoreStatistics(this);

	}

	public static final WCSConnector getConnectorFromURL(URL url) throws IOException {

		WCSConnector drv = (WCSConnector) drivers.get(url);

		if (drv == null) {

			drv = new WCSConnector(url);

			drivers.put(url, drv);

		}

		return drv;

	}

	/**

	 * Obtiene el objeto que contiene que contiene la interpretaci?n de

	 * color por banda

	 * @return

	 */

	public ColorInterpretation getColorInterpretation() {

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

			ColorInterpretation colorInterpretation = new DataStoreColorInterpretation();

			colorInterpretation.initColorInterpretation(getBandCount());

			if(getBandCount() == 3) {

				colorInterpretation = DataStoreColorInterpretation.createRGBInterpretation();

			} else {

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

					colorInterpretation.setColorInterpValue(i, DataStoreColorInterpretation.GRAY_BAND);

				}

			}

			setColorInterpretation(colorInterpretation);

		}

		return super.getColorInterpretation();

	}

	/**

	 * Gets WCS parameters

	 * @return

	 */

	public WCSDataParameters getParameters() {

		return (WCSDataParameters)parameters;

	}

	public AffineTransform getAffineTransform() {

		Extent e = getExtent();

		double resolutionX = e.width() / getWidth();

		double resolutionY = e.height() / getHeight();

		ownTransformation = new AffineTransform(

				resolutionX,                        // ESCALADO en X

				0,                                  // CIZALLAMIENTO de la Y

				0,                                  // CIZALLAMIENTO de la X

				-resolutionY,                       // ESCALADO en Y

				e.getULX() - (resolutionX / 2),     // TRASLACION en X

				e.getULY() - (resolutionY / 2));    // TRASLACION en Y

		externalTransformation = (AffineTransform) ownTransformation.clone();

		return ownTransformation;

	}

	/**

	 * Calcula el extent en coordenadas del mundo real

	 * @return Extent

	 */

	public Extent getExtent() {

		WCSDataParametersImpl p = (WCSDataParametersImpl)parameters;

		try {

			p.setFormat("image/tiff");

			if(p.getSRSCode() == null){

				WCSConnector connector = WCSProvider.getConnectorFromURL(p.getURI().toURL());

				ArrayList srs = connector.getSRSs(p.getCoverageName());

				if(!srs.isEmpty() && !StringUtils.isBlank((String)srs.get(0))){

					p.setSRSID((String) srs.get(0));

				}else{

					return null;

				}

			}

			Rectangle2D r = getConnector().getFullExtent(p.getCoverageName(), p.getSRSCode());

			if(r == null)

				return null;

			return new ExtentImpl(r.getX(),  r.getY() + r.getHeight(), r.getX() + r.getWidth(), r.getY());

		} catch (RemoteServiceException e1) {

			e1.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		}

		return null;

	}

	public Rectangle2D getLayerExtent(String layerName, String srs) throws RemoteServiceException {

		return null;

	}

	public RasterProvider load() {

		return this;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

		open = false;

	}

	public Transparency getTransparency() {

		if(fileTransparency == null)

			fileTransparency = new DataStoreTransparency(getColorInterpretation());

		return fileTransparency;

	}

	public URI translateURI(URI uri) {

		return uri;

	}

	public void setView(Extent e) {

		viewRequest = e;

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		WCSDataParametersImpl p = (WCSDataParametersImpl)parameters;

		try {

			return getConnector().getWidth(p.getCoverageName());

		} catch (RemoteServiceException e) {

			e.printStackTrace();

		}

		return 0;

	}

	public double getHeight() {

		WCSDataParametersImpl p = (WCSDataParametersImpl)parameters;

		try {

			return getConnector().getHeight(p.getCoverageName());

		} catch (RemoteServiceException e) {

			e.printStackTrace();

		}

		return 0;

	}

	public Object readCompleteLine(int line, int band)

			throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		return null;

	}

	/**

	 * When the remote layer has fixed size this method downloads the file and return its reference.

	 * File layer has in the long side FIXED_SIZE pixels and the bounding box is complete. This file could be

	 * useful to build an histogram or calculate statistics. This represents a sample of data.

	 * @return

	 * @throws RasterDriverException

	 */

	public File getFileLayer() throws RasterDriverException {

		Extent e = getExtent();

		Rectangle2D bBox = new Rectangle2D.Double(e.getULX(), e.getLRY(), e.width(), e.height());

		WCSStatus wcsStatus = loadWCSStatus(bBox);

		return downloadFile(wcsStatus, e, (int)getWidth(), (int)getHeight());

	}

	/**

	 * Reads a complete block of data and returns an tridimensional array of the right type. This function is useful

	 * to read a file very fast without setting a view. In a WCS service when the size is fixed then it will read the

	 * entire image but when the source hasn't pixel size it will read a sample of data. This set of data will have

	 * the size defined in FIXED_SIZE.

	 *

	 * @param pos Posici?n donde se empieza  a leer

	 * @param blockHeight Altura m?xima del bloque leido

	 * @return Object que es un array tridimendional del tipo de datos del raster. (Bandas X Filas X Columnas)

	 * @throws InvalidSetViewException

	 * @throws FileNotOpenException

	 * @throws RasterDriverException

	 */

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

			throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

		File lastFile = getFileLayer();

		BandList bandList = new BandListImpl();

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

			try {

				bandList.addBand(new DatasetBandImpl(lastFile.getPath(), pos, Buffer.TYPE_BYTE, 3));