Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.wms.io.DefaultWMSIOLibrary

error_connecting=Error conectando con el servidor

malformed_url=URL mal formada

error_connecting=Error connecting with the server

malformed_url=Malformed URL

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

import org.gvsig.i18n.Messages;

import org.gvsig.raster.wms.io.time.DefaultDimension;

import org.gvsig.raster.wms.io.time.TimeDimension;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 *

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

 */

public class DefaultWMSIOLibrary extends AbstractLibrary {

	/*public DefaultWMSIOLibrary() {

		super(DefaultWMSIOLibrary.class,Library.TYPE.IMPL);

		require(ToolsLibrary.class);

		require(DALLibrary.class);

		require(DALFileLibrary.class);

	}*/

	@Override

	protected void doInitialize() throws LibraryException {

		//RasterLibrary.wakeUp();

		WMSLayerNode.registerPersistent();

		RemoteWMSStyle.registerPersistent();

		DefaultDimension.registerPersistent();

		TimeDimension.registerPersistent();

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

				DefaultWMSIOLibrary.class.getClassLoader(),

				DefaultWMSIOLibrary.class.getClass().getName());

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		WMSServerExplorerParameters.registerDynClass();

		WMSDataParametersImpl.registerDynClass();

		WMSProvider.register();

	}

}

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

import java.awt.Dimension;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.raster.wms.io.time.DefaultDimension;

import org.gvsig.raster.wms.io.time.RemoteTimeDimension;

import org.gvsig.raster.wms.io.time.TimeDimension;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

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

 * @author jaume

 */

@SuppressWarnings("unchecked")

public class WMSLayerNode implements Persistent {

    private String                         _name              = null;

    private String                         _title             = null;

	private List<String>                   srs                = null;

    private boolean                        queryable;

    private boolean                        transparency;

    private String                         lAbstract          = null;

    private String                         latLonBox          = null;

    private int                            selectedStyleIndex = 0;

    private List<RemoteWMSStyle>           styles             = new ArrayList<RemoteWMSStyle>();

    private List<RemoteTimeDimension>      dimensions         = null;

    private List<String>                   keywords           = null;

    private List<WMSLayerNode>             children           = new ArrayList<WMSLayerNode>();

    private WMSLayerNode                   _parent            = null;

	private Dimension                      fixedSize          = null;

	public void loadFromState(PersistentState state) throws PersistenceException {

		this._name = state.getString("_name");

		this._title = state.getString("_title");

		this.srs = state.getList("srs");

		this.queryable = state.getBoolean("queryable");

		this.transparency = state.getBoolean("transparency");

		this.lAbstract = state.getString("lAbstract");

		this.latLonBox = state.getString("latLonBox");

		this.selectedStyleIndex = state.getInt("selectedStyleIndex");

		this.styles = state.getList("styles");

		this.dimensions = state.getList("dimensions");

		this.keywords = state.getList("keywords");

		this.children = state.getList("children");

		this._parent = (WMSLayerNode)state.get("_parent");

		this.fixedSize = (Dimension)state.get("fixedSize");

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		state.set("_name", _name);

		state.set("_title", _title);

		state.set("srs", srs);

		state.set("queryable", queryable);

		state.set("transparency", transparency);

		state.set("lAbstract", lAbstract);

		state.set("latLonBox", latLonBox);

		state.set("selectedStyleIndex", selectedStyleIndex);

		state.set("styles", styles);

		state.set("dimensions", dimensions);

		state.set("keywords", keywords);

		state.set("children", children);

		state.set("_parent", _parent);

		state.set("fixedSize", fixedSize);

	}	

    public static void registerPersistent() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition("WMSLayerNode_Persistent");

		if( definition == null ) {

			definition = manager.addDefinition(

					WMSLayerNode.class,

					"WMSLayerNode_Persistent",

					"WMSLayerNode Persistence",

					null, 

					null

			);

		}

		definition.addDynFieldString("_name").setMandatory(false);

		definition.addDynFieldString("_title").setMandatory(false);

		definition.addDynFieldList("srs").setClassOfItems(String.class).setMandatory(false);

		definition.addDynFieldBoolean("queryable").setMandatory(false);

		definition.addDynFieldBoolean("transparency").setMandatory(false);

