Application: gvSIG desktop » gvSIG raster

*

* 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

* MA  02110-1301, USA.

*/

package org.gvsig.raster.wms.app.wmsclient.layer;

import java.awt.Dimension;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.andami.PluginServices;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class FLyrWMS extends DefaultFLyrRaster {

	public static final String           PERSISTENT_NAME           = "FLyrWMS_Persistent";

	public static final String           PERSISTENT_DESCRIPTION    = "FLyrWMS Persistent Definition";

	private static final GeometryManager geomManager               = GeometryLocator.getGeometryManager();

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

	private boolean 					 mustSplitRequest          = false;

			logger.error("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), this, e);

		}

	}

   public FLyrWMS(DataStoreParameters dataStoreParameters) throws Exception {

        this();

        //Create the explorer and connect

        DataManager dataManager = DALLocator.getDataManager();

               dataManager.createServerExplorerParameters(WMSServerExplorer.NAME);

            (WMSServerExplorer) dataManager.openServerExplorer(WMSServerExplorer.NAME, explorerParams);

        wmsServerExplorer.connect(null, ((RemoteStoreParameters)dataStoreParameters).isDeletingCache());

        //Set the parameters

        setParameters((WMSDataParameters)dataStoreParameters);

        setExplorer(wmsServerExplorer);

    }

	public static DataStore createDataStore(String host, IProjection srs) throws InitializeException {

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

		RasterDataParameters params = null;

		} catch (ProviderNotRegisteredException e) {

			return null;

		}

		params.setSRS(srs);

		try {

			return dataman.openStore(params.getDataStoreName(), params);

		} catch (ValidateDataParametersException e) {

		}

		return (String)formats.get(0);

	}

	public static void registerPersistent() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

					FLyrWMS.class,

					"FLyrWMS_Persistent",

					"FLyrWMS Persistent Definition",

					null

			);

			definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE, DefaultFLyrRaster.PERSISTENT_NAME);

		}

		DefaultFLyrRaster.registerPersistence(definition);

	}

	public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

			Cancellable cancel, double scale) throws ReadException {

		TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

		manager.add(taskStatus);

		taskStatus.setAutoremove(true);

		splitRequestCalculation(viewPort.getImageWidth(), viewPort.getImageHeight());

		if(!firstLoad) {

			try {

				initFilters();

			}

			firstLoad = true;

		}

		enableStopped();

		if(recalcLevel) {

			double pixelSize = viewPort.getEnvelope().getLength(0) / (double)viewPort.getImageWidth();

			zoomLevel = dataStore.getNearestLevel(pixelSize);

		}

		disableStopped();

	}

	/**

	 * This is the method used to draw a tile in a WMS mosaic layer.

	 * @throws LoadLayerException

			Rectangle2D vpRect = getRectable2DFromEnvelope(vpEnv);

			Rectangle2D layerRect = getRectable2DFromEnvelope(layerEnv);

			// 2. Intersect layer and viewport extents to get the area of interest

			Rectangle2D.intersect(layerRect, vpRect, requestedRect);

			// 3. Compute image size in pixels from the requested Extent

			if ((wImg <= 0) || (hImg <= 0)) {

				return;

			}

			// 4. compute exactly the requested extent (from the rounded image size)

			// ensuring we are still within the layer extent

			double worldWidth = Math.abs((double)wImg/scalex);

			else {

				worldY = requestedRect.getMinY();

			}

			Envelope requestedEnvelope = geomManager.createEnvelope(requestedRect.getMinX(),

					requestedRect.getMinY(),

					requestedRect.getMaxX(),

					requestedRect.getMaxY(),

					SUBTYPES.GEOM2D);

			Extent requestedExtent = rManager.getDataStructFactory().createExtent(

					requestedEnvelope.getMinimum(1));

			// 5. compute the new AffineTransform (ViewPort class can do it for us

			auxVp.setImageSize(sz);

			auxVp.setEnvelope(requestedEnvelope);

			// 6. compute tile offeset. It is the sum of the original viewport offset

			// plus the offset introduced by intersecting layer and viewport extents

			double offsetX = vp.getOffset().getX();

		} catch (CreateEnvelopeException e) {

			drawingError(e);

		} finally {

		}

	}

	private void drawingError(Exception e) {

		setAvailable(false);

		JOptionPane.showMessageDialog(null, "Problems drawing this layer:" + e.getMessage(), Messages.getText("Error"), JOptionPane.ERROR_MESSAGE);

		logger.info("Problems drawing this layer:" + e.getMessage(), e);

	/**

	 * @see com.iver.cit.gvsig.fmap.layers.FLayer#print(java.awt.Graphics2D,

	@SuppressWarnings({ "unchecked", "rawtypes" })

	public String toMapContext(String mapContextVersion) {

		XmlBuilder xml = new XmlBuilder();

		String query = getParameters().getLayerQuery();

		String[] layerNames = query.split(",");

		List<RemoteWMSStyle> styleList = getParameters().getStyles();

	public boolean isTiled() {

		return mustSplitRequest;

	}

	private void splitRequestCalculation(int width, int height) {

            RasterDataStore store = this.getDataStore();

            if( store == null ) {

		if (!getParameters().getURI().equals(aLayer.getParameters().getURI())) {

			return false;

		}

		if (!p.getFormat().equals(aLayer.getParameters().getFormat())) {

			return false;

		}

		}

		return null;

	}

	public boolean isRemote() {

		return true;

	}

		}

		return null;

	}*/

	@Override

	public String getFileFormat() {

		return "WMS";

	}

	@Override

	public FLayer getFileLayer() throws RasterDriverException {

		/*if(getDataStore() instanceof DefaultRemoteRasterStore) {

			RemoteRasterProvider prov = (RemoteRasterProvider)((DefaultRemoteRasterStore)getDataStore()).getProvider(0);

			File file = null;

			if(getParameters().isSizeFixed()) {

				file = prov.getFileLayer();

			} else {

				file = prov.getLastRequest();

			}

			if(file == null)

				return null;

			try {

				return DefaultFLyrRaster.createLayer("tmp", file);

			} catch (LoadLayerException e) {

		return rAux;

	}

	public Extent getFullRasterExtent() {

		return getExtentFromEnvelope(getFullEnvelope());

	}

	public DynObjectSet getInfo(org.gvsig.fmap.geom.primitive.Point p, double tolerance) throws LoadLayerException, DataException {

		Point p1 = new Point((int)p.getX(), (int)p.getY());

		return getInfo(p1, tolerance, null, false);

			getParameters().setWidth(viewPort.getImageWidth());

			getParameters().setHeight(viewPort.getImageHeight());

		}

		CancelTaskImpl cancellable = new CancelTaskImpl(cancel);

		getParameters().setCancellable(cancellable);

		String fInfo;

		try {

			//Point2D pt = new Point2D.Double();

			/*} catch (NoninvertibleTransformException e) {

				return null;

			}*/

			Extent bbox = getExtentFromEnvelope(viewPort.getAdjustedEnvelope());

					cancellable);

		} catch (InfoByPointException e) {

			throw new LoadLayerException("Error in getInfoByPoint", e);

		}

		return new DynObjectSetWMSInfo(fInfo, getParameters().getInfoFormat());

	}

	private Extent getExtentFromEnvelope(Envelope env) {

		double minx = env.getMinimum(0);

		double miny = env.getMinimum(1);

		Point2D lr = new Point2D.Double(maxx, miny);

		return rManager.getDataStructFactory().createExtent(ul, lr, ur, ll);

	}

    /**

     * Sets the data store parameters

     * @param params

    	if(params instanceof TileDataParameters) {

			((TileDataParameters)params).deleteCache(deleteCache);

		}

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

		try {

			DataStore dStore = dataman.openStore(params.getDataStoreName(), params);

			this.setDataStore(dStore);

			if(params instanceof WMSDataParameters) {

			}

			if(params instanceof TileDataParameters) {

				DataParameters p = ((TileDataParameters) params).getDataParameters();

				if(p instanceof WMSDataParameters) {

				}

			}

		} catch (ValidateDataParametersException e) {

			throw new InitializeException(e);

		}

    }

	public WMSDataParameters getParameters() {

		return getWMSParameters(getDataStore().getParameters());

    }

    /**

     * Gets <code>WMSDataParameters</code>

     * @param parameters

    	if(parameters instanceof WMSDataParameters) {

			params = (WMSDataParameters) parameters;

		}

		if(parameters instanceof TileDataParameters) {

			DataParameters p = ((TileDataParameters) parameters).getDataParameters();

			if(p instanceof WMSDataParameters) {

		}

		return params;

    }

    /**

	 * Assigns the flag to delete this layer from the cache

	 * @param selected

	public void deleteCache(boolean deleteCache) {

		this.deleteCache = deleteCache;

	}

    /**

     * Sets the explorer

     * @param explorer

    	if(getDataStore() != null)

    		getDataStore().setExplorer(explorer);

    }

    /**

     * Gets the explorer

     * @return

		}

    	return null;

    }

	public FLayer cloneLayer() throws Exception {

		RasterDataStore  ds = dataStore.cloneDataStore();

		FLyrWMS newLayer = new FLyrWMS();

		newLayer.setOpenRasterStore(ds);

		//newLayer.firstLoad = firstLoad;

		newLayer.setExplorer(getExplorer());

		List<RasterFilter> filters = getRender().getFilterList().getStatusCloned();

		//Hacemos una copia de las bandas a renderizar

		if(dataStore.getNoDataValue().isDefined())

			newLayer.setNoDataTransparent(true);

		newLayer.enableOpen();

		return newLayer;

	}

	@Override

	public boolean isInside(Point2D p) {

		// Don't call the data store isInside method, as the data store