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 org.gvsig.i18n.Messages;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 *

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

 */

public class DefaultWCSIOLibrary extends AbstractLibrary {	

	public DefaultWCSIOLibrary() {

		/*super(DefaultWCSIOLibrary.class,Library.TYPE.IMPL);

		require(ToolsLibrary.class);

		require(DALLibrary.class);

		require(DALFileLibrary.class);*/

	}

	@Override

	protected void doInitialize() throws LibraryException {

		//RasterLibrary.wakeUp();

		WCSDataParametersImpl.registerDynClass();

		Messages.addResourceFamily("org.gvsig.raster.wcs.io.i18n.text",

				DefaultWCSIOLibrary.class.getClassLoader(),

				DefaultWCSIOLibrary.class.getClass().getName()); 

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		WCSServerExplorerParameters.registerDynClass();

		WCSDataParametersImpl.registerDynClass();

		WCSProvider.register();

	}

}

package org.gvsig.raster.wcs.io.downloader;

import java.awt.geom.Rectangle2D;

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

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

import org.gvsig.raster.wcs.io.WCSDataParametersImpl;

import org.gvsig.remoteclient.wcs.WCSStatus;

/** 

 * Tile getter 

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

 */

public class TileDownloaderForWCS extends BaseTileDownloader {

	private WCSConnector             connector  = null;

	public TileDownloaderForWCS(RasterDataStore store, 

			int tilePxWidth,

			int tilePxHeight,

			WCSConnector connector) {

		super(store, tilePxWidth, tilePxHeight);

		this.connector = connector;

	}

	public synchronized Tile downloadTile(Tile tile) throws TileGettingException {

		try {

			Rectangle2D r = new Rectangle2D.Double(tile.getExtent().getMinX(), 

					tile.getExtent().getMinY() - tile.getExtent().getHeight(), 

					tile.getExtent().getWidth(), 

					tile.getExtent().getHeight());

			WCSDataParametersImpl p = (WCSDataParametersImpl)store.getParameters();

			WCSStatus wcsStatus = new WCSStatus();

			wcsStatus.setCoveraName(p.getCoverageName());

			wcsStatus.setSrs((String)p.getSRSCode());

			wcsStatus.setFormat((String)p.getFormat());

			wcsStatus.setDepth(p.getDepth());

			wcsStatus.setOnlineResource(p.getOnlineResource() != null ? (String) p.getOnlineResource().get("GetCoverage") : null);

			wcsStatus.setExtent(r);

			wcsStatus.setHeight(tile.getHeightPx());

			wcsStatus.setWidth(tile.getWidthPx());

			connector.getCoverageURL(wcsStatus, tile.getCancelled(), tile.getFile());

			//Si borramos el rmf no se puede leer la etiqueta Alpha. En caso de que se modifique jgdal para

			//poder guardar esta etiqueta deberiamos borrar el rmf para ahorrar ficheros

			//File rmf = new File(tile.getFile().getAbsolutePath() + ".rmf");

			//if(rmf.exists())

				//rmf.delete();

		} catch (RemoteServiceException e) {

			throw new TileGettingException(e);

		}

		readTileFromDisk(tile);

		return tile;

	}

}

package org.gvsig.raster.wcs.io.downloader;

import org.cresques.cts.IProjection;

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

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

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

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

import org.gvsig.raster.cache.tile.TileCacheLibrary;

import org.gvsig.raster.cache.tile.TileCacheLocator;

import org.gvsig.raster.cache.tile.TileCacheManager;

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.impl.provider.RasterProvider;

import org.gvsig.raster.wcs.io.WCSProvider;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/** 

* Data server for the tile cache in a WMSProvider 

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

*/

public class WCSTileServer implements TileServer {

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

	private CacheStruct                struct               = null;

	private Downloader                 downloader           = null;

	private RasterDataStore            store                = null;

	private String                     suffix               = ".tif";

	public WCSTileServer(RasterDataStore store) {

		this.store = store;

		this.suffix = ((RasterProvider)store.getProvider()).getFileSuffix();

	}

