Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.impl.buffer;

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

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

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

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

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

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

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

import org.gvsig.raster.cache.tile.provider.CacheStruct;

import org.gvsig.raster.cache.tile.provider.TileListener;

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;

import org.gvsig.timesupport.Time;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.task.TaskStatus;

/**

 * Default implementation for RasterQuery

 * 

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

 */

public class DefaultRasterQuery implements RasterQuery, SpiRasterQuery {

        public static final int  TYPE_UNDEFINED             = -1;

        public static final int  TYPE_ENTIRE                = 0;

        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                       = -1;

        /*

         * 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 int[]            drawableBands              = new int[]{0};

        private boolean          readOnly                   = false;

        private boolean          memoryBuffer               = false;

        private boolean          storeLastBuffer            = false;

        private Time             time                       = null;

        private boolean                         supersamplingLoadingBuffer = false;

        /**

         * Valor NoData con el que se rellenan las celdas cuando adjustToExtent es false

         */

        private NoData           noDataValueToFill          = null;

        private TileListener     listener                   = null;

        private int              alphaBandNumber            = -1;

        private CacheStruct      cacheStruct                = null;   

        private TaskStatus       taskStatus                 = null;

        //Parameters only for providers

        private BandList         bandList                   = null;

        private Buffer           bufferForProviders         = null;

        //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, 

                        int bufWidth, int bufHeight, TileListener listener) {

                this.requestBoundingBox = requestBoundingBox;

                this.widthForResampling = bufWidth;

                this.heightForResampling = bufHeight;

                this.type = TYPE_TILED;

                this.listener = listener;

        }

        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)

         */

        public void setTileParameters(int level, int tileCol, int tileRow, Extent bbox, CacheStruct cacheStruct) {

                this.type = TYPE_ONE_TILE;

                this.requestBoundingBox = bbox;

                this.resolutionLevel = level;

                this.tileRow = tileRow;

                this.tileCol = tileCol;

                int[] size = null;

                if(cacheStruct != null) {

                        this.cacheStruct = cacheStruct;

                        size = cacheStruct.getTileSizeByLevel(level);

                } else {

                        size = new int[]{TileCacheLibrary.DEFAULT_TILEWIDTH, TileCacheLibrary.DEFAULT_TILEHEIGHT};

                }

                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;

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

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

        /**

         * 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(ul.getX() - lr.getX()));

                int h = (int)Math.ceil(Math.abs(ul.getY() - 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(ul.getX() - lr.getX()));

                h = (int)Math.ceil(Math.abs(ul.getY() - 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};

        }

        private Buffer createBuffer(RasterDataStore store) throws QueryException {

                if(isReadOnly()) {

                        bufferForProviders = DefaultRasterManager.getInstance().createReadOnlyBuffer(

                                        store.getDataType()[0], getAdjustedWidth(), getAdjustedHeight(), store.getBandCount());

                        try {

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

                                                getAdjustedX(), 

                                                getAdjustedY(), 

                                                getAdjustedX() + getAdjustedBufWidth() - 1, 

                                                getAdjustedY() + getAdjustedBufHeight() - 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());

                        if(isMemoryBuffer()) 

                                bufferForProviders = DefaultRasterManager.getInstance().createMemoryBuffer(

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

                        else

                                bufferForProviders = DefaultRasterManager.getInstance().createBuffer(

                                                store.getDataType()[0], getAdjustedBufWidth(), getAdjustedBufHeight(), bandList.getDrawableBandsCount(), 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

                        }

                }

        }

        /**

         * 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()) {

                        calculateStep(store);

                        supersampledBuffers(store);

                }

                //Bands and buffers

                buildDrawableBandList(store.getBands());

                createBuffer(store);

        }

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

        //*********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 int getType() {

                return type;

        }

        public void storeLastBuffer(boolean store) {

                this.storeLastBuffer = store;

        }

        /**

         * The user can told if the buffer will be stored or not in the RasterDatasource.

         * @return store

         */

        public boolean isStoredLastBuffer() {

                return storeLastBuffer;

        }

        public void setAdjustToExtent(boolean adjustToExtent) {

                this.adjustToSrcExtent = adjustToExtent;

        }

        public boolean isAdjustToExtent() {

                return adjustToSrcExtent;

        }

        public int[] getDrawableBands() {

                return drawableBands;

        }

        public void setAllDrawableBands() {

                this.drawableBands = null;

        }

        public void setDrawableBands(int[] drawableBands) {

                this.drawableBands = drawableBands;

        }

        public void setReadOnly(boolean readOnly) {

                this.readOnly = readOnly;

        }

        /**

         * 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() {

                return supersamplingLoadingBuffer;

        }

        /**

         * 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) {

                this.supersamplingLoadingBuffer = supersamplingLoadingBuffer;

        }

        public void setMemoryBuffer(boolean memoryBuffer) {

                this.memoryBuffer = memoryBuffer;

        }

        /**

         * Obtiene el flag que dice si la carga del siguiente buffer es en memoria

         * @return memory true si la siguiente carga de buffer se hace en memoria y false se deja decidir al dataset 

         * el tipo de buffer

         */

        public boolean isMemoryBuffer() {

                return memoryBuffer;

        }

        public void setNoDataToFill(NoData noData) {

                this.noDataValueToFill = noData;

        }

        public void setAlphaBand(int bandNumber) {

                this.alphaBandNumber = bandNumber;

        }

        public int getAlphaBandNumber() {

                return alphaBandNumber;

        }

        public NoData getNoDataValueToFill() {

                return this.noDataValueToFill;

        }

        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) {

                 widthForResampling = h;

         }

         public void setBufWidth(int w) {

                 heightForResampling = 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 setBufferForProviders(Buffer buffer) throws QueryException {

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

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

                 this.bufferForProviders = buffer;

         }

         /**

          * Buffer without adjust to the source limits. This is useful for

          * request with shift. Normally the result will have frames with nodata

          * values

          * @return

          */

         /*public Buffer getBufferWithoutAdjust() {

                 return bufferWithoutAdjust;

         }*/

         /**

          * Buffer without adjust to the source limits. This is useful for

          * request with shift. Normally the result will have frames with nodata

          * values

          */

         /*public void setBufferWithoutAdjust(Buffer buffer) {

                 this.bufferWithoutAdjust = buffer;

         }*/

         public double[] getStep() {

                 return step;

         }

         /**

          * Gets the task status

          */

         public TaskStatus getTaskStatus() {

                 return taskStatus;

         }

}