Application: gvSIG desktop » gvSIG raster

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.util.RasterUtils;

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.raster.impl.buffer.cache.RasterReadOnlyBuffer;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.store.QueryableRaster;

public class DefaultRasterQuery implements RasterQuery, SpiRasterQuery {

	public static final int  TYPE_UNDEFINED             = -1;

	public static final int  TYPE_WCOORDS               = 1;

	public static final int  TYPE_WCOORDS_RESCALED      = 2;

	public static final int  TYPE_WCOORDS_SHIFT         = 3;

	public static final int  TYPE_PX                    = 4;

	public static final int  TYPE_PX_RESCALED           = 5;

	public static final int  TYPE_PX_SHIFT              = 6;

	public static final int  TYPE_PX_RESCALED_SHIFT     = 7;

	public static final int  TYPE_TILED                 = 8;

	public static final int  TYPE_ONE_TILE              = 9;

	private int              type                       = TYPE_ENTIRE;

	/*

	 * Request in pixels

	 */

	private Rectangle        pixelWindow                = null;

	/*

	 * Request in pixels adjusted to the source. The provider will use this parameter. If the type is with

	 * shift then adjustedPixelWindow will be the same to the pixelWindow

	 */

	private Rectangle        adjustedPixelWindow        = null;

	/*

	 * Request in world coordinates

	 */

	private Extent           requestBoundingBox         = null;

	/*

	 * Request in world coordinates adjusted to the source. The provider will use this parameter. If the type is with

	 * shift then adjustedBoundingBox will be the same to the requestBoundingBox

	 */

	private Extent           adjustedBoundingBox        = null;

	private int              widthForResampling         = -1;

	private int              heightForResampling        = -1;

	/*

	 * If the request is adjusted to the input source this width is the same to widthForResampling else

	 * the provider has to receive the right buffer size for the request, so this adjustedWidth will

	 * contain a smaller buffer without frames. 

	 */

	private int              adjustedBufferWidth        = 0;

	/*

	 * If the request is adjusted to the input source this height is the same to heightForResampling else

	 * the provider has to receive the right buffer size for the request, so this adjustedHeight will

	 * contain a smaller buffer without frames. 

	 */

	private int              adjustedBufferHeight       = 0;

	private double[]         step                       = null;

	private int              tileRow                    = 0;

	private int              tileCol                    = 0;

	private int              resolutionLevel            = -1;

	private boolean          adjustToSrcExtent          = true;

	private boolean			 supersamplingLoadingBuffer = false;

	private boolean          dontBuildBuffer            = false;

	private Buffer           bufferForProviders         = null;

	private boolean          forceARGBBuffer            = false;

	private boolean          forceRGBBuffer             = false;

	//private Buffer           bufferWithoutAdjust        = null;

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

	//*************Request of data windows****************

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