	public Downloader getDownloader() {

		if(downloader == null ||

		   ((TileDownloaderForWCS)downloader).getTileSize()[0] != TileCacheLibrary.ALTERNATIVE_TILESIZE ||

		   ((TileDownloaderForWCS)downloader).getTileSize()[1] != TileCacheLibrary.ALTERNATIVE_TILESIZE) {

			try {

				downloader = new TileDownloaderForWCS(

						store, 

						TileCacheLibrary.ALTERNATIVE_TILESIZE, 

						TileCacheLibrary.ALTERNATIVE_TILESIZE, 

						((WCSProvider)store.getProvider()).getConnector());

			} catch (RemoteServiceException e) {

				return null;

			}

		}

		return downloader;

	}

	public CacheStruct getStruct() {

		if(struct == null) {

			TileCacheManager  manager = TileCacheLocator.getManager();

			int coordinates = CacheStruct.FLAT;

			if(store.getProjection() != null)

				coordinates = (store.getProjection() != null && store.getProjection().isProjected()) ? CacheStruct.FLAT : CacheStruct.GEOGRAFIC;

			else {

				Extent e = store.getExtent();

				if(e.getULX() >= -180 && e.getULX() <= 180 && e.getLRX() >= -180 && e.getLRX() <= 180 && 

					e.getULY() >= -90 && e.getULY() <= 90 && e.getLRY() >= -90 && e.getLRY() <= 90) {

					coordinates = CacheStruct.GEOGRAFIC;

				}

			}

			String epsg = null;

			IProjection proj = store.getProjection();

			if(proj != null)

				epsg = proj.getAbrev();

			struct = manager.createCacheStructure(coordinates, 

					TileCacheLibrary.DEFAULT_LEVELS, 

					store.getExtent().toRectangle2D(), 

					store.getCellSize(), 

					TileCacheLibrary.ALTERNATIVE_TILESIZE, 

					TileCacheLibrary.ALTERNATIVE_TILESIZE,

					((WCSProvider)store.getProvider()).getURIOfFirstProvider(),

					((WCSProvider)store.getProvider()).getParameters().getCoverageName(),

					TileCacheLibrary.DEFAULT_STRUCTURE,

					RasterLibrary.pathTileCache,

					getFileSuffix(),

					epsg,

					0);

		}

		return struct;

	}

	public void setStruct(CacheStruct struct) {

		if(struct != null) {

			this.struct = struct;

			if(struct.getTileSizeByLevel(0) != null) {

				try {

					downloader = new TileDownloaderForWCS(store, 

							struct.getTileSizeByLevel(0)[0], 

							struct.getTileSizeByLevel(0)[1],

							((WCSProvider)store.getProvider()).getConnector());

				} catch (RemoteServiceException ex) {

					logger.error("Constructing TileDownloaderForWCS: " + ex.getMessage());

				}

			}

		}

	}

	public String getFileSuffix() {

		return suffix;

	}

	public void setFileSuffix(String extension) {

		this.suffix = extension;

	}

}

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>org.gvsig.raster.wcs.io package documentation</title>

</head>

<body>

	<p>WCS provider</p>

</body>

</html>

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

import java.net.URLConnection;

import java.util.Hashtable;

import java.util.List;

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;

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

		/*if(connector != null) {

			return connector.getOnlineResources();

		}*/

		return null;

	}

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

	//Connector

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

	public DataStoreParameters getStoredParameters() {

		DataManager manager = DALLocator.getDataManager();

		WCSDataParametersImpl params = null;

		try {

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

			/*if(WCSProvider.TILED) {

				TileDataParameters tileParams = (TileDataParameters) manager.createStoreParameters("Tile Store");

				tileParams.setDataParameters(params);

				return tileParams;

			} */

		} catch (InitializeException e) {

			e.printStackTrace();

		} catch (ProviderNotRegisteredException e) {

			e.printStackTrace();

		}

		params.setURI(parameters.getHost());

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

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

import java.util.Hashtable;

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

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; 

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

	}