Application: gvSIG desktop » gvSIG raster

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.raster.wms.io</artifactId>

    <packaging>jar</packaging>

    <name>org.gvsig.raster.wms.io</name>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.raster.wms</artifactId>

        <version>2.2.254</version>

    </parent>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.cache.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.lib.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.remoteclient</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.wms.remoteclient</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.i18n</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.cresques.impl</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.se</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.lib</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.spi</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.api</artifactId>

            <scope>compile</scope>

        </dependency>

    <!--

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.generalpath</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.operation</artifactId>

            <scope>runtime</scope>

        </dependency>

    -->

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.downloader.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.apache.httpcomponents</groupId>

            <artifactId>httpcore</artifactId>

            <scope>compile</scope>

        </dependency>

    </dependencies>

</project>

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

org.gvsig.raster.wms.io.DefaultWMSIOLibrary

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

import java.util.Comparator;

import java.util.List;

import java.util.Objects;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

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

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

        	}

        return clone;

    }

    public void sort() {

        if(CollectionUtils.isEmpty(this.children)){

            return;

        }

        Collections.sort(this.children, new Comparator<WMSLayerNode>() {

            @Override

            public int compare(WMSLayerNode o1, WMSLayerNode o2) {

                return StringUtils.compareIgnoreCase(

                    Objects.toString(o1),

                    Objects.toString(o2)

                );

            }

        });

        for (WMSLayerNode child : this.children) {

            child.sort();

        }

    }

}

/* 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 java.util.logging.Level;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

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

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

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

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

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

        @Override

        public DataStoreParameters get(String layerName) {

            WMSDataParameters params = (WMSDataParameters) this.getStoredParameters();

            params.setLayerQuery(layerName);

            return params;

        }

	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;

	}

        @Override

        public void open() throws OpenException {

            try {

                this.connect(null);

            } catch (ConnectException ex) {

                throw new OpenException(this.getHost(), ex);

            }

        }

	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;

    }

    @Override

    public DataStore open(DataStoreParameters par) throws DataException {

        String layerName = "unknown";

        try {

            layerName = (String) par.getDynValue(WMSDataParametersImpl.FIELD_LAYERQUERY);

            DataManager datamanager = DALLocator.getDataManager();

            RasterDataStore store = (RasterDataStore) datamanager.openStore(NAME, par);

            store.setExplorer(this);

            return store;

        } catch (Exception ex) {

            throw new OpenException(layerName,ex);

        }

    }

    @Override

    public Object getProperty(String name) {

        if( StringUtils.equalsIgnoreCase("OnlineResources", name) ) {

            return this.getOnlineResources();

        }

        return super.getProperty(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.

 *

 */

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

/**

 * This class instances a regular WMS dimension. It handles single, multiple and

 * interval values and uses them as they were a point, a list or a regularly

 * split line, respectivelly.<br>

 * <p>

 * As far as it implements RemoteTimeDimension it uses the same interface and

 * documentation.

 * </p>

 * @author jaume dominguez faus (jaume.dominguez@iver.es)

 *

 */

public class DefaultDimension implements RemoteTimeDimension {

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

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

    static private final String letter = "[_$%a-zA-Z]";

    static private final String word = letter+"("+letter+"|"+digit+")+"; // TODO Should be * instead of + ??

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

    static private final String integerNumber = nonZeroDigit+digit+"+";

    static private final String dimensionItem = "("+floatingPointNumber+"|"+word+")";

    /**

     * regular expression for matching dimensions.

     */

    static private final String regexpDefaultDimensionExpression =

    	"("+floatingPointNumber+"/"+floatingPointNumber+"/"+floatingPointNumber+"|"+

    	    dimensionItem+"(,"+dimensionItem+")*)";

	private String name;

    private String unit;

    private String unitSymbol;

    private String expression;

    private String period;

    private Object minValue;

    private Object maxValue;

	private int type;

	private boolean compiled = false;

	public void loadFromState(PersistentState state) throws PersistenceException {

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

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

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

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

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

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

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

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

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

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		state.set("name", name);

		state.set("unit", unit);

		state.set("unitSymbol", unitSymbol);

		state.set("expression", expression);

		state.set("period", period);

		state.set("minValue", minValue);

		state.set("maxValue", maxValue);

		state.set("type", type);

		state.set("compiled", compiled);

	}	

	public static void registerPersistent() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

		if( definition == null ) {

			definition = manager.addDefinition(

					DefaultDimension.class,

					"DefaultDimension_Persistent",

					"DefaultDimension Persistence",

					null, 

					null

			);

		}