Application: gvSIG desktop » gvSIG raster

	private WMTSDataParameters            storeParams        = null;

    public synchronized File getTile(WMTSStatus status, ICancellable cancel) throws WMTSException, ServerErrorException {   

 * Provider for WMTS service

	//Los tiles se piden de forma secuencial y sin lanzar threads para ello (+Lento)

	public static int                   SEQUENTIAL               = 0;

	//Los tiles se piden en threads y hay un thread manager para gestionar que no se pidan m?s de cierto n?mero

	public static int                   LIMITED_THREADS          = 1;

	//Los tiles se piden en threads y se lanzan tantos threads como tiles haya

	public static int                   UNLIMITED_THREADS        = 2;

	private int                         requestType              = LIMITED_THREADS;

	/**

	 * This thread manages the number of tiles that have been thrown.

	 * This number is controlled by the NTHREADS_QUEUE variable.

	 * 

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

	 */

	class RequestThreadManager extends Thread {

		public int                 NTHREADS_QUEUE = 5;

		private TilePipe           pipe           = null;

		private ArrayList<Tile>    tiles          = null;

		private WMTSStatus         status         = null;

		public RequestThreadManager(TilePipe pipe, ArrayList<Tile> tiles, WMTSStatus status) {

			this.pipe = pipe;

			this.tiles = tiles;

			this.status = status;

		}

		public void run() {

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

				Tile tile = tiles.get(i);

				WMTSStatus statusCopy = status.cloneStatus();

				statusCopy.setTileRow(tile.row);

				statusCopy.setTileCol(tile.col);

				if (pipe.getSize() > NTHREADS_QUEUE) {

					try {

						synchronized (this) {

							wait();							

						}

					} catch( InterruptedException e ) {

					}

				}

				new RequestTileLauncher(pipe, statusCopy, tile).start();

			}

		}

	}

	/**

	 * Thread to download a tile

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

	 */

	class RequestTileLauncher extends Thread {

		private TilePipe      pipe    = null;

		private WMTSStatus    status  = null;

		private Tile          tile    = null;

		public RequestTileLauncher(TilePipe pipe, WMTSStatus status, Tile tile) {

			this.pipe = pipe;

			this.status = status;

			this.tile = tile;

		}

		public void run() {

			try {

				File file = getConnector().getTile(status, null);

				tile.file = file;

				pipe.setTile(tile);

			} catch (WMTSException e) {

			} catch (ServerErrorException e) {

			}

		}

	}

	private synchronized Buffer request(WMTSStatus status, BandList bandList, TileListener listener) throws RasterDriverException, ProcessInterruptedException {

		//WMTSDataParameters p = (WMTSDataParameters)param;

		TilePipe pipe = new TilePipe();

		//Caso 1: Lanza un thread que gestiona que no se lancen muchos threads a la vez

		if(requestType == LIMITED_THREADS) {

			RequestThreadManager threadManager = new RequestThreadManager(pipe, tiles, status);

			pipe.setRequestManager(threadManager);

			threadManager.start();

		//Caso 2: Lanza todos los threads

		} else if(requestType == UNLIMITED_THREADS) {

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

				Tile tile = tiles.get(i);

				WMTSStatus statusCopy = status.cloneStatus();

				statusCopy.setTileRow(tile.row);

				statusCopy.setTileCol(tile.col);

				new RequestTileLauncher(pipe, statusCopy, tile).start();

			}

		}

		if(requestType == LIMITED_THREADS || requestType == UNLIMITED_THREADS) {

			int nCollected = 0;

			while (nCollected < tiles.size()) {

				Tile tile = pipe.getTile();

				drawTile(tile, listener, bandList);

				nCollected ++;

			}

		}

		if(requestType == SEQUENTIAL) {

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

				Tile tile = tiles.get(i);

				status.setTileRow(tile.row);

				status.setTileCol(tile.col);

				//TODO:Cancelaci?n

				try {

					File file = connector.getTile(status, null);

					tile.file = file;

					drawTile(tile, listener, bandList);

				} catch (WMTSException e) {

					throw new RasterDriverException("Error getting tiles", e);

				} catch (ServerErrorException e) {

					throw new RasterDriverException("Error getting tiles", e);

	/**

	 * Reads a tile with gdal and calls the method nextBuffer

	 * @param tile

	 * @param listener

	 * @param bandList

	 * @return

	 * @throws RasterDriverException

	 */

	private synchronized Buffer drawTile(Tile tile, TileListener listener, BandList bandList) throws RasterDriverException {

		WMTSDataParameters p = (WMTSDataParameters)param;

		try {

			String serverName = bandList.getBand(0).getFileName();

			for (int j = 0; j < bandList.getBandCount(); j++) {

				bandList.getBand(j).setFileName(tile.file.getPath());

			}

			GdalProvider driver = new GdalProvider(tile.file.getPath());

			colorTable = driver.getColorTable();

			bandCount = driver.getBandCount();

			lastFileTransparency = driver.getTransparency();

			Buffer rasterBuf = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], tile.wPx, tile.hPx, 3, true);

			Buffer buf = driver.getWindowRaster(0, 0, tile.wPx, tile.hPx, bandList, rasterBuf);

			buf.setDataExtent(new Rectangle2D.Double(Math.min(tile.ulx, tile.lrx), Math.min(tile.uly, tile.lry), Math.abs(tile.ulx - tile.lrx), Math.abs(tile.uly - tile.lry)));

			Buffer alphaBand = null;

			if(p.getAlphaBand() != -1 && listener != null && p.getAlphaBand() < bandCount) {

				alphaBand = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], tile.wPx, tile.hPx, 1, true);

				int[] oldDB = bandList.getDrawableBands();

				bandList.setDrawableBands(new int[]{p.getAlphaBand()});

				alphaBand = driver.getWindowRaster(0, 0, tile.wPx, tile.hPx, bandList, alphaBand);

				bandList.setDrawableBands(oldDB);

			}

			for (int j = 0; j < bandList.getBandCount(); j++) {

				bandList.getBand(j).setFileName(serverName);

			}

			driver.close();

			if(listener != null)

				listener.nextBuffer(buf, alphaBand, new ExtentImpl(tile.ulx, tile.uly, tile.lrx, tile.lry), getAffineTransform(), null, true);

			else

				return buf;

		} catch (NotSupportedExtensionException e) {

			throw new RasterDriverException("Error getting tiles", e);

		} catch (ProcessInterruptedException e) {

		}

		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.fmap.dal.coverage.dataset.io.wmts;