		definition.addDynFieldString("lAbstract").setMandatory(false);

		definition.addDynFieldString("latLonBox").setMandatory(false);		

		definition.addDynFieldInt("selectedStyleIndex").setMandatory(false);

		definition.addDynFieldList("styles").setClassOfItems(RemoteWMSStyle.class).setMandatory(false);

		definition.addDynFieldList("dimensions").setClassOfItems(RemoteTimeDimension.class).setMandatory(false);

		definition.addDynFieldList("keywords").setClassOfItems(String.class).setMandatory(false);

		definition.addDynFieldList("children").setClassOfItems(WMSLayerNode.class).setMandatory(false);

		definition.addDynFieldObject("_parent").setClassOfValue(WMSLayerNode.class).setMandatory(false);

		definition.addDynFieldObject("fixedSize").setClassOfValue(Dimension.class).setMandatory(false);

	}

	/**

     * @return Returns the name.

     */

    public String getName() {

        return _name;

    }

    public List<WMSLayerNode> getChildren() {

        return children;

    }

    /**

     * @param name The name to set.

     */

    public void setName(String name) {

        this._name = name;

    }

    /**

     * @return Returns the namedStyles.

     */

    public List<RemoteWMSStyle> getStyles() {

        return styles;

    }

    public List<String> getKeywords() {

    	return keywords;

    }

    /**

     * @return Returns the queryable.

     */

    public boolean isQueryable() {

        return queryable;

    }

    /**

     * @param queryable The queryable to set.

     */

    public void setQueryable(boolean queryable) {

        this.queryable = queryable;

    }

    /**

     * @return Returns the srs.

     */

    public List<String> getAllSrs() {

        if ((srs.size() == 0) && _parent!=null)

            return _parent.getAllSrs();

        return srs;

    }

    /**

     * @param srs The srs to set.

     */

    public void setSrs(List<String> srs) {

        this.srs = srs;

    }

    /**

     * @return Returns the title.

     */

    public String getTitle() {

        return _title;

    }

    public void setTitle(String title) {

        this._title = title.trim();

    }

    /**

     * @return Returns the transparency.

     */

    public boolean isTransparent() {

        return transparency;

    }

    /**

     * @param transparency The transparency to set.

     */

    public void setTransparency(boolean transparency) {

        this.transparency = transparency;

    }

    /**

     * Sets the list of sons of this layer.

     * @param children

     */

    public void setChildren(List<WMSLayerNode> children) {

        this.children = children;

    }

    public WMSLayerNode getParent() {

        return _parent;

    }

    public void setParent(WMSLayerNode parentNode) {

        this._parent = parentNode;

    }

    public List<RemoteTimeDimension> getDimensions() {

        return dimensions;

    }

    /**

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

    }

    /**

     * @param name

     * @param units

     * @param unitSymbol

     * @param dimensionExpression

     */

    public void addDimension(String name, String units, String unitSymbol, String dimExpression) {

    	if (dimensions == null)

    		dimensions = new ArrayList<RemoteTimeDimension>();

    	if (name.equalsIgnoreCase("time")) {

    		try {

    			dimensions.add(new TimeDimension(units, unitSymbol,

    					dimExpression));

    		} catch (IllegalArgumentException e) {

    			// The TIME class does not yet support this kind of time so it

    			// will be treated as a DefaultDimension

    			dimensions.add(new DefaultDimension(name.toUpperCase(),

    					units, unitSymbol, dimExpression));

    		}

    	} else if (name.equalsIgnoreCase("sequence")) {

    		// TODO Not yet implemented

    		return;

    	} else {

    		dimensions.add(new DefaultDimension(name.toUpperCase(), units,

    				unitSymbol, dimExpression));

    	}

    }

    public void setLatLonBox(String _latLonBox) {

        latLonBox = _latLonBox;

    }

    public String getLatLonBox() {

        return latLonBox;

    }

    /**

     * When a server cannot renderize images but just server them in constant size and

     * BBox, the layer must have this value set in order to correctly work.

     *

     * @param fixedWidth - the constant value for the image width

     * @param fixedHeight - the constant value for the image height

     */

    public void setFixedSize(int fixedWidth, int fixedHeight) {

		fixedSize = new Dimension(fixedWidth, fixedHeight);

	}

	public Dimension getFixedSize() {

		return fixedSize;

	}

	public boolean isSizeFixed() {

		return fixedSize            != null &&

		       fixedSize.getWidth()  > 0    &&

		       fixedSize.getHeight() > 0;

	}

    /**

     *

     * @param _name

     * @param _title

     * @param _abstract

     */

    public void addStyle(org.gvsig.remoteclient.wms.WMSStyle style) {

    	if (style.getName().equalsIgnoreCase("default"))

    		selectedStyleIndex = styles.size();

        if (styles == null)

            styles = new ArrayList<RemoteWMSStyle>();

        styles.add(new RemoteWMSStyle(style, this));

    }

    public RemoteWMSStyle getSelectedStyle() {

    	if (styles == null || selectedStyleIndex > styles.size() - 1 || selectedStyleIndex == -1)

    		return null;

    	return (RemoteWMSStyle) styles.get(selectedStyleIndex);

    }

    public void setSelectedStyleByIndex(int index) {

		selectedStyleIndex = index;

	}

	public void setSelectedStyleByName(String styName) {

		if (styName == null || styName.equals(""))

			setSelectedStyleByIndex(-1);

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

			RemoteWMSStyle sty = (RemoteWMSStyle) styles.get(i);

			if (sty.name.equalsIgnoreCase(styName)) {

				setSelectedStyleByIndex(i);

				return;

			}

		}

		setSelectedStyleByIndex(-1);

	}

	public void addKeyword(String keyword) {

		if (keywords == null)

			keywords = new ArrayList<String>();

		keywords.add(keyword);

	}

    public String toString(){

    	String str;

    	if (getName()==null)

    		str = getTitle();

    	else

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

        return str;

    }

    public Object clone() throws CloneNotSupportedException {

        WMSLayerNode clone       = new WMSLayerNode();

        clone._name              = this._name;

        clone.queryable          = this.queryable;

        clone.srs                = this.srs;

        clone._title             = this._title;

        clone.transparency       = this.transparency;

        clone.styles             = new ArrayList<RemoteWMSStyle>();

        clone.lAbstract          = this.lAbstract;

        clone.latLonBox          = this.latLonBox;

        clone.selectedStyleIndex = this.selectedStyleIndex;

        if (keywords != null) {

        	clone.keywords = new ArrayList<String>(keywords.size());

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

				clone.keywords.add((String) keywords.get(i));

			}

        }

        if (styles != null)

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

        		RemoteWMSStyle sty = (RemoteWMSStyle) this.styles.get(i).clone();

        		((RemoteWMSStyle)sty).parent = this;

        		clone.styles.add(sty);

        	}

        if (dimensions!=null)

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

        		clone.dimensions = new ArrayList<RemoteTimeDimension>();

        		clone.dimensions.add((RemoteTimeDimension) this.dimensions.get(i));

        	}

        return clone;

    }

}

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