	public void setAreaOfInterest() {

		this.type = TYPE_ENTIRE;

	public void setAreaOfInterest(Rectangle pixelWindow) {

		this.pixelWindow = pixelWindow;

		this.type = TYPE_PX;

	public void setAreaOfInterest(Rectangle pixelWindow, int bufWidth, int bufHeight) {

		this.pixelWindow = pixelWindow;

		this.widthForResampling = bufWidth;

		this.heightForResampling = bufHeight;

		this.type = TYPE_PX;

	public void setAreaOfInterest(Extent requestBoundingBox, int bufWidth, int bufHeight) {

		this.widthForResampling = bufWidth;

		this.heightForResampling = bufHeight;

		this.requestBoundingBox = requestBoundingBox;

		this.type = TYPE_WCOORDS;

	}

	public void setAreaOfInterest(Extent boundingBox) {

		this.requestBoundingBox = boundingBox;

		this.type = TYPE_WCOORDS;

	}

	public void setAreaOfInterest(Extent requestBoundingBox, 

		this.requestBoundingBox = requestBoundingBox;

		this.widthForResampling = bufWidth;

		this.heightForResampling = bufHeight;

		this.type = TYPE_TILED;

	public void setTileParameters(int level, int tileCol, int tileRow) {

		this.type = TYPE_ONE_TILE;

		this.resolutionLevel = level;

		this.tileRow = tileRow;

		this.tileCol = tileCol;

	/**

	 * @deprecated Use setTileParameters(int level, int tileCol, int tileRow)

	 */

		this.requestBoundingBox = bbox;

		this.widthForResampling = size[0];

		this.heightForResampling = size[1];

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

	//****************Internal Services*******************

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

	public boolean requestIsTiled() {

		switch (type) {

		case TYPE_TILED:

		case TYPE_ONE_TILE:

			return true;

		}

		return false;

	}

	public boolean requestHasShift() {

		switch (type) {

		case TYPE_PX_RESCALED_SHIFT:

		case TYPE_PX_SHIFT:

		case TYPE_WCOORDS_SHIFT:

			return true;

		}

		return false;

	}

	public boolean requestIsPixelCoordinates() {

		switch (type) {

		case TYPE_PX:

		case TYPE_PX_SHIFT:

		case TYPE_PX_RESCALED:

		case TYPE_PX_RESCALED_SHIFT:

		case TYPE_ENTIRE:

			return true;

		}

		return false;

	}

	public boolean requestIsInWorldCoordinates() {

		switch (type) {

		case TYPE_WCOORDS:

		case TYPE_WCOORDS_RESCALED:

		case TYPE_WCOORDS_SHIFT:

		case TYPE_TILED:

			return true;

		}

		return false;

	}

	public boolean requestIsRescaled() {

		switch (type) {

		case TYPE_PX_RESCALED:

		case TYPE_PX_RESCALED_SHIFT:

		case TYPE_WCOORDS_RESCALED:

		case TYPE_TILED:

			return true;

		}

		return false;

	}

	/**

	 * Returns true if the request is trying apply supersampling, that is, the size of the result is

	 * bigger that the window of maximum resolution of this source

	 * @return

	 */

	public boolean isSupersamplingTheRequest() {

		if(!requestHasShift()) {

			return (getBufWidth() > getAdjustedWidth() || getBufHeight() > getAdjustedHeight());

		}

		return (getAdjustedBufWidth() > getAdjustedWidth() || getAdjustedBufHeight() > getAdjustedHeight());

	}

	public RasterQuery clone() {

		DefaultRasterQuery q = new DefaultRasterQuery();

		q.type = type;

		q.pixelWindow = (Rectangle)pixelWindow.clone();

		q.adjustToSrcExtent = adjustToSrcExtent;

		q.widthForResampling = widthForResampling;

		q.heightForResampling = heightForResampling;

		q.requestBoundingBox = requestBoundingBox != null ? requestBoundingBox.clone() : null;

		q.tileCol = tileCol;

		q.tileRow = tileRow;

		q.resolutionLevel = resolutionLevel;

		q.readOnly = readOnly;

		q.memoryBuffer = memoryBuffer;

		q.storeLastBuffer = storeLastBuffer;

		if(drawableBands != null) {

			q.drawableBands = new int[drawableBands.length];

			for (int i = 0; i < q.drawableBands.length; i++) {

				q.drawableBands[i] = drawableBands[i];

			}

		}

		q.supersamplingLoadingBuffer = supersamplingLoadingBuffer;

		q.noDataValueToFill = noDataValueToFill != null ? (NoData)noDataValueToFill.clone() : null;

		q.listener = listener;

		q.alphaBandNumber = alphaBandNumber;

		q.bandList = bandList != null ? (BandList)bandList.clone() : null;

		q.bufferForProviders = bufferForProviders;

		return q;

	}

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

	//*************Parameters calculation*****************

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

	/**

	 * Calculates the parameters using the base request. That is, bounding boxes, data windows,

	 * output size, steps and parameters for supersampling, band lists and buffers. This parameters

	 * are calculated adjusting to the source limits. For this reason, the request parameters are 

	 * saved in other variables, to allow calculate the displacement and resampling whether it was 

	 * necessary

	 * @param store

	 * @throws QueryException 

	 */

	public void calculateParameters(RasterDataStore store) throws QueryException {

		calculateRequestType(store);

		//Parameters for requests in pixels

		if(requestIsPixelCoordinates()) {

			calculateAdjustedPxSizeFromPxSize((int)store.getWidth(), (int)store.getHeight());

			calculateBoundingBoxesFromPxRequest(store);

		} 

		//Parameters for requests in world coordinates

		if(requestIsInWorldCoordinates()) {

			calculateAdjustedWCWindowFromWCWindow(store.getAffineTransform(), (int)store.getWidth(), (int)store.getHeight());

			calculatePxWindowsFromBoundingBoxes(store);

		}

		//Output

		calculateOutputSizeFromPxWindow(store);

		//Supersampling parameters

		step = null;

		if(isSupersamplingTheRequest() && !store.isRasterEnclosed()) {

			calculateStep(store);

			supersampledBuffers(store);

		}

		//Bands and buffers

		buildDrawableBandList(store.getBands());

		if(!dontBuildBuffer)

			createBuffer(store);

	}

	/**

	 * Adjust the request in world coordinates to the data size

	 * @param q

	 */

	private void calculateAdjustedWCWindowFromWCWindow(AffineTransform at, int w, int h) {

		if(requestHasShift()) {

			setAdjustedRequestBoundingBox(getRequestBoundingBox().clone());

		}

		RasterUtils util = RasterLocator.getManager().getRasterUtils();

		Extent adjustedDataExtent = util.calculateAdjustedView(getRequestBoundingBox(), at, w, h);

		setAdjustedRequestBoundingBox(adjustedDataExtent);

	}

	/**

	 * Adjust the request in pixel coordinates to the data size

	 * @param q

	 */

	private void calculateAdjustedPxSizeFromPxSize(int sourceWidth, int sourceHeight) {

		adjustedPixelWindow = (Rectangle)pixelWindow.clone();

		if(requestHasShift()) 

			return;

		if(getAdjustedX() < 0)

			setAdjustedX(0);

		if(getAdjustedY() < 0)

			setAdjustedY(0);

		if((getAdjustedX() + getAdjustedWidth()) > sourceWidth)

			setAdjustedWidth(sourceWidth - getX());

		if((getAdjustedY() + getAdjustedHeight()) > sourceHeight)

			setAdjustedHeight(sourceHeight - getAdjustedY());

	}

	private void calculateBoundingBoxesFromPxRequest(RasterDataStore store) {

		Extent extent = new ExtentImpl(

				store.rasterToWorld(new Point2D.Double(getX(), getY())),

				store.rasterToWorld(new Point2D.Double(getX() + getWidth(), getY() + getHeight())));

		setRequestBoundingBox(extent);

		Extent adjustedExtent = new ExtentImpl(

				store.rasterToWorld(new Point2D.Double(getAdjustedX(), getAdjustedY())),

				store.rasterToWorld(new Point2D.Double(getAdjustedX() + getAdjustedWidth(), getAdjustedY() + getAdjustedHeight())));

		setAdjustedRequestBoundingBox(adjustedExtent);

	}

	private double round(double value) {

		double a = (value - (int)value);

		return (a > 0.95 || a < 0.05) ? Math.round(value) : value;

	}

	private void calculateOutputSizeFromPxWindow(RasterDataStore store) {

		if(!requestIsRescaled()) {

			setBufHeight(getHeight());

			setBufWidth(getWidth());

			setAdjustedBufWidth(getAdjustedWidth());

			setAdjustedBufHeight(getAdjustedHeight());

		} else {

			double scaleWidth = (double)getWidth() / getBufWidth();

			double scaleHeight = (double)getHeight() / getBufHeight();

			setAdjustedBufWidth((int)Math.ceil(round(getAdjustedWidth() / scaleWidth)));

			setAdjustedBufHeight((int)Math.ceil(round(getAdjustedHeight() / scaleHeight)));

		}

	}

	private void calculatePxWindowsFromBoundingBoxes(RasterDataStore store) {

		Extent requestBBox = getRequestBoundingBox();

		Point2D ul = store.worldToRaster(requestBBox.getUL());

		Point2D lr = store.worldToRaster(requestBBox.getLR());

		int w = (int)Math.ceil(Math.abs(round(ul.getX()) - round(lr.getX())));

		int h = (int)Math.ceil(Math.abs(round(ul.getY()) - round(lr.getY())));

		Rectangle r = new Rectangle((int)ul.getX(), (int)ul.getY(), w, h);

		pixelWindow = r;

		Extent adjustedBBox = getAdjustedRequestBoundingBox();

		ul = store.worldToRaster(adjustedBBox.getUL());

		lr = store.worldToRaster(adjustedBBox.getLR());

		w = (int)Math.ceil(Math.abs(round(ul.getX()) - round(lr.getX())));

		h = (int)Math.ceil(Math.abs(round(ul.getY()) - round(lr.getY())));

		r = new Rectangle((int)ul.getX(), (int)ul.getY(), w, h);

		adjustedPixelWindow = r;

	}

	/**

	 * <p>

	 * If the request is being supersampled, then the buffer size will be bigger than the pixel window. 

	 * In this case the provider will receive a buffer in 1:1 scale. The supersampling function will be 

	 * in the client (supersampling deactivated) or in the store (supersampling activated). 

	 * </p><p>

	 * The buffer will have one pixel more because the resampling cuts the first pixel by the beginning and

	 * shows the last pixel by the end.

	 * </p>

	 * @param store

	 */

	private void supersampledBuffers(RasterDataStore store) {

		//Si se est? pidiendo supersampleo el provider tiene que recibir un buffer de tama?o igual al n?mero real de

		//pixels del ?rea, por ello habr? que cambiar el adjustedbufwidth y adjustedBufHeight. Adem?s habr? que variar

		//el extent del provider y la ventana en pixeles para que todo cuadre. El objetivo es que cuando el cliente (Render)

		//supersamplee no le queden huecos en blanco porque le falte el ?ltimo pixel.

		if((getAdjustedX() + getAdjustedWidth()) < store.getWidth())

			setAdjustedWidth(getAdjustedWidth() + 1);

		if((getAdjustedY() + getAdjustedHeight()) < store.getHeight())

			setAdjustedHeight(getAdjustedHeight() + 1);

		setAdjustedBufWidth(getAdjustedWidth());

		setAdjustedBufHeight(getAdjustedHeight());

		Point2D ul = store.rasterToWorld(new Point2D.Double(adjustedPixelWindow.getX(), adjustedPixelWindow.getY()));

		Point2D lr = store.rasterToWorld(new Point2D.Double(

				adjustedPixelWindow.getX() + adjustedPixelWindow.getWidth(), 

				adjustedPixelWindow.getY() + adjustedPixelWindow.getHeight()));

		setAdjustedRequestBoundingBox(new ExtentImpl(ul, lr));

	}

	/**

	 * Giving a world coordinates, a buffer size and a original raster size. If the 

	 * buffer is bigger than the window requested in the source raster (supersampling), 

	 * then it means that each pixel of the raster will be written several times in 

	 * the destination buffer.

	 * 

	 * This function calculates the shift in pixels en X and Y coordinate that 

	 * correspond to the first pixel, due to this pixel won't be drawn entirely.

	 * 

	 * This operation is needed when the client wants to apply suppersampling on the 

	 * result of a request.

	 */

	private void calculateStep(RasterDataStore store) {

		Point2D tl = store.worldToRaster(getAdjustedRequestBoundingBox().getUL());

		Point2D br = store.worldToRaster(getAdjustedRequestBoundingBox().getLR());

		//Se obtiene el tama?o de la petici?n original pero ajustada ya que adjustedBufferWidth y adjustedBufferHeight

		//habr?n sido modificados para que no excedan el tama?o de la ventana, ya que el provider no debe supersamplear

		double scaleWidth = (double)getWidth() / getBufWidth();

		double scaleHeight = (double)getHeight() / getBufHeight();

		int srcOriginalAdjustedWidth = (int)Math.ceil(round(getAdjustedWidth() / scaleWidth));

		int srcOriginalAdjustedHeight = (int)Math.ceil(round(getAdjustedHeight() / scaleHeight));

		double wPx = (srcOriginalAdjustedWidth / Math.abs(br.getX() - tl.getX()));

		double hPx = (srcOriginalAdjustedHeight / Math.abs(br.getY() - tl.getY()));

		int x = (int)((tl.getX() > br.getX()) ? Math.floor(br.getX()) : Math.floor(tl.getX()));

		int y = (int)((tl.getY() > br.getY()) ? Math.floor(br.getY()) : Math.floor(tl.getY()));

		double a = (tl.getX() > br.getX()) ? (Math.abs(br.getX() - x)) : (Math.abs(tl.getX() - x));

		double b = (tl.getY() > br.getY()) ? (Math.abs(br.getY() - y)) : (Math.abs(tl.getY() - y));

		double stpX = (int)((a * srcOriginalAdjustedWidth) / Math.abs(br.getX() - tl.getX()));

		double stpY = (int)((b * srcOriginalAdjustedHeight) / Math.abs(br.getY() - tl.getY()));

		step = new double[]{stpX, stpY, wPx, hPx};

	}

	public Buffer createBuffer(RasterDataStore store) throws QueryException {

		if(isReadOnly()) {

			bufferForProviders = DefaultRasterManager.getInstance().createReadOnlyBuffer(

					store.getDataType()[0], getAdjustedBufWidth(), getAdjustedBufHeight(), store.getBandCount());

			try {

				((RasterReadOnlyBuffer)bufferForProviders).setBufferParams((QueryableRaster)store, 

						getAdjustedX(), 

						getAdjustedY(), 

						getAdjustedX() + getAdjustedWidth() - 1, 

						getAdjustedY() + getAdjustedHeight() - 1, 

						bandList);

			} catch (FileNotExistsException e) {

				throw new QueryException("Error setting buffer params in a RO buffer", e);

			} catch (NotSupportedExtensionException e) {

				throw new QueryException("Error setting buffer params in a RO buffer", e);

			} catch (InvalidSetViewException e) {

				throw new QueryException("Error setting buffer params in a RO buffer", e);

			}

		} else {

			BandList bandList = buildDrawableBandList(store.getBands());

			int bandCount = bandList.getDrawableBandsCount();

			if(forceARGBBuffer) 

				bandCount = 4;

			if(forceRGBBuffer) 

				bandCount = 3;

			if(isMemoryBuffer()) 

				bufferForProviders = DefaultRasterManager.getInstance().createMemoryBuffer(

						store.getDataType()[0], getAdjustedBufWidth(), getAdjustedBufHeight(), bandCount, true);

			else

				bufferForProviders = DefaultRasterManager.getInstance().createBuffer(

						store.getDataType()[0], getAdjustedBufWidth(), getAdjustedBufHeight(), bandCount, true);

		}

		bufferForProviders.setDataExtent(getAdjustedRequestBoundingBox().toRectangle2D());

		return bufferForProviders;

	}

	/**

	 * Builds a list o bands to draw from the store band list and

	 * the <code>drawablebands</code> asigned by the user

	 * @param drawableBands

	 * @param storeBandList

	 * @return

	 */

	public BandList buildDrawableBandList(BandList storeBandList) {

		bandList = (BandList)storeBandList.clone();

		//If drawableBands is null then the bandList is the same that the source band list

		if(drawableBands != null)

			bandList.setDrawableBands(drawableBands);

		return bandList;

	}

	private boolean isAdjustingPixelWindowToStore(RasterDataStore store) {

		return (pixelWindow.getX() >= 0 && 

				pixelWindow.getY() >= 0 && 

				pixelWindow.getWidth() <= store.getWidth() && 

				pixelWindow.getHeight() <= store.getHeight());

	}

	private boolean isBufferSizeDefined() {

		return (widthForResampling != -1 && heightForResampling != -1);

	}

	private boolean isAdjustingRequestBBoxToStore(RasterDataStore store) {

		Extent intersection = requestBoundingBox.intersection(store.getExtent());

		return intersection.equals(store.getExtent());

	}

	private void calculateRequestType(RasterDataStore store) {

		if(type == TYPE_ENTIRE) {

			pixelWindow = new Rectangle(0, 0, (int)store.getWidth(), (int)store.getHeight());

			return;

		}

		if(!adjustToSrcExtent) {

			if(type == TYPE_PX) {

				if(isAdjustingPixelWindowToStore(store)) {

					if(isBufferSizeDefined())

						this.type = TYPE_PX_RESCALED;

					else

						this.type = TYPE_PX;

				} else {

					if(isBufferSizeDefined())

						this.type = TYPE_PX_RESCALED_SHIFT;

					else

						this.type = TYPE_PX_SHIFT;

				}

			}

			if(type == TYPE_WCOORDS) {

				if(isBufferSizeDefined()) {

					if(isAdjustingRequestBBoxToStore(store))

						this.type = TYPE_WCOORDS_RESCALED;

					else

						this.type = TYPE_WCOORDS_SHIFT;						

				} //else TYPE_WCOORDS

			}

		} else {

			if(type == TYPE_PX) {

				if(isBufferSizeDefined())

					this.type = TYPE_PX_RESCALED;

			}

			if(type == TYPE_WCOORDS) {

				if(isBufferSizeDefined())

					this.type = TYPE_WCOORDS_RESCALED;

				//else TYPE_WCOORDS

			}

		}

	}

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

	//*********Implementing DataQuery methods*************

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

	public Object getQueryParameter(String name) {

		return null;

	}

	public double getScale() {

		return 0;

	}

	public void setQueryParameter(String name, Object value) {

	}

	public void setScale(double scale) {

	}

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

	//*********Implementing Persistent methods************

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

	public void loadFromState(PersistentState state)

			throws PersistenceException {

	}

	public void saveToState(PersistentState state) throws PersistenceException {

	}

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

	//**************Getters and Setters*******************

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

	public void forceARGBRequest() {

		this.forceARGBBuffer = true;

		this.forceRGBBuffer = false;

	}

	public void forceRGBRequest() {

		this.forceRGBBuffer = true;

		this.forceARGBBuffer = false;

	}

	public boolean isforcingRGBRequest() {

		return (forceRGBBuffer && !forceARGBBuffer);

	}

	public boolean isforcingARGBRequest() {

		return (forceARGBBuffer && !forceRGBBuffer);

	}

	public void dontBuildBuffer() {

		this.dontBuildBuffer = true;

	}

	public int getType() {

		return type;

	}

		this.adjustToSrcExtent = adjustToExtent;

		return adjustToSrcExtent;

	/**

	 * Returns true if the supersampling is enable and false if it is disable

	 * Rendering from gvSIG, the resampling is always disable because if the request 

	 * is greater than 1:1 scale the resampling will be done in the client <code>Render</code>.

	 * The default value is disable.

	 */

	public boolean isSupersamplingOptionActive() {

	/**

	 * Enables or disables the supersampling loading the buffer. Rendering from gvSIG,

	 * the resampling is always disable because if the request is greater than 1:1 scale

	 * the resampling will be done in the client <code>Render</code>

	 */

	public void setSupersamplingOption(boolean supersamplingLoadingBuffer) {

	public void setRequestPixelWindow(Rectangle pixelWindow) {

		this.pixelWindow = pixelWindow;

	public int getX() {

		return (int)pixelWindow.getX();

	public int getY() {

		return (int)pixelWindow.getY();

	public int getWidth() {

		return (int)pixelWindow.getWidth();

	public int getHeight() {

		return (int)pixelWindow.getHeight();

	public void setX(int x) {

		pixelWindow.setLocation(x, getY());

	public void setY(int y) {

		pixelWindow.setLocation(getX(), y);

	public void setWidth(int w) {

		pixelWindow.setSize(w, getWidth());

	public void setHeight(int h) {

		pixelWindow.setSize(getHeight(), h);

	public int getAdjustedX() {

		return (int)adjustedPixelWindow.getX();

	public int getAdjustedY() {

		return (int)adjustedPixelWindow.getY();

	public int getAdjustedWidth() {

		return (int)adjustedPixelWindow.getWidth();

	public int getAdjustedHeight() {

		return (int)adjustedPixelWindow.getHeight();

	public void setAdjustedX(int x) {

		adjustedPixelWindow.setLocation(x, getAdjustedY());

	public void setAdjustedY(int y) {

		adjustedPixelWindow.setLocation(getAdjustedX(), y);

	public void setAdjustedWidth(int w) {

		adjustedPixelWindow.setSize(w, getAdjustedHeight());

	public void setAdjustedHeight(int h) {

		adjustedPixelWindow.setSize(getAdjustedWidth(), h);

	/**

	 * Gets the window of the request in pixel coordinates

	 */

	 public Rectangle getRequestPxWindow() {

		 return pixelWindow;

	 }

	 /**

	  * Gets the adjusted window of the request in pixel coordinates

	  */

	 public Rectangle getAdjustedRequestPxWindow() {

		 return adjustedPixelWindow;

	 }

	 /**

	  * Gets a bounding box of a request in world coordinates.

	  */

	 public Extent getRequestBoundingBox() {

		 return requestBoundingBox;

	 }

	 /**

	  * Sets a bounding box of a request in world coordinates.

	  * @param requestBoundingBox

	  */

	 public void setRequestBoundingBox(Extent requestBoundingBox) {

		 this.requestBoundingBox = requestBoundingBox;

	 }

	 /**

	  * Gets a bounding box of a request in world coordinates adjusted to the bounding box of the source.

	  */

	 public Extent getAdjustedRequestBoundingBox() {

		 return adjustedBoundingBox;

	 }

	 /**

	  * Sets a bounding box of a request in world coordinates adjusted to the bounding box of the source.

	  * @param requestBoundingBox

	  */

	 public void setAdjustedRequestBoundingBox(Extent adjustedBoundingBox) {

		 this.adjustedBoundingBox = adjustedBoundingBox;

	 }

	 public int getBufWidth() {

		 return widthForResampling;

	 }

	 public int getBufHeight() {

		 return heightForResampling;

	 }

	 public void setBufHeight(int h) {

		 heightForResampling = h;

	 }

	 public void setBufWidth(int w) {

		 widthForResampling = w;

	 }

	 public int getAdjustedBufWidth() {

		 return adjustedBufferWidth;

	 }

	 public int getAdjustedBufHeight() {

		 return adjustedBufferHeight;

	 }

	 public void setAdjustedBufHeight(int h) {

		 adjustedBufferHeight = h;

	 }

	 public void setAdjustedBufWidth(int w) {

		 adjustedBufferWidth = w;

	 }

	 public boolean isReadOnly() {

		 return readOnly;

	 }

	 public TileListener getTileListener() {

		 return listener;

	 }

	 public void setTileListener(TileListener listener) {

		 this.listener = listener;

	 }

	 public Time getTime() {

		 return time;

	 }

	 public void setTime(Time time) {

		 this.time = time;

	 }

	 public int getTileRow() {

		 return tileRow;

	 }

	 public int getTileCol() {

		 return tileCol;

	 }

	 public CacheStruct getCacheStruct() {

		 return cacheStruct;

	 }

	 public void setCacheStruct(CacheStruct cacheStruct) {

		 this.cacheStruct = cacheStruct;

	 }

	 public int getResolutionLevel() {

		 return resolutionLevel;

	 }

	 public void setTaskStatus(TaskStatus taskStatus) {

		 this.taskStatus = taskStatus;

	 }

	 public BandList getBandList() {

		 return bandList;

	 }

	 public void setBandList(BandList bandList) {

		 this.bandList = bandList;

	 }

	 /**

	  * Buffer loaded by the provider and created by the store

	  * @return

	  */

	 public Buffer getBufferForProviders() {

		 return bufferForProviders;

	 }

	 public void setBufferResult(Buffer buffer) {

		 this.bufferForProviders = buffer;

	 }

	 public void setBufferForProviders(Buffer buffer) throws QueryException {

		 if(buffer.getWidth() != getAdjustedBufWidth() || buffer.getHeight() != getAdjustedBufHeight())

			 throw new QueryException("Error in buffer size");

		 this.bufferForProviders = buffer;

	 }

	 public double[] getStep() {

		 return step;

	 }

	 /**

	  * Gets the task status

	  */

	 public TaskStatus getTaskStatus() {

		 return taskStatus;

	 }