import org.gvsig.fmap.dal.coverage.dataset.io.wmts.WMTSProvider.RequestThreadManager;

import org.gvsig.remoteclient.wmts.struct.WMTSTileMatrix.Tile;

/**

 * This class manages transactions between the producer and the consumer. The

 * producer download tiles from a server and the consumer is a tile provider

 * which will return downloaded tiles.

 *

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

 */

public class TilePipe {

	private final static int     BUFFER_SIZE    = 10; 

	private Tile                 buffer[]       = new Tile[BUFFER_SIZE];

	private int                  next           = 0;

	private boolean              isFull         = false;

	private boolean              isEmpty        = true;

	private RequestThreadManager threadManager  = null;

	public void setRequestManager(RequestThreadManager threadManager) {

		this.threadManager = threadManager;

	}

	/**

	 * Sets a tile in the pipe

	 * @param tile

	 */

	public synchronized void setTile(Tile tile) {

		while( isFull == true ) {

			try {

				wait();

			} catch( InterruptedException e ) {

			}

		}

		buffer[next] = tile;

		next++;

		if( next == BUFFER_SIZE )

			isFull = true;

		isEmpty = false;

		notify();

	}

	/**

	 * Gets a tile from the pipe

	 * @return

	 */

	public synchronized Tile getTile() {

		while( isEmpty == true ) {

			try {

				wait();

			} catch( InterruptedException e ) {

			}

		}

        next--;

        if( next == 0 )

        	isEmpty = true;

        isFull = false;

        notify();

        if(threadManager != null && getSize() <= threadManager.NTHREADS_QUEUE) {

        	synchronized(threadManager) {

        		threadManager.notify();

        	}

        }

        return buffer[next] ;

	}

	/**

	 * Returns the number of elements in the queue

	 * @return

	 */

	public synchronized int getSize() {

		return next;

	}

}