import java.awt.geom.Rectangle2D;

import java.io.File;

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

import java.util.Hashtable;

import java.util.List;

import java.util.Vector;

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

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

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

import org.gvsig.i18n.Messages;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Explorer for a WMS server

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

 */

public class WMSServerExplorer extends AbstractDataServerExplorer implements RasterDataServerExplorer, DataServerExplorerProvider {

	public static final String          NAME                     = WMSProvider.NAME;

	private WMSConnector                connector                = null;

//	private WMSServerExplorerParameters parameters               = null;

	private Logger                      log                      = LoggerFactory.getLogger(WMSServerExplorer.class);

	public WMSServerExplorer(

			WMSServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

                super(parameters, services);

//		this.parameters = parameters;

	}

	/**

	 * Gets the provider's name

	 * @return

	 */

	public String getDataStoreProviderName() {

		return WMSProvider.NAME;

	}

	public String getDescription() {

		return WMSProvider.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<String> getDataStoreProviderNames() {

		return null;

	}

	public WMSServerExplorerParameters getParameters() {

		return (WMSServerExplorerParameters) super.getParameters();

	}

	public List<DataStoreParameters> list() throws DataException {

		return null;

	}

	public List<DataStoreParameters> list(int mode) throws DataException {

		return null;

	}

	public void remove(DataStoreParameters parameters) throws DataException {

	}

	public String getProviderName() {

		return null;

	}

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

	//Connector

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

	public DataStoreParameters getStoredParameters() {

		DataManager manager = DALLocator.getDataManager();

		WMSDataParameters params = null;

		try {

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

			params.setURI(new URI(getParameters().getHost()));

			/*if(WMSProvider.TILED) {

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

				tileParams.setDataParameters(params);

				return tileParams;

			} */

		} catch (InitializeException e) {

			log.debug("Error initializating parameters", e);

		} catch (ProviderNotRegisteredException e) {

			log.debug("Error getting parameters", e);

		} catch (URISyntaxException e) {

            log.debug("Can't create URI from "+getParameters().getHost(), e);

        }

		return params;

	}

	public void connect(ICancellable cancellable) throws ConnectException {

		connect(cancellable, false);

	}

	/**

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

	 * the basic information to make requests.

	 * @throws RemoteServiceException

	 */

	public void connect(ICancellable cancellable, boolean updateCache) throws ConnectException {

		URL url = null;

		try {

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

		} catch (Exception e) {

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

		}

        try {

        	connector = WMSProvider.getConnectorFromURL(url, updateCache);

        	if (!connector.connect(this.getParameters(), updateCache, 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(getParameters().getHost());

			File file = Utilities.downloadFile(url, "checkhost.dat", null);

		} catch (Exception 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.getAbstract();

		return null;

	}

	/**

	 * Gets the list of raster formats supported by the server

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public String[] getFormats() {

		if(connector != null) {

			Vector f = connector.getFormats();

			ArrayList formatos = new ArrayList();

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

				formatos.add(f.elementAt(i));

			}

			return (String[]) formatos.toArray(new String[0]);

		}

		return null;

	}

	/**

	 * Gets the list of raster information formats supported by the server

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public String[] getInfoFormats() {

		if(connector != null) {

			Vector f = connector.getInfoFormats();

			ArrayList formatos = new ArrayList();

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

				formatos.add(f.elementAt(i));

			}

			return (String[]) formatos.toArray(new String[0]);

		}

		return null;

	}

	/**

	 * Gets a tree of nodes which represents the server information

	 * @return

	 */

	public WMSLayerNode getLayerTree() {

		if(connector != null) {

			return connector.getLayersTree();

		}

		return null;

	}

	/**

	 * Gets the server title

	 * @return

	 */

	public String getServerType() {

		if (getVersion() == null)

			return "WMS";

        return "WMS "+ getVersion();

	}

	/**

	 * Gets the online resources

	 * @return

	 */

	public Hashtable getOnlineResources() {

		if(connector != null) {

			return connector.getOnlineResources();

		}

		return null;

	}

	/**

	 * Gets the protocol supported by the server

	 * @return

	 */

	public String getVersion() {

		if(connector != null) {

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

		}

		return null;

	}

    public Rectangle2D getLayersExtent(String[] layerName, String srs) {

    	return connector.getLayersExtent(layerName, srs);

    }

    /**

	 * Gets a layer using its name

	 * @param layerName

	 * @return

	 */

    public WMSLayerNode getLayer(String layerName) {

    	return connector.getLayer(layerName);

    }

    /**

	 * Gets the host URI

	 * @return

	 */

	public String getHost() {

		return getParameters().getHost();

	}

	public Rectangle2D getBoundingBox(String[] layerNames, String srs) {

		return connector.getLayersExtent(layerNames, srs);

    }

	public boolean isQueryable() {

    	return connector.isQueryable();

    }

	/**

	 * Gets the title

	 * @return

	 */

	public String getTitle() {

		return null;

	}

    /**

     * @return The title of the service offered by the WMS server.

     */

    public String getServiceTitle() {

		return connector.getServiceTitle();

    }

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		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.wms.io.downloader;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.util.List;

import java.util.Vector;

import org.cresques.cts.IProjection;

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

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

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

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

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

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

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

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

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.tile.BaseTileDownloader;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.raster.wms.io.RemoteWMSStyle;

import org.gvsig.raster.wms.io.WMSConnector;

import org.gvsig.raster.wms.io.WMSDataParameters;

import org.gvsig.raster.wms.io.WMSProvider;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.tools.locator.LocatorException;

/** 

 * Tile getter 

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

 */

public class TileDownloaderForWMS extends BaseTileDownloader {

	private WMSConnector             connector  = null;

	private Extent                   lyrExtent  = null;

	public TileDownloaderForWMS(RasterDataStore store,

			int tilePxWidth,

			int tilePxHeight) throws RemoteServiceException {

		super(store, tilePxWidth, tilePxHeight);

		this.connector = ((WMSProvider)store.getProvider()).getConnector();

		lyrExtent = store.getExtent();

	}

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

			//Extent tileExtent = RasterLocator.getManager().getDataStructFactory().createExtent(r);

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

			WMSStatus wmsStatus = new WMSStatus();

			wmsStatus.setLayerNames(Utilities.createVector(p.getLayerQuery(), ","));

			wmsStatus.setSrs(p.getSRSCode());

			wmsStatus.setFormat(p.getFormat());

			List<RemoteWMSStyle> listStyles = p.getStyles();

			Vector<?> v = listStyles != null ? new Vector<RemoteWMSStyle>(listStyles) : null;

			wmsStatus.setStyles(v);

			wmsStatus.setDimensions(p.getDimensions());

			wmsStatus.setTransparency(p.isWmsTransparent());

			wmsStatus.setOnlineResource((String) p.getOnlineResource().get("GetMap"));

			wmsStatus.setExtent(r);

			wmsStatus.setHeight(tile.getHeightPx());

			wmsStatus.setWidth(tile.getWidthPx());

			wmsStatus.setXyAxisOrder(p.isXyAxisOrder());

			IProjection proj = (IProjection)p.getSRS();

			if(proj != null)

				wmsStatus.setProjected(proj.isProjected());

			connector.getMap(wmsStatus, 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;

	}

	@SuppressWarnings("unused")

	private void fuseFiles(Extent dstExtent, int dstWidth, int dstHeight, File src, File dst, double pixelSize) 

		throws RasterDriverException, ProcessInterruptedException, ProviderNotRegisteredException, InitializeException, LocatorException, NotSupportedExtensionException, IOException, QueryException {

		RasterProvider provider = DefaultProviderServices.loadProvider(src);

		RasterQuery q = RasterLocator.getManager().createQuery();

		Buffer bufInput = store.query(q);

		Buffer bufDst = DefaultRasterManager.getInstance().createMemoryBuffer(provider.getDataType()[0], dstWidth, dstHeight, provider.getBandCount(), true);

		String extension = RasterLocator.getManager().getFileUtils().getExtensionFromFileName(src.getAbsolutePath());

		RasterLocator.getManager().getRasterUtils().copyToBuffer(

				bufDst, 

				dstExtent, 

				bufInput, 

				lyrExtent, 

				pixelSize, 

				provider.getColorInterpretation().hasAlphaBand());

		RasterLocator.getManager().getProviderServices().exportBufferToFile(

				bufDst, 

				provider.getCellSize(), 

				extension, 

				provider.getColorInterpretation().hasAlphaBand(), 

				dst, 

				dstExtent, 

				provider.getColorInterpretation());

	}

}

/* 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.wms.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.wms.io.WMSProvider;

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 WMSTileServer implements TileServer {

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

	private CacheStruct                struct               = null;

	private Downloader                 downloader           = null;

	private RasterDataStore            store                = null;

	private String                     suffix               = ".tif";

	public WMSTileServer(RasterDataStore store) {

		this.store = store;

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

	}

	public Downloader getDownloader() {

		if(downloader == null ||

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

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

			try {

				downloader = new TileDownloaderForWMS(

						store,

						TileCacheLibrary.ALTERNATIVE_TILESIZE,

						TileCacheLibrary.ALTERNATIVE_TILESIZE);

			} 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(),

					Double.POSITIVE_INFINITY,//provider.getCellSize(),

					TileCacheLibrary.ALTERNATIVE_TILESIZE,

					TileCacheLibrary.ALTERNATIVE_TILESIZE,

					((RasterProvider)store.getProvider()).getURIOfFirstProvider().getPath(),

					((WMSProvider)store.getProvider()).getParameters().getLayerQuery(),

					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 TileDownloaderForWMS(store,

							struct.getTileSizeByLevel(0)[0],

							struct.getTileSizeByLevel(0)[1]);

				} 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.wms.io package documentation</title>

</head>

<body>

	<p>WMS 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.wms.io.time;

import org.gvsig.tools.persistence.Persistent;

/**

 * 

 * @author jaume

 *

 */

public interface RemoteTimeDimension extends Persistent {

	public static int SINGLE_VALUE = 0;

	public static int MULTIPLE_VALUE = 1;

	public static int INTERVAL = 2;

    /**

     * Return the dimension's name. This value is the value that will be used in

     * a GetMap request.

     * 

     * @return String containing the name of this dimension.

     */

    public String getName();

    /**

     * Return the unit used by this dimension.

     * @return

     */

    public String getUnit();

    /**

     * Returns the unit symbol (i.e. 'm', 's', or 'l' for meters, seconds, or liters respectively) 

     * @return

     */

    public String getUnitSymbol();

    /**

     * This method returns the <b>lowest</b> value of this dimension if this dimension is

     * specified as an interval or as a set of values, or the value specified if it

     * was a single value. 

     * @return String containing the coded value.

     */

    public String getLowLimit();

    /**

     * This method returns the <b>highest</b> value of this dimension if this dimension is

     * specified as an interval or as a set of values, or the value specified if it

     * was a single value. 

     * @return String containing the coded value.

     */

    public String getHighLimit();

    /**

     * This method returns the resolution supported by this dimension. This

     * means the step lenght between two consecutive points along the

     * dimension's axis. 

     * @return String containing the coded value, or null if no value for resolution.

     * @deprecated

     */

    public String getResolution();

    /**

     * Checks if the value represented as string is a valid value by checking

     * if the dimensions supports it. It should be true if one of the following is

     * true:

     * <p>

     * <ol> 

     * <li>

     *  The dimension <b>supports nearest values</b> and <b>the value is greather

     *  or  equal than the low limit</b> and <b>less or equal than the high limit</b>.  

     *  </li>

     *  <li>

     *  The value matches in one of the points defined by the low and high limits, and

     *  the resolution value.

     *  </li>

     * </ol>

     * </p>

     * @param value

     * @return

     */

    public boolean isValidValue(String value);

    /**

     * Return the value of the String passed in the dimension's unit-natural type.

     * @param value

     * @return

     */

    public Object valueOf(String value) throws IllegalArgumentException;

    /**

     * Returns the value that would be at the position passed as argument.

     * @param pos

     * @return

     * @throws ArrayIndexOutOfBoundsException

     */

    public String valueAt(int pos) throws ArrayIndexOutOfBoundsException;

    /**

     * The amount of positions that this dimension contains. 

     * @return -1 if the dimension is not recognized, the amount otherwise

     */

    public int valueCount();

    /**

     * Returns the expression describing this WMS Dimension

     */

    public String getExpression();

    /**

     * Sets the expression describing this WMS Dimension

     * @throws IllegalArgumentException

     */

    public void setExpression(String expr);

    /**

	 * Returns the type of the dimension expression.<br>

	 * Possible values are:

	 * <ol>

	 * 	<li>

	 * 		<b>IFMapWMSDimension.SINGLE_VALUE</b>

	 * 		<b>IFMapWMSDimension.MULTIPLE_VALUE</b>

	 * 		<b>IFMapWMSDimension.INTERVAL</b>

	 * 	</li>

	 * </ol>

	 * @return int

	 */

    public int getType();

    /**

     * Analyzes and establishes the starting values for this dimension. No operation of this

     * dimension can be called before the dimension has been compiled.

     * 

     * @throws IllegalArgumentException

     */

    public void compile() throws IllegalArgumentException;

}

/* 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.wms.io.time;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.GregorianCalendar;

import java.util.List;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Class for WMS TIME dimension from a WMS. It allows you to handle the correct

 * values for this kind of dimension.

 * <br>

 * <p>

 * At the moment this class was written the WMS TIME dimension is defined as the

 * ISO8601 standard for expressing times.

 * </p>

 * <br>

 * <p>

 * As far as this class implements IFMapWMSDimension it uses the same interface

 * and documentation.

 * </p>

 *

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

 */

public class TimeDimension implements RemoteTimeDimension {

	static private final byte   YEAR_FORMAT           = 1;

	static private final byte   YEAR_TO_MONTH_FORMAT  = 2;

	static private final byte   YEAR_TO_DAY_FORMAT    = 3;

	static private final byte   FULL_FORMAT           = 4;

    static private final long   millisXsec            = 1000;

    static private final long   millisXminute         = 60 * millisXsec;

    static private final long   millisXhour           = 60 * millisXminute;

    static private final long   millisXday            = 24 * millisXhour;

    static private final long   millisXmonth          = 30 * millisXday;

    //(1 year = 365 days 6 hours 9 minutes 9,7 seconds)

    static private final long   millisXyear           = (365*millisXday) + (6*millisXhour) + (9*millisXminute) + 9700;

    static private final String digit                 = "[0-9]";

    static private final String nonZeroDigit          = "[1-9]";

    static private final String seconds               = "([0-5]" + digit + "((\\.|,)" + digit + digit+ "?" + digit + "?" + ")?)";

    static private final String minutes               = "([0-5]" + digit + ")";

    static private final String hours                 = "(0" + digit + "|1" + digit + "|2[0-3])";

    static private final String time                  = hours + ":" + minutes + "(:" + seconds + ")?";

    static private final String days                  = "(0?" + nonZeroDigit + "|1" + digit + "|2" + digit + "|30|31)";

    static private final String months                = "(0?" + nonZeroDigit + "|10|11|12)";

    static private final String year                  = "(" + digit + digit + ")";

    static private final String century               = "(" + digit + digit + ")";

    static private final String floatingPointNumber   = "(" + digit + "+(\\." + digit + "+)?)";

    private String              unit;

	private String              unitSymbol;

	private List<GregorianCalendar>   

	                            valueList;

	private boolean             compiled;

	private boolean             isGeologic;

	private String              expression;

	private int                 type;

	private byte                format               = 0;

    static private final String regexDateExtendedForBCE1 = "B?"+century+year;

    static private final String regexDateExtendedForBCE2 = "B?"+century+year+"-"+months;

    static private final String regexDateExtendedForBCE3 = "B?"+century+year+"-"+months+"-"+days;

    static private final String regexDateExtendedForBCE4 = "B?"+century+year+"-"+months+"-"+days+"(T| )"+time+"Z";

    // Note: in WMS 1.1.0 the suffix Z is optional

    static private final String regexDateExtendedForBCE =

        "(" +  regexDateExtendedForBCE1  + "|"

            +  regexDateExtendedForBCE2  + "|"

            +  regexDateExtendedForBCE3  + "|"

            +  regexDateExtendedForBCE4  +      ")";

    static private final String periodMagnitude = "(Y|M|D)";

    static private final String p1 = "(("+digit+")+"+periodMagnitude+")";

    static private final String timeMagnitude = "(H|M|S)";

    static private final String p2 = "("+floatingPointNumber+timeMagnitude+")";

    static private final String regexPeriod = "P(("+p1+"+"+"(T"+p2+")*)|("+p1+"*"+"(T"+p2+")+))";

    static private final String regexIntervalTimeDimension =

        "("+regexDateExtendedForBCE+")/("+regexDateExtendedForBCE+")/("+regexPeriod+")";

    static private final String geologicDatasets = "(K|M|G)";

    static private final String regexDateForGeologicDatasets = geologicDatasets+floatingPointNumber;

	@SuppressWarnings("unchecked")

	public void loadFromState(PersistentState state) throws PersistenceException {

		this.unit = state.getString("unit");

		this.unitSymbol = state.getString("unitSymbol");

		List<String> list = (List<String>)state.getList("valueList");

		valueList = convertStringListToGregorianCalendarList(list);

		this.compiled = state.getBoolean("compiled");

		this.isGeologic = state.getBoolean("isGeologic");

		this.expression = state.getString("expression");

		this.type = state.getInt("type");

		this.format = (byte)state.getInt("format");

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		state.set("unit", unit);

		state.set("unitSymbol", unitSymbol);

		state.set("valueList", convertGregorianCalendarListToStringList(valueList));

		state.set("compiled", compiled);