Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.gdal.io.DefaultGdalIOLibrary

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

import org.gvsig.addo.BuildingOverviewsException;

import org.gvsig.addo.IOverviewIncrement;

import org.gvsig.addo.Jaddo;

import org.gvsig.addo.WritingException;

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

import org.gvsig.fmap.dal.coverage.process.BaseIncrementableTask;

import org.gvsig.fmap.dal.coverage.process.overview.OverviewBuilder;

/**

 * Servicios ofrecidos por el proceso de construcci?n de overviews. Esta

 * implementaci?n usa gdal para construir las overviews.

 * 

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

 */

public class GdalOverviewBuilder implements OverviewBuilder {

	private Jaddo        build         = new Jaddo();

	private int          value         = 0;

	/**

	 * Bindings between an IOverviewIncrement and a BaseIncrementableTask

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

	 */

	class ProcessBinding implements IOverviewIncrement {

		private BaseIncrementableTask  task = null;

		public ProcessBinding(BaseIncrementableTask task) {

			this.task = task;	

		}

		public int getPercent() {

			return task.getPercent();

		}

		public void setPercent(int value) {

			task.setPercent(value);

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.coverage.process.overview.OverviewBuilder#buildOverviews(int, java.lang.String, int[])

	 */

	public void buildOverviews(int resamplingAlg, String file, int[] overviews)

			throws OverviewException {

		try {

			build.buildOverviews(resamplingAlg, file, overviews);

		} catch (BuildingOverviewsException e) {

			throw new OverviewException("Error building overviews", e);

		} catch (WritingException e) {

			throw new OverviewException("Error writing overviews", e);

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.coverage.process.overview.OverviewBuilder#getPercent()

	 */

	public int getPercent() {

		return value;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.coverage.process.overview.OverviewBuilder#setIncrementListener(org.gvsig.addo.IOverviewIncrement)

	 */

	public void setIncrementListener(BaseIncrementableTask incr) {

		build.setIncrementListener(new ProcessBinding(incr));

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.coverage.process.overview.OverviewBuilder#setPercent(int)

	 */

	public void setPercent(int value) {

		this.value = value;

	}

}

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

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALLibrary;

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

import org.gvsig.raster.gdal.overview.GdalOverviewBuilder;

import org.gvsig.raster.gdal.util.DefaultCRSUtils;

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

import org.gvsig.tools.ToolsLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.Library;

import org.gvsig.tools.library.LibraryException;

/**

 *

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

 */

public class DefaultGdalIOLibrary extends AbstractLibrary {	

	public DefaultGdalIOLibrary() {

		super(DefaultGdalIOLibrary.class,Library.TYPE.IMPL);

		require(ToolsLibrary.class);

		require(DALLibrary.class);

		require(DALFileLibrary.class);

	}

	@Override

	protected void doInitialize() throws LibraryException {

		//RasterLibrary.wakeUp();

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		//AbstractRasterFileDataParameters.registerDynClass();

		AbstractNewRasterStoreParameters.registerDynClass();

		// Registro de los drivers de lectura

		GdalProvider.register();

		// Registro de los drivers de escritura

		GdalWriter.register();

		JpegWriter.register();

		PngWriter.register();

		GdalDataParameters.registerDynClass();

		//Register GdalOverviewBuilder

		RasterLocator.getManager().getProviderServices().registerOverviewBuilderImplementation(

				"GDAL",

				new GdalOverviewBuilder());

		//Register CRSUtils

		RasterLocator.getManager().getProviderServices().registerCRSUtilImplementation(

						new DefaultCRSUtils());

	}

}

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

import java.awt.Color;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

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

import org.gvsig.jgdal.Gdal;

import org.gvsig.jgdal.GdalBuffer;

import org.gvsig.jgdal.GdalColorEntry;

import org.gvsig.jgdal.GdalColorTable;

import org.gvsig.jgdal.GdalException;

import org.gvsig.jgdal.GdalRasterBand;

import org.gvsig.jgdal.GeoTransform;

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

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

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

import org.gvsig.raster.impl.process.RasterTask;

import org.gvsig.raster.impl.process.RasterTaskQueue;

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.gvsig.raster.impl.store.properties.DataStoreColorTable;

import org.gvsig.raster.impl.store.properties.DataStoreMetadata;

import org.gvsig.raster.impl.store.properties.DataStoreTransparency;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.task.TaskStatus;

/**

 * Soporte 'nativo' para ficheros desde GDAL.

 * 

 * @author Luis W. Sevilla (sevilla_lui@gva.es)

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

 */

public class GdalNative extends Gdal implements Disposable {

	private String                       fileName                = null;

	private String                       shortName               = "";

	public 	GeoTransform                 trans                   = null;

	public int                           width                   = 0, height = 0;

	public double                        originX                 = 0D, originY = 0D;

	public String                        version                 = "";

	protected int                        rBandNr                 = 1, gBandNr = 2, bBandNr = 3, aBandNr = 4;

	private int[]                        dataType                = null;

	DataStoreMetadata                    metadata                = null;

	protected boolean                    georeferenced           = true;

	/**

	 * Vectores que contiene los desplazamientos de un pixel cuando hay supersampling.

	 * , es decir el n?mero de pixels de pantalla que tiene un pixel de imagen. Como todos

	 * los pixeles no tienen el mismo ancho y alto ha de meterse en un array y no puede ser

	 * una variable. Adem?s hay que tener en cuenta que el primer y ?ltimo pixel son de 

	 * distinto tama?o que el resto.   

	 */

	public int[]                              stepArrayX             = null;

	public int[]                              stepArrayY             = null;

	protected GdalRasterBand[]                gdalBands              = null;

	private double                            lastReadLine           = -1;

	private int                               overviewWidth          = -1;

	private int                               overviewHeight         = -1;

	private int                               currentViewWidth       = -1;

	private int                               currentViewHeight      = -1;

	private double                            currentViewX           = 0D;

	private double                            viewportScaleX         = 0D;

	private double                            viewportScaleY         = 0D;

	private double                            stepX                  = 0D;

	private double                            stepY                  = 0D;

	public boolean                            isSupersampling        = false;

	private boolean                           open                   = false;

	/**

	 * Estado de transparencia del raster.

	 */

	protected DataStoreTransparency           fileTransparency       = null;

	protected DataStoreColorTable             palette                = null;

	protected DataStoreColorInterpretation    colorInterpr           = null;

	protected AffineTransform                 ownTransformation      = null;

	protected AffineTransform                 externalTransformation = new AffineTransform();

	public static int getGdalTypeFromRasterBufType(int rasterBufType) {

		switch (rasterBufType) {

			case Buffer.TYPE_BYTE: return Gdal.GDT_Byte;

			case Buffer.TYPE_USHORT: return Gdal.GDT_UInt16;

			case Buffer.TYPE_SHORT: return Gdal.GDT_Int16;

			case Buffer.TYPE_INT: return Gdal.GDT_Int32;

			case Buffer.TYPE_FLOAT: return Gdal.GDT_Float32;

			case Buffer.TYPE_DOUBLE: return Gdal.GDT_Float64;

			case Buffer.TYPE_UNDEFINED: return Gdal.GDT_Unknown;

			case Buffer.TYPE_IMAGE: return Gdal.GDT_Byte;

		}

		return Gdal.GDT_Unknown;

	}

	/**

	 * Conversi?n de los tipos de datos de gdal a los tipos de datos de RasterBuf

	 * @param gdalType Tipo de dato de gdal

	 * @return Tipo de dato de RasterBuf

	 */

	public static int getRasterBufTypeFromGdalType(int gdalType) {

		switch (gdalType) {

			case 1:// Eight bit unsigned integer GDT_Byte = 1

				return Buffer.TYPE_BYTE;

			case 3:// Sixteen bit signed integer GDT_Int16 = 3,

				return Buffer.TYPE_SHORT;

			case 2:// Sixteen bit unsigned integer GDT_UInt16 = 2

				//return RasterBuffer.TYPE_USHORT;

				return Buffer.TYPE_SHORT; //Apa?o para usar los tipos de datos que soportamos

			case 5:// Thirty two bit signed integer GDT_Int32 = 5

				return Buffer.TYPE_INT;

			case 6:// Thirty two bit floating point GDT_Float32 = 6

				return Buffer.TYPE_FLOAT;

			case 7:// Sixty four bit floating point GDT_Float64 = 7

				return Buffer.TYPE_DOUBLE;

				// TODO:Estos tipos de datos no podemos gestionarlos. Habria que definir

				// el tipo complejo y usar el tipo long que de momento no se gasta.

			case 4:// Thirty two bit unsigned integer GDT_UInt32 = 4,

				return Buffer.TYPE_INT;

				//return RasterBuffer.TYPE_UNDEFINED; // Deberia devolver un Long

			case 8:// Complex Int16 GDT_CInt16 = 8

			case 9:// Complex Int32 GDT_CInt32 = 9

			case 10:// Complex Float32 GDT_CFloat32 = 10

			case 11:// Complex Float64 GDT_CFloat64 = 11

				return Buffer.TYPE_UNDEFINED;

		}

		return Buffer.TYPE_UNDEFINED;

	}

	/**

	 * Overview usada en el ?ltimo setView

	 */

	int currentOverview = -1;

	public GdalNative(String fName) throws GdalException, IOException {

		super();

		init(fName);

	}

	private void init(String fName) throws GdalException, IOException {

		fileName = fName;

		open(fName, GA_ReadOnly);

		open = true;

		if (getPtro() == -1)

			throw new GdalException("Error en la apertura del fichero. El fichero no tiene un formato v?lido.");

//		ext = RasterUtilities.getExtensionFromFileName(fName);

		width = getRasterXSize();

		height = getRasterYSize();

		int[] dt = new int[getRasterCount()];

		for (int i = 0; i < getRasterCount(); i++)

			dt[i] = this.getRasterBand(i + 1).getRasterDataType();

		setDataType(dt);

		shortName = getDriverShortName();

		colorInterpr = new DataStoreColorInterpretation(getRasterCount());

		fileTransparency = new DataStoreTransparency(colorInterpr);

		metadata = new DataStoreMetadata(getMetadata(), colorInterpr);

		// Asignamos la interpretaci?n de color leida por gdal a cada banda. Esto

		// nos sirve para saber que banda de la imagen va asignada a cada banda de

		// visualizaci?n (ARGB)

		metadata.initNoDataByBand(getRasterCount());

		for (int i = 0; i < getRasterCount(); i++) {

			GdalRasterBand rb = getRasterBand(i + 1);

			String colorInt = getColorInterpretationName(rb.getRasterColorInterpretation());

			metadata.setNoDataEnabled(rb.existsNoDataValue());

			if(rb.existsNoDataValue()) {

				metadata.setNoDataValue(i, rb.getRasterNoDataValue());

				metadata.setNoDataEnabled(rb.existsNoDataValue());

			}

			colorInterpr.setColorInterpValue(i, colorInt);

			if (colorInt.equals("Alpha"))

				fileTransparency.setTransparencyBand(i);

			if (rb.getRasterColorTable() != null && palette == null) {

				palette = new DataStoreColorTable(gdalColorTable2ColorItems(rb.getRasterColorTable()), false);

//				fileTransparency.setTransparencyRangeList(palette.getTransparencyRange());

			}

		}

		fileTransparency.setTransparencyByPixelFromMetadata(metadata);

		try {

			trans = getGeoTransform();

			boolean isCorrect = false;

			for (int i = 0; i < trans.adfgeotransform.length; i++)

				if (trans.adfgeotransform[i] != 0)

					isCorrect = true;

			if (!isCorrect)

				throw new GdalException("");

			double psX = trans.adfgeotransform[1];

			double psY = trans.adfgeotransform[5];

			double rotX = trans.adfgeotransform[4];

			double rotY = trans.adfgeotransform[2];

			double offX = trans.adfgeotransform[0];

			double offY = trans.adfgeotransform[3];

			ownTransformation = new AffineTransform(psX, rotX, rotY, psY, offX, offY);

					//trans.adfgeotransform[1], trans.adfgeotransform[4], trans.adfgeotransform[2], trans.adfgeotransform[5], trans.adfgeotransform[0], trans.adfgeotransform[3]);

			externalTransformation = (AffineTransform) ownTransformation.clone();

			overviewWidth = width;

			overviewHeight = height;

			this.georeferenced = true;

		} catch (GdalException exc) {

			// Transformaci�n para ficheros sin georreferenciaci�n. Se invierte la Y

			// ya que las WC decrecen de

			// arriba a abajo y los pixeles crecen de arriba a abajo

			ownTransformation = new AffineTransform(1, 0, 0, -1, 0, height);

			externalTransformation = (AffineTransform) ownTransformation.clone();

			overviewWidth = width;

			overviewHeight = height;

			this.georeferenced = false;

		}

	}

	/**

	 * Returns true if this provider is open and false if don't

	 * @return

	 */

	public boolean isOpen() {

		return open;

	}

	/**

	 * Obtiene el flag que informa de si el raster tiene valor no data o no.

	 * Consultar� todas las bandas del mismo y si alguna tiene valor no data

	 * devuelve true sino devolver� false.

	 * @return true si tiene valor no data y false si no lo tiene

	 * @throws GdalException

	 */

	public boolean existsNoDataValue() throws GdalException {

		for (int i = 0; i < getRasterCount(); i++) {

			GdalRasterBand rb = getRasterBand(i + 1);

			if (rb.existsNoDataValue())

				return true;

		}

		return false;

	}

	/**

	 * Obtiene el flag que informa de si el raster tiene valor no data o no

	 * en una banda concreta.

	 * @return true si tiene valor no data en esa banda y false si no lo tiene

	 * @param band Posici�n de la banda a consultar (0..n)

	 * @throws GdalException

	 */

	public boolean existsNoDataValue(int band) throws GdalException {

		GdalRasterBand rb = getRasterBand(band + 1);

		return rb.existsNoDataValue();

	}

	/**

	 * Gets nodata value

	 * @return

	 */

	public NoData getNoDataValue() {

		Number value = null;

		int type = getRasterBufTypeFromGdalType(getDataType()[0]);

		if (metadata != null && metadata.isNoDataEnabled() && metadata.getNoDataValue().length > 0) {

			switch (type) {

			case Buffer.TYPE_BYTE:

				if (metadata == null || metadata.getNoDataValue().length == 0)

					value = new Byte(RasterLibrary.defaultByteNoDataValue);

				else

					value = new Byte((byte)metadata.getNoDataValue()[0]);

				break;

			case Buffer.TYPE_SHORT:

				if (metadata == null || metadata.getNoDataValue().length == 0)

					value = new Short(RasterLibrary.defaultShortNoDataValue);

				else

					value = new Short((short)metadata.getNoDataValue()[0]);

				break;

			case Buffer.TYPE_INT:

				if (metadata == null || metadata.getNoDataValue().length == 0)

					value = new Integer((int)RasterLibrary.defaultIntegerNoDataValue);

				else

					value = new Integer((int)metadata.getNoDataValue()[0]);

				break;

			case Buffer.TYPE_FLOAT:

				if (metadata == null || metadata.getNoDataValue().length == 0)

					value = new Float(RasterLibrary.defaultFloatNoDataValue);

				else

					value = new Float(metadata.getNoDataValue()[0]);

				break;

			case Buffer.TYPE_DOUBLE:

				if (metadata == null || metadata.getNoDataValue().length == 0)

					value = new Double(RasterLibrary.defaultFloatNoDataValue);

				else

					value = new Double(metadata.getNoDataValue()[0]);

				break;

			}

		}

		NoData nodata = new DefaultNoData(value, value, fileName);

		nodata.setNoDataTransparent(false);

		return nodata;

	}

	/**

	 * Asigna el tipo de dato

	 * @param dt entero que representa el tipo de dato

	 */

	public void setDataType(int[] dt) { 

		dataType = dt; 

	}

	/**

	 * Obtiene el tipo de dato

	 * @return entero que representa el tipo de dato

	 */

	public int[] getDataType() { 

		return dataType; 

	}

	/**

	 * Gets the color interpretation

	 * @return

	 */

	public ColorInterpretation getColorInterpretation() { 

		return colorInterpr; 

	}

	/**

	 * Gets the color table

	 * @return

	 */

	public ColorTable getColorTable() {

		return palette;

	}

	/**

	 * Obtiene un punto 2D con las coordenadas del raster a partir de uno en coordenadas

	 * del punto real.

	 * Supone rasters no girados

	 * @param pt	punto en coordenadas del punto real

	 * @return	punto en coordenadas del raster

	 */

	public Point2D worldToRasterWithoutRot(Point2D pt) {

		Point2D p = new Point2D.Double();

		AffineTransform at = new AffineTransform(	externalTransformation.getScaleX(), 0, 

													0, externalTransformation.getScaleY(), 

													externalTransformation.getTranslateX(), externalTransformation.getTranslateY());

		try {

			at.inverseTransform(pt, p);

		} catch (NoninvertibleTransformException e) {

			return pt;

		}

		return p;

	}

	/**

	 * Obtiene un punto 2D con las coordenadas del raster a partir de uno en coordenadas

	 * del punto real.

	 * Supone rasters no girados

	 * @param pt	punto en coordenadas del punto real

	 * @return	punto en coordenadas del raster

	 */

	public Point2D worldToRaster(Point2D pt) {

		Point2D p = new Point2D.Double();

		try {

			externalTransformation.inverseTransform(pt, p);

		} catch (NoninvertibleTransformException e) {

			return pt;

		}

		return p;

	}

	/**

	 * Obtiene un punto del raster en coordenadas pixel a partir de un punto en coordenadas

	 * reales. 

	 * @param pt Punto en coordenadas reales

	 * @return Punto en coordenadas pixel.

	 */

	public Point2D rasterToWorld(Point2D pt) {

		Point2D p = new Point2D.Double();

		externalTransformation.transform(pt, p);

		return p;

	}

	/**

	 * Calcula el overview a usar. Hay que tener en cuenta que tenemos que tener calculadas las variables

	 * viewPortScale, currentFullWidth y currentFulHeight

	 * @param coordenada pixel expresada en double que indica la posici�n superior izquierda

	 * @throws GdalException

	 */

	private void calcOverview(Point2D tl, Point2D br) throws GdalException {

		gdalBands[0] = getRasterBand(1);

		currentOverview = -1;

		if (gdalBands[0].getOverviewCount() > 0) {

			GdalRasterBand ovb = null;

			for (int i = gdalBands[0].getOverviewCount() - 1; i > 0; i--) {

				ovb = gdalBands[0].getOverview(i);

				if (ovb.getRasterBandXSize() > getRasterXSize() * viewportScaleX) {

					currentOverview = i;

					viewportScaleX *= ((double) width / (double) ovb.getRasterBandXSize());

					viewportScaleY *= ((double) height / (double) ovb.getRasterBandYSize());

					stepX = 1D / viewportScaleX;

					stepY = 1D / viewportScaleY;

					overviewWidth = ovb.getRasterBandXSize();

					overviewHeight = ovb.getRasterBandYSize();

					currentViewX = Math.min(tl.getX(), br.getX());

					lastReadLine = Math.min(tl.getY(), br.getY());

					break;

				}

			}

		}

	}

	public void setView(double dWorldTLX, double dWorldTLY,

						double dWorldBRX, double dWorldBRY,

						int nWidth, int nHeight) throws GdalException {

		overviewWidth = width;

		overviewHeight = height;

		Point2D tl = worldToRaster(new Point2D.Double(dWorldTLX, dWorldTLY));

		Point2D br = worldToRaster(new Point2D.Double(dWorldBRX, dWorldBRY));

		// Calcula cual es la primera l�nea a leer;

		currentViewWidth = nWidth;

		currentViewHeight = nHeight;

//		wcWidth = Math.abs(br.getX() - tl.getX());

		currentViewX = Math.min(tl.getX(), br.getX());

		viewportScaleX = (double) currentViewWidth / (br.getX() - tl.getX());

		viewportScaleY = (double) currentViewHeight / (br.getY() - tl.getY());

		stepX = 1D / viewportScaleX;

		stepY = 1D / viewportScaleY;

		lastReadLine = Math.min(tl.getY(), br.getY());

		//Para lectura del renderizado (ARGB). readWindow selecciona las bandas que necesita.

		// calcula el overview a usar

		gdalBands = new GdalRasterBand[4];

		calcOverview(tl, br);

	}

	/**

	 * Selecciona bandas y overview en el objeto GdalRasterBand[] para el n�mero de bandas solicitado.

	 * @param nbands N�mero de bandas solicitado.

	 * @throws GdalException

	 */

	public void selectGdalBands(int nbands) throws GdalException {

		gdalBands = new GdalRasterBand[nbands];

		// Selecciona las bandas y los overviews necesarios

		gdalBands[0] = getRasterBand(1);

		for (int i = 0; i < nbands; i++)

			gdalBands[i] = gdalBands[0];

		assignDataTypeFromGdalRasterBands(gdalBands);

//		setDataType(gdalBands[0].getRasterDataType());

		for (int i = 2; i <= nbands; i++) {

			if (getRasterCount() >= i) {

				gdalBands[i - 1] = getRasterBand(i);

				for (int j = i; j < nbands; j++)

					gdalBands[j] = gdalBands[i - 1];

			}

		}

		if (currentOverview > 0) {

			gdalBands[0] = gdalBands[0].getOverview(currentOverview);

			for (int i = 2; i <= nbands; i++) {

				if (getRasterCount() >= i)

					gdalBands[i - 1] = gdalBands[i - 1].getOverview(currentOverview);

			}

		}

	}

	int lastY = -1;

	/**

	 * Lee una l�nea de bytes

	 * @param line Buffer donde se cargan los datos

	 * @param initOffset Desplazamiento inicial desde el margen inzquierdo. Esto es necesario para cuando

	 * se supersamplea ya que cada pixel de imagen ocupa muchos pixeles de pantalla y puede empezar a dibujarse

	 * por la izquierda a mitad de pixel

	 * @param gdalBuffer Buffer con la l�nea de datos original

	 */

	private void readLine(byte[][] line, double initOffset, GdalBuffer[] gdalBuffer) {

		double j = 0D;

		int i = 0;

		for (int iBand = 0; iBand < gdalBuffer.length; iBand++) {

			for (i = 0, j = initOffset; i < currentViewWidth && j < gdalBuffer[0].getSize(); i++, j += stepX) {

				line[iBand][i] = gdalBuffer[iBand].buffByte[(int) j];

			}

		}

	}

	/**

	 * Lee una l�nea de shorts

	 * @param line Buffer donde se cargan los datos

	 * @param initOffset Desplazamiento inicial desde el margen inzquierdo. Esto es necesario para cuando

	 * se supersamplea ya que cada pixel de imagen ocupa muchos pixeles de pantalla y puede empezar a dibujarse

	 * por la izquierda a mitad de pixel

	 * @param gdalBuffer Buffer con la l�nea de datos original

	 */

	private void readLine(short[][] line, double initOffset, GdalBuffer[] gdalBuffer) {

		double j = 0D;

		int i = 0;

		for (int iBand = 0; iBand < gdalBuffer.length; iBand++) {

			for (i = 0, j = initOffset; i < currentViewWidth && j < gdalBuffer[0].getSize(); i++, j += stepX) {

				line[iBand][i] = (short) (gdalBuffer[iBand].buffShort[(int) j] & 0xffff);

			}

		}

	}

	/**

	 * Lee una l�nea de ints

	 * @param line Buffer donde se cargan los datos

	 * @param initOffset Desplazamiento inicial desde el margen inzquierdo. Esto es necesario para cuando

	 * se supersamplea ya que cada pixel de imagen ocupa muchos pixeles de pantalla y puede empezar a dibujarse

	 * por la izquierda a mitad de pixel

	 * @param gdalBuffer Buffer con la l�nea de datos original

	 */

	private void readLine(int[][] line, double initOffset, GdalBuffer[] gdalBuffer) {

		double j = 0D;

		int i = 0;

		for (int iBand = 0; iBand < gdalBuffer.length; iBand++) {

			for (i = 0, j = initOffset; i < currentViewWidth && j < gdalBuffer[0].getSize(); i++, j += stepX) {

				line[iBand][i] = (gdalBuffer[iBand].buffInt[(int) j] & 0xffffffff);

			}

		}

	}

	/**

	 * Lee una l�nea de float

	 * @param line Buffer donde se cargan los datos

	 * @param initOffset Desplazamiento inicial desde el margen izquierdo. Esto es necesario para cuando

	 * se supersamplea ya que cada pixel de imagen ocupa muchos pixeles de pantalla y puede empezar a dibujarse

	 * por la izquierda a mitad de pixel

	 * @param gdalBuffer Buffer con la l�nea de datos original

	 */

	private void readLine(float[][] line, double initOffset, GdalBuffer[] gdalBuffer) {

		double j = 0D;

		int i = 0;

		for (int iBand = 0; iBand < gdalBuffer.length; iBand++) {

			for (i = 0, j = initOffset; i < currentViewWidth && j < gdalBuffer[0].getSize(); i++, j += stepX) {

				line[iBand][i] = gdalBuffer[iBand].buffFloat[(int) j];

			}

		}

	}

	/**

	 * Lee una l�nea de doubles

	 * @param line Buffer donde se cargan los datos

	 * @param initOffset Desplazamiento inicial desde el margen inzquierdo. Esto es necesario para cuando

	 * se supersamplea ya que cada pixel de imagen ocupa muchos pixeles de pantalla y puede empezar a dibujarse

	 * por la izquierda a mitad de pixel

	 * @param gdalBuffer Buffer con la l�nea de datos original

	 */

	private void readLine(double[][] line, double initOffset, GdalBuffer[] gdalBuffer) {

		double j = 0D;

		int i = 0;

		for (int iBand = 0; iBand < gdalBuffer.length; iBand++) {

			for (i = 0, j = initOffset; i < currentViewWidth && j < gdalBuffer[0].getSize(); i++, j += stepX) {

				line[iBand][i] = gdalBuffer[iBand].buffDouble[(int) j];

			}

		}

	}

	/**

	 * Lee una l�nea completa del raster y devuelve un array del tipo correcto. Esta funci�n es util

	 * para una lectura rapida de todo el fichero sin necesidad de asignar vista. 

	 * @param nLine N�mero de l�nea a leer

	 * @param band Banda requerida

	 * @return Object que es un array unidimendional del tipo de datos del raster

	 * @throws GdalException

	 */

	public Object readCompleteLine(int nLine, int band) throws GdalException {

		GdalRasterBand gdalBand = super.getRasterBand(band + 1);

		GdalBuffer gdalBuf = null;

		gdalBuf = gdalBand.readRaster(0, nLine, getRasterXSize(), 1, getRasterXSize(), 1, dataType[band]);

		if (dataType[band] == GDT_Byte)

			return gdalBuf.buffByte;

		if (dataType[band] == GDT_Int16 || dataType[band] == GDT_UInt16)

			return gdalBuf.buffShort;

		if (dataType[band] == GDT_Int32 || dataType[band] == GDT_UInt32)

			return gdalBuf.buffInt;

		if (dataType[band] == GDT_Float32)

			return gdalBuf.buffFloat;

		if (dataType[band] == GDT_Float64)

			return gdalBuf.buffDouble;

		if (dataType[band] == GDT_CInt16 || dataType[band] == GDT_CInt32 ||

				dataType[band] == GDT_CFloat32 || dataType[band] == GDT_CFloat64)

			return null;

		return null;

	}

	/**

	 * Lee una bloque completo del raster y devuelve un array tridimensional del tipo correcto. Esta funci�n es util

	 * para una lectura rapida de todo el fichero sin necesidad de asignar vista. 

	 * @param nLine N�mero de l�nea a leer

	 * @param band Banda requerida

	 * @return Object que es un array unidimendional del tipo de datos del raster

	 * @throws GdalException

	 */

	public Object readBlock(int pos, int blockHeight, double scale) throws GdalException, ProcessInterruptedException {

		bBandNr = super.getRasterCount();

		int widthBuffer = (int)(getRasterXSize() * scale);

		int heightBuffer = (int)(blockHeight * scale);

		RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

		GdalRasterBand[] gdalBand = new GdalRasterBand[bBandNr];

		for (int iBand = 0; iBand < gdalBand.length; iBand++) 

			gdalBand[iBand] = super.getRasterBand(iBand + 1);

		GdalBuffer[] gdalBuf = new GdalBuffer[bBandNr];

		if (dataType[0] == GDT_Byte) {

			byte[][][] buf = new byte[bBandNr][heightBuffer][widthBuffer];

			for (int iBand = 0; iBand < gdalBuf.length; iBand++) {

				gdalBuf[iBand] = gdalBand[iBand].readRaster(0, pos, getRasterXSize(), blockHeight, widthBuffer, heightBuffer, dataType[0]);

				for (int iRow = 0; iRow < heightBuffer; iRow++) {

					for (int iCol = 0; iCol < widthBuffer; iCol++) 

						buf[iBand][iRow][iCol] = gdalBuf[iBand].buffByte[iRow * widthBuffer + iCol];

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf[iBand].buffByte = null;

			}	

			return buf;

		} else if (dataType[0] == GDT_CInt16 || dataType[0] == GDT_Int16  || dataType[0] == GDT_UInt16) {

			short[][][] buf = new short[bBandNr][heightBuffer][widthBuffer];

			for (int iBand = 0; iBand < gdalBuf.length; iBand++) {

				gdalBuf[iBand] = gdalBand[iBand].readRaster(0, pos, getRasterXSize(), blockHeight, widthBuffer, heightBuffer, dataType[0]);

				for (int iRow = 0; iRow < heightBuffer; iRow++) {

					for (int iCol = 0; iCol < widthBuffer; iCol++) 

						buf[iBand][iRow][iCol] = gdalBuf[iBand].buffShort[iRow * widthBuffer + iCol];

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf[iBand].buffShort = null;

			}	

			return buf;

		} else if (dataType[0] == GDT_CInt32 || dataType[0] == GDT_Int32  || dataType[0] == GDT_UInt32) {

			int[][][] buf = new int[bBandNr][heightBuffer][widthBuffer];

			for (int iBand = 0; iBand < gdalBuf.length; iBand++) {

				gdalBuf[iBand] = gdalBand[iBand].readRaster(0, pos, getRasterXSize(), blockHeight, widthBuffer, heightBuffer, dataType[0]);

				for (int iRow = 0; iRow < heightBuffer; iRow++) { 

					for (int iCol = 0; iCol < widthBuffer; iCol++)

						buf[iBand][iRow][iCol] = gdalBuf[iBand].buffInt[iRow * widthBuffer + iCol];

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf[iBand].buffInt = null;

			}	

			return buf;

		} else if(dataType[0] == GDT_Float32 || dataType[0] == GDT_CFloat32) {

			float[][][] buf = new float[bBandNr][heightBuffer][widthBuffer];

			for (int iBand = 0; iBand < gdalBuf.length; iBand++) {

				gdalBuf[iBand] = gdalBand[iBand].readRaster(0, pos, getRasterXSize(), blockHeight, widthBuffer, heightBuffer, dataType[0]);

				for (int iRow = 0; iRow < heightBuffer; iRow++) {

					for (int iCol = 0; iCol < widthBuffer; iCol++)

						buf[iBand][iRow][iCol] = gdalBuf[iBand].buffFloat[iRow * widthBuffer + iCol];

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf[iBand].buffFloat = null;

			}	

			return buf;

		} else if(dataType[0] == GDT_Float64 || dataType[0] == GDT_CFloat64) {

			double[][][] buf = new double[bBandNr][heightBuffer][widthBuffer];

			for (int iBand = 0; iBand < gdalBuf.length; iBand++) {

				gdalBuf[iBand] = gdalBand[iBand].readRaster(0, pos, getRasterXSize(), blockHeight, widthBuffer, heightBuffer, dataType[0]);

				for (int iRow = 0; iRow < heightBuffer; iRow++) {

					for (int iCol = 0; iCol < widthBuffer; iCol++) 

						buf[iBand][iRow][iCol] = gdalBuf[iBand].buffDouble[iRow * widthBuffer + iCol];

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf[iBand].buffDouble = null;

			}		

			return buf;

		}

		return null;

	}

	/**

	 * Lectura de una l�nea de datos.

	 * @param line

	 * @throws GdalException

	 */

	public void readLine(Object line) throws GdalException {

		int w = (int) (Math.ceil(((double)currentViewWidth)*stepX) + 1);

		int x = (int) (currentViewX);

		int y = (int) (lastReadLine);

		GdalBuffer r = null, g = null, b = null;

		GdalBuffer a = new GdalBuffer();

		while(y >= gdalBands[0].getRasterBandYSize())

			y--;

		if (x+w > gdalBands[0].getRasterBandXSize()) 

			w = gdalBands[0].getRasterBandXSize()-x;

		if(gdalBands[0].getRasterColorTable() != null) {

			palette = new DataStoreColorTable(gdalColorTable2ColorItems(gdalBands[0].getRasterColorTable()), false);

			r = gdalBands[0].readRaster(x, y, w, 1, w, 1, dataType[0]);

		} else {

			a.buffByte = new byte[w];

			r = gdalBands[0].readRaster(x, y, w, 1, w, 1, dataType[0]);

			g = b = r;

			if (getRasterCount() > 1 && gdalBands[1] != null)

				g = gdalBands[1].readRaster(x, y, w, 1, w, 1, dataType[0]);

			if (getRasterCount() > 2 && gdalBands[2] != null)

				b = gdalBands[2].readRaster(x, y, w, 1, w, 1, dataType[0]);

		}

		lastReadLine += stepY;

		double initOffset =  Math.abs(currentViewX - ((int)currentViewX));

		GdalBuffer[] bands = {r, g, b};

		if (dataType[0] == GDT_Byte)

			readLine((byte[][])line, initOffset, bands);

		else if (dataType[0] == GDT_CInt16 || dataType[0] == GDT_Int16  || dataType[0] == GDT_UInt16)

			readLine((short[][])line, initOffset, bands);

		else if (dataType[0] == GDT_CInt32 || dataType[0] == GDT_Int32  || dataType[0] == GDT_UInt32)

			readLine((int[][])line, initOffset, bands);

		else if(dataType[0] == GDT_Float32 || dataType[0] == GDT_CFloat32)

			readLine((float[][])line, initOffset, bands);

		else if(dataType[0] == GDT_Float64 || dataType[0] == GDT_CFloat64)

			readLine((double[][])line, initOffset, bands);

		return;

	}

	private List<ColorItem> gdalColorTable2ColorItems(GdalColorTable table) {

		try {

			List<ColorItem> colorItems = new ArrayList<ColorItem>();

			for (int iEntry = 0; iEntry < table.getColorEntryCount(); iEntry++) {

				GdalColorEntry entry = table.getColorEntryAsRGB(iEntry);

				ColorItem colorItem = new ColorItemImpl();

				colorItem.setNameClass("");

				colorItem.setValue(iEntry);

				colorItem.setColor(new Color(	(int) (entry.c1 & 0xff),

																			(int) (entry.c2 & 0xff),

																			(int) (entry.c3 & 0xff),

																			(int) (entry.c4 & 0xff)));

				colorItems.add(colorItem);

			}

			return colorItems;

		} catch (GdalException ex) {

			// No se crea la paleta

		}

		return null;

	}

	/**

	 * Cuando se hace una petici�n de carga de buffer la extensi�n pedida puede

	 * estar ajustada a la extensi�n del raster o no estarlo. En caso de no

	 * estarlo los pixeles del buffer que caen fuera de la extensi�n del raster

	 * tendr�n valor de NoData. Esta funci�n calcula en que pixel del buffer hay

	 * que empezar a escribir en caso de que este sea mayor que los datos a leer.

	 * 

	 * @param dWorldTLX Posici�n X superior izquierda en coord reales

	 * @param dWorldTLY Posici�n Y superior izquierda en coord reales

	 * @param dWorldBRX Posici�n X inferior derecha en coord reales

	 * @param dWorldBRY Posici�n Y inferior derecha en coord reales

	 * @param nWidth Ancho en pixeles del buffer

	 * @param nHeight Alto en pixeles del buffer

	 * @return desplazamiento dentro del buffer en X e Y

	 */ 

	private int[] calcStepBuffer(Extent dataExtent, int nWidth, int nHeight, int[] stpBuffer) {

		Extent imageExtent = getExtentWithoutRot();

		Extent ajustDataExtent = RasterLocator.getManager().getRasterUtils().calculateAdjustedView(dataExtent, imageExtent);

		if(!RasterLocator.getManager().getRasterUtils().compareExtents(dataExtent, ajustDataExtent)){

			Point2D p1 = worldToRasterWithoutRot(new Point2D.Double(ajustDataExtent.minX(), ajustDataExtent.maxY()));

			Point2D p2 = worldToRasterWithoutRot(new Point2D.Double(ajustDataExtent.maxX(), ajustDataExtent.minY()));

			Point2D p3 = worldToRasterWithoutRot(new Point2D.Double(dataExtent.minX(), dataExtent.maxY()));

			//    		Point2D p4 = worldToRasterWithoutRot(new Point2D.Double(dataExtent.maxX(), dataExtent.minY()));

			//Ese es el ancho y alto q tendr�a el buffer en caso de haberse ajustado

			int w = (int)Math.abs(Math.ceil(p2.getX()) - Math.floor(p1.getX())); 

			int h = (int)Math.abs(Math.floor(p1.getY()) - Math.ceil(p2.getY()));

			stpBuffer[0] = (int)(p1.getX() + (-p3.getX()));

			stpBuffer[1] = (int)(p1.getY() + (-p3.getY()));

			stpBuffer[2] = stpBuffer[0] + w; 

			stpBuffer[3] = stpBuffer[1] + h;

			return new int[]{w, h};

		}

		return new int[]{nWidth, nHeight};

	}

	/**

	 * Lee una ventana de datos sin resampleo a partir de coordenadas reales.

	 * @param buf Buffer donde se almacenan los datos

	 * @param bandList Lista de bandas que queremos leer y sobre que bandas del buffer de destino queremos escribirlas

	 * @param dWorldTLX Posici�n X superior izquierda en coord reales

	 * @param dWorldTLY Posici�n Y superior izquierda en coord reales

	 * @param dWorldBRX Posici�n X inferior derecha en coord reales

	 * @param dWorldBRY Posici�n Y inferior derecha en coord reales

	 * @param nWidth Ancho en pixeles del buffer

	 * @param nHeight Alto en pixeles del buffer

	 * @throws GdalException

	 */

	public void readWindow(Buffer buf, BandList bandList, double ulx, double uly,double lrx, double lry,

			int nWidth, int nHeight, boolean adjustToExtent, TaskStatus status) throws GdalException, ProcessInterruptedException {

		Extent petExtent = new ExtentImpl(ulx, uly, lrx, lry);

		setView(ulx, uly, lrx, lry, nWidth, nHeight);

		Point2D tl = worldToRaster(new Point2D.Double(ulx, uly));

		Point2D br = worldToRaster(new Point2D.Double(lrx, lry));

		if(tl.getX() > br.getX())

			tl.setLocation(tl.getX() - 1, tl.getY());

		else

			br.setLocation(br.getX() - 1, br.getY());

		if(tl.getY() > br.getY())

			tl.setLocation(tl.getX(), tl.getY() - 1);

		else

			br.setLocation(br.getX(), br.getY() - 1);

		if(gdalBands.length == 0)

			return;

		selectGdalBands(/*buf.getBandCount()*/getRasterCount());

		int x = (int) Math.round(Math.min(tl.getX(), br.getX()));

		int y = (int) Math.round(Math.min(tl.getY(), br.getY()));

		int[] stpBuffer = new int[]{0, 0 , buf.getWidth(), buf.getHeight()};

		//Si el buffer no se ajusta al extent entonces calculamos en que posici�n comienza a escribirse dentro del buffer

		//ya que lo que cae fuera ser�n valores NoData

		if(!adjustToExtent){

			int[] wh = calcStepBuffer(petExtent, nWidth, nHeight, stpBuffer);

			if(x < 0)

				x  = 0;

			if(y < 0)

				y  = 0;

			readDataCachedBuffer(buf, bandList, new int[]{x, y, wh[0], wh[1]}, 

					wh[0], wh[1], 0, 0, stpBuffer, status);

			return;

		}

		readDataCachedBuffer(buf, bandList, new int[]{x, y, nWidth, nHeight}, 

				nWidth, nHeight, 0, 0, stpBuffer, status);

	}

	public void readWindow(Buffer buf, BandList bandList, Extent ext, Rectangle adjustedWindow, TaskStatus status) throws GdalException, ProcessInterruptedException {

		setView(ext.getULX(), ext.getULY(), ext.getLRX(), ext.getLRY(), buf.getWidth(), buf.getHeight());

		if(gdalBands.length == 0)

			return;

		selectGdalBands(getRasterCount());

		int[] stpBuffer = new int[]{0, 0 , buf.getWidth(), buf.getHeight()};

		adjustedWindow = getAdjustedWindowInOverviewCoordinates(adjustedWindow);

		readDataCachedBuffer(buf, 

				bandList, 

				new int[]{(int)adjustedWindow.getX(), (int)adjustedWindow.getY(), (int)adjustedWindow.getWidth(), (int)adjustedWindow.getHeight()}, 

				buf.getWidth(), 

				buf.getHeight(), 

				0, 0, stpBuffer, status);

	}

	/**

	 * Adjust the request rectangle to the overview size. The requests in Gdal have to be

	 * in the overview scale

	 * @param adjustedWindow

	 * @return

	 */

	private Rectangle getAdjustedWindowInOverviewCoordinates(Rectangle adjustedWindow) {

		int nWidth = (int)(((long)adjustedWindow.getWidth() * overviewWidth) / width);

		int nHeight = (int)(((long)adjustedWindow.getHeight() * overviewHeight) / height);

		int x = (int)(((long)adjustedWindow.getX() * (long)overviewWidth) / (long)width);

		int y = (int) (((long)adjustedWindow.getY() * (long)overviewHeight) / (long)height);

		return new Rectangle(x, y, nWidth, nHeight);

	}

	/**

	 * Lee una ventana de datos con resampleo a partir de coordenadas reales. Este m�todo lee la

	 * ventana de una vez cargando los datos de un golpe en el buffer. Las coordenadas se solicitan

	 * en coordenadas del mundo real por lo que estas pueden caer en cualquier parte de un pixel.

	 * Esto se hace m�s evidente cuando supersampleamos en la petici�n, es decir el buffer de de 

	 * mayor tama�o que el n�mero de pixels solicitado.

	 * 

	 * Para resolver esto escribiremos con la funci�n readRaster los datos sobre un buffer mayor 

	 * que el solicitado. Despu�s calcularemos el desplazamiento en pixels dentro de este buffer 

	 * de mayor tama�o hasta llegar a la coordenada real donde comienza la petici�n real que ha

	 * hecho el usuario. Esto es as� porque cuando supersampleamos no queremos los pixeles del 

	 * raster de disco completos sino que en los bordes del buffer quedan cortados.  

	 *  

	 * @param buf Buffer donde se almacenan los datos

	 * @param bandList Lista de bandas que queremos leer y sobre que bandas del buffer de destino queremos escribirlas

	 * @param dWorldTLX Posici�n X superior izquierda en coord reales

	 * @param dWorldTLY Posici�n Y superior izquierda en coord reales

	 * @param dWorldBRX Posici�n X inferior derecha en coord reales

	 * @param dWorldBRY Posici�n Y inferior derecha en coord reales

	 * @param nWidth Ancho en pixeles de la petici�n

	 * @param nHeight Alto en pixeles de la petici�n

	 * @param bufWidth Ancho del buffer

	 * @param bufHeight Alto del buffer

	 * @throws GdalException

	 */

	public void readWindow(Buffer buf, BandList bandList, double ulx, double uly, double lrx, double lry,

							double nWidth, double nHeight, int bufWidth, int bufHeight, boolean adjustToExtent, TaskStatus status) throws GdalException, ProcessInterruptedException {

		Extent petExtent = new ExtentImpl(ulx, uly, lrx, lry);

		setView(ulx, uly, lrx, lry, bufWidth, bufHeight);

		Point2D ul = worldToRaster(new Point2D.Double(ulx, uly));

		Point2D lr = worldToRaster(new Point2D.Double(lrx, lry));

		ul.setLocation(ul.getX() < 0 ? 1 : ul.getX(), ul.getY() < 0 ? 1 : ul.getY());

		lr.setLocation(lr.getX() < 0 ? 1 : lr.getX(), lr.getY() < 0 ? 1 : lr.getY());

		ul.setLocation(ul.getX() - 0.5, ul.getY() - 0.5);

		lr.setLocation(lr.getX() - 0.5, lr.getY() - 0.5);

		adjustPoints(ul, lr);

		if(gdalBands.length == 0)

			return;

		selectGdalBands(/*buf.getBandCount()*/getRasterCount());

		Rectangle requestWindow = new Rectangle(

				(int) Math.min(ul.getX(), lr.getX()), 

				(int) Math.min(ul.getY(), lr.getY()), 

				(int)nWidth, 

				(int)nHeight);

		requestWindow = getAdjustedWindowInOverviewCoordinates(requestWindow); 

		int[] stpBuffer = new int[]{0, 0 , buf.getWidth(), buf.getHeight()};

		//Si el buffer no se ajusta al extent entonces calculamos en que posici�n comienza a escribirse dentro del buffer

		//ya que lo que cae fuera ser�n valores NoData

		if(!adjustToExtent){

			int[] wh = calcStepBuffer(petExtent, bufWidth, bufHeight, stpBuffer);

			if(requestWindow.getX() < 0)

				requestWindow.setLocation(0, (int)requestWindow.getY());

			if(requestWindow.getY() < 0)

				requestWindow.setLocation((int)requestWindow.getX(), 0);

			stpBuffer[0] = (int)((stpBuffer[0] * bufWidth) / requestWindow.getWidth());

			stpBuffer[1] = (int)((stpBuffer[1] * bufHeight) / requestWindow.getHeight());

			stpBuffer[2] = (int)((stpBuffer[2] * bufWidth) / requestWindow.getWidth());

			stpBuffer[3] = (int)((stpBuffer[3] * bufHeight) / requestWindow.getHeight());

			bufWidth = (int)Math.abs(stpBuffer[2] - stpBuffer[0]);

			bufHeight = (int)Math.abs(stpBuffer[3] - stpBuffer[1]);

			readDataCachedBuffer(buf, bandList, 

					new int[]{(int)requestWindow.getX(), (int)requestWindow.getY(), wh[0], wh[1]}, 

						bufWidth, bufHeight, 0, 0, stpBuffer, status);

			return;

		}

		if ((requestWindow.getX() + requestWindow.getWidth()) > gdalBands[0].getRasterBandXSize()) 

			requestWindow.setSize((int)(gdalBands[0].getRasterBandXSize() - requestWindow.getX()), (int)requestWindow.getHeight());

		if ((requestWindow.getY() + requestWindow.getHeight()) > gdalBands[0].getRasterBandYSize()) 

			requestWindow.setSize((int)requestWindow.getWidth(), (int)(gdalBands[0].getRasterBandYSize() - requestWindow.getY()));

		readDataCachedBuffer(buf, bandList, 

				new int[]{(int)requestWindow.getX(), (int)requestWindow.getY(), (int)requestWindow.getWidth(), (int)requestWindow.getHeight()}, 

				bufWidth, bufHeight, 0, 0, stpBuffer, status);

	}

	private void adjustPoints(Point2D ul, Point2D lr) {

		double a = (ul.getX() - (int)ul.getX());

		double b = (ul.getY() - (int)ul.getY());

		ul.setLocation(	(a > 0.95 || a < 0.05) ? Math.round(ul.getX()) : ul.getX(), 

						(b > 0.95 || b < 0.05) ? Math.round(ul.getY()) : ul.getY());

		lr.setLocation(	(a > 0.95 || a < 0.05) ? Math.round(lr.getX()) : lr.getX(), 

						(b > 0.95 || b < 0.05) ? Math.round(lr.getY()) : lr.getY());

	}

	/**

	 * Lee una ventana de datos con resampleo a partir de coordenadas en pixeles. Este m�todo lee la

	 * ventana de una vez cargando los datos de un golpe en el buffer.

	 * @param buf Buffer donde se almacenan los datos

	 * @param bandList Lista de bandas que queremos leer y sobre que bandas del buffer de destino queremos escribirlas

	 * @param x Posici�n X en pixeles

	 * @param y Posici�n Y en pixeles

	 * @param w Ancho en pixeles

	 * @param h Alto en pixeles

	 * @param bufWidth Ancho del buffer

	 * @param bufHeight Alto del buffer

	 * @throws GdalException

	 */

	public void readWindow(Buffer buf, BandList bandList, int x, int y, int w, int h, TaskStatus status) throws GdalException, ProcessInterruptedException {

		gdalBands = new GdalRasterBand[getRasterCount()];

		if(buf.getWidth() == w && buf.getHeight() == h)

			isSupersampling = false;

		if(gdalBands.length == 0)

			return;

		// Selecciona las bandas

		gdalBands[0] = getRasterBand(1);

		for(int iBand = 1; iBand < gdalBands.length; iBand++)

			gdalBands[iBand] = getRasterBand(iBand + 1);

		assignDataTypeFromGdalRasterBands(gdalBands);

		int[] stpBuffer = new int[]{0, 0 , buf.getWidth(), buf.getHeight()};

		readDataCachedBuffer(buf, bandList, new int[]{x, y, w, h}, buf.getWidth(), buf.getHeight(), 0, 0, stpBuffer, status);

	}

	/**

	 * Asigna el tipo de datos de las bandas a partir de una lista de GdalRasterBands

	 * @param gdalBands

	 * @throws GdalException

	 */

	private void assignDataTypeFromGdalRasterBands(GdalRasterBand[] gdalBands) throws GdalException {

		int[] dt = new int[gdalBands.length];

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

			if(gdalBands[i] != null)

				dt[i] = gdalBands[i].getRasterDataType();

		}

		setDataType(dt);

	}

	/**

	 * Lee una ventana de datos. Esta funci?n es usuada por

	 * readWindow para coordenadas reales y readWindow en coordenadas pixel. Esta es una versi?n de readData pero

	 * comprueba si el buffer es cacheado y si lo es pide por trozos para no intentar cargar desde gdal demasiados

	 * datos.

	 * @param buf Buffer donde se almacenan los datos

	 * @param bandList Lista de bandas que queremos leer y sobre que bandas del buffer de destino queremos escribirlas

	 * @param inputWindow

	 * <UL>

	 * <LI>inputWindow[0]:Posici?n X en pixeles de la imagen de entrada</LI>

	 * <LI>inputWindow[1]:Posici?n Y en pixeles de la imagen de entrada</LI>

	 * <LI>inputWindow[2]:Ancho en p?xeles a leer de la imagen de entrada</LI>

	 * <LI>inputWindow[3]:Alto en p?xeles a leer de la imagen de entrada</LI>

	 * </UL>

	 * @param bufWidth Ancho del buffer de la imagen de entrada. Si no coincide con inputWindow[2] el propio gdal resamplea

	 * @param bufHeight Alto del buffer de la imagen de entrada. Si no coincide con inputWindow[3] el propio gdal resamplea

	 * @param stepX Desplazamiento en p?xeles en X a partir de la posici?n x. Este desplazamiento es util cuando hay un 

	 * supersampleo ya que puede ser que de los pixeles que est?n en el borde izquierdo de la petici?n solo queramos una

	 * parte de ellos. 

	 * @param stepY Desplazamiento en p?xeles en Y a partir de la posici?n y. Este desplazamiento es util cuando hay un 

	 * supersampleo ya que puede ser que de los p?xeles que est?n en el borde superior de la petici?n solo queramos una

	 * parte de ellos.

	 * @param stepBuffer El buffer puede empezar a escribirse a partir de un pixel determinado y acabar de escribir antes 

	 * de fin de buffer. Este par?metro indica el desplazamiento desde el inicio del buffer y la posici?n final.

	 * <UL>

	 * <LI>stepBuffer[0]:Desplazamiento en X desde el inicio</LI>

	 * <LI>stepBuffer[1]:Desplazamiento en Y desde el inicio</LI>

	 * <LI>stepBuffer[2]:Posici?n X final m?s uno</LI>

	 * <LI>stepBuffer[3]:Posici?n Y final m?s uno</LI>

	 * </UL>

	 * @throws GdalException

	 */

	private void readDataCachedBuffer(Buffer buf, 

			BandList bandList, 

			int[] inputWindow, 

			int bufWidth, 

			int bufHeight, 

			int stpX, 

			int stpY, 

			int[] stepBuffer,

			TaskStatus status) throws GdalException, ProcessInterruptedException {

		if(buf.isCached()) {

			int nBlocks = (int)(buf.getHeight() / buf.getBlockHeight());

			int lastblock = buf.getHeight() - (nBlocks * buf.getBlockHeight());

			if(lastblock > 0)

				nBlocks ++;

			int initYSrc = inputWindow[1];

			int stepYSrc = (buf.getBlockHeight() * inputWindow[3]) / buf.getHeight();

			int lastBlockYSrc = (lastblock * inputWindow[3]) / buf.getHeight();

			int initYBuffer = 0;

			for (int i = 0; i < nBlocks; i++) {

				if(lastblock > 0 && i == (nBlocks - 1)) {

					int[] newStepBuffer = new int[]{0, initYBuffer, stepBuffer[2], initYBuffer + lastblock};

					int[] newWindow = new int[]{inputWindow[0], initYSrc, inputWindow[2], lastBlockYSrc};

					readData(buf, 

							bandList, 

							newWindow, 

							bufWidth, lastblock, 0, 0, newStepBuffer);

				} else {

					int[] newStepBuffer = new int[]{0, initYBuffer, stepBuffer[2], initYBuffer + buf.getBlockHeight()};

					int[] newWindow = new int[]{inputWindow[0], initYSrc, inputWindow[2], stepYSrc};

					readData(buf, 

							bandList, 

							newWindow, 

							bufWidth, buf.getBlockHeight(), 0, 0, newStepBuffer);

					initYSrc += stepYSrc;

					initYBuffer += buf.getBlockHeight();

				}

			}

		} else {

			readData(buf, bandList, inputWindow, bufWidth, bufHeight, 0, 0, stepBuffer);

		}

	}

	/**

	 * Lee una ventana de datos. Esta funci?n es usuada por

	 * readWindow para coordenadas reales y readWindow en coordenadas pixel. 

	 * @param buf Buffer donde se almacenan los datos

	 * @param bandList Lista de bandas que queremos leer y sobre que bandas del buffer de destino queremos escribirlas

	 * @param inputWindow

	 * <UL>

	 * <LI>inputWindow[0]:Posici?n X en pixeles de la imagen de entrada</LI>

	 * <LI>inputWindow[1]:Posici?n Y en pixeles de la imagen de entrada</LI>

	 * <LI>inputWindow[2]:Ancho en p?xeles a leer de la imagen de entrada</LI>

	 * <LI>inputWindow[3]:Alto en p?xeles a leer de la imagen de entrada</LI>

	 * </UL>

	 * @param bufWidth Ancho del buffer de la imagen de entrada. Si no coincide con inputWindow[2] el propio gdal resamplea

	 * @param bufHeight Alto del buffer de la imagen de entrada. Si no coincide con inputWindow[3] el propio gdal resamplea

	 * @param stepX Desplazamiento en p?xeles en X a partir de la posici?n x. Este desplazamiento es util cuando hay un 

	 * supersampleo ya que puede ser que de los pixeles que est?n en el borde izquierdo de la petici?n solo queramos una

	 * parte de ellos. 

	 * @param stepY Desplazamiento en p?xeles en Y a partir de la posici?n y. Este desplazamiento es util cuando hay un 

	 * supersampleo ya que puede ser que de los p?xeles que est?n en el borde superior de la petici?n solo queramos una

	 * parte de ellos.

	 * @param stepBuffer El buffer puede empezar a escribirse a partir de un pixel determinado y acabar de escribir antes 

	 * de fin de buffer. Este par?metro indica el desplazamiento desde el inicio del buffer y la posici?n final.

	 * <UL>

	 * <LI>stepBuffer[0]:Desplazamiento en X desde el inicio</LI>

	 * <LI>stepBuffer[1]:Desplazamiento en Y desde el inicio</LI>

	 * <LI>stepBuffer[2]:Posici?n X final m?s uno</LI>

	 * <LI>stepBuffer[3]:Posici?n Y final m?s uno</LI>

	 * </UL>

	 * @throws GdalException

	 */

	private void readData(Buffer buf, 

			BandList bandList, 

			int[] inputWindow, 

			int bufWidth, 

			int bufHeight, 

			int stpX, 

			int stpY, 

			int[] stepBuffer) throws GdalException, ProcessInterruptedException {

		RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + ""); 

		FileUtils fUtil = RasterLocator.getManager().getFileUtils(); 

		GdalBuffer gdalBuf = null;

		for(int iBand = 0; iBand < gdalBands.length; iBand++) {

			int[] drawableBands = bandList.getBufferBandToDraw(fUtil.getFormatedRasterFileName(fileName), iBand);

			if(drawableBands == null || (drawableBands.length == 1 && drawableBands[0] == -1))

				continue;	

			int init = (int)((bufWidth * stpY) + stpX); //Pos inicial. Desplazamos stpX pixels hacia la derecha y bajamos stpY lineas

			int pos = init;

			gdalBuf = gdalBands[iBand].readRaster(	inputWindow[0], 

													inputWindow[1], 

													inputWindow[2], 

													inputWindow[3], 

													bufWidth, 

													bufHeight, 

													dataType[iBand]);

			int lineInputWindow = 0;

			if(dataType[iBand] == Gdal.GDT_Byte) {

				for (int line = stepBuffer[1]; line < stepBuffer[3]; line++) {

					pos = (int)((bufWidth * (lineInputWindow - stepBuffer[0])) + init);

					for (int col = stepBuffer[0]; col < stepBuffer[2]; col ++) {

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

							buf.setElem(line, col, drawableBands[i], gdalBuf.buffByte[pos]);

						pos ++;

					}

					lineInputWindow ++;

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf.buffByte = null;

			} else if((dataType[iBand] == Gdal.GDT_UInt16) || (dataType[iBand] == Gdal.GDT_Int16) || (dataType[iBand] == Gdal.GDT_CInt16)) {

				for (int line = stepBuffer[1]; line < stepBuffer[3]; line++) {

					pos = (int)((bufWidth * (lineInputWindow - stepBuffer[0])) + init);

					for (int col = stepBuffer[0]; col < stepBuffer[2]; col ++) {

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

							buf.setElem(line, col, drawableBands[i], gdalBuf.buffShort[pos]);

						pos ++;

					}

					lineInputWindow ++;

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf.buffShort = null;

			} else if((dataType[iBand] == Gdal.GDT_UInt32) || (dataType[iBand] == Gdal.GDT_Int32) || (dataType[iBand] == Gdal.GDT_CInt32)) {

				for (int line = stepBuffer[1]; line < stepBuffer[3]; line++) {

					pos = (int)((bufWidth * (lineInputWindow - stepBuffer[0])) + init);

					for (int col = stepBuffer[0]; col < stepBuffer[2]; col ++) {

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

							buf.setElem(line, col, drawableBands[i], gdalBuf.buffInt[pos]);

						pos ++;

					}

					lineInputWindow ++;

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf.buffInt = null;

			} else if(dataType[iBand] == Gdal.GDT_Float32) {

				for (int line = stepBuffer[1]; line < stepBuffer[3]; line++) {

					pos = (int)((bufWidth * (lineInputWindow - stepBuffer[0])) + init);

					for (int col = stepBuffer[0]; col < stepBuffer[2]; col ++) {

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

							buf.setElem(line, col, drawableBands[i], gdalBuf.buffFloat[pos]);

						pos ++;

					}

					lineInputWindow ++;

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf.buffFloat = null;

			} else if(dataType[iBand] == Gdal.GDT_Float64) {

				for (int line = stepBuffer[1]; line < stepBuffer[3]; line++) {

					pos = (int)((bufWidth * (lineInputWindow - stepBuffer[0])) + init);

					for (int col = stepBuffer[0]; col < stepBuffer[2]; col ++) {

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

							buf.setElem(line, col, drawableBands[i], gdalBuf.buffDouble[pos]);

						pos ++;

					}

					lineInputWindow ++;

					if(task.getEvent() != null)

						task.manageEvent(task.getEvent());

				}

				gdalBuf.buffDouble = null;

			}

		}

	}

	/**

	 * Lee una ventana de datos sin resampleo a partir de coordenadas en pixeles. Esta funci�n es usuada por

	 * readWindow para coordenadas reales y readWindow en coordenadas pixel. 

	 * @param buf Buffer donde se almacenan los datos

	 * @param bandList Lista de bandas que queremos leer y sobre que bandas del buffer de destino queremos escribirlas

	 * @param x Posici�n X en pixeles

	 * @param y Posici�n Y en pixeles

	 * @param w Ancho en pixeles

	 * @param yMax altura m�xima de y

	 * @throws GdalException

	 */

	@SuppressWarnings("unused")

	private void readDataByLine(Buffer buf, BandList bandList, int x, int y, int w, int yMax) throws GdalException, ProcessInterruptedException {

		GdalBuffer gdalBuf = null;

		int rasterBufLine;

		RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

		FileUtils fUtil = RasterLocator.getManager().getFileUtils(); 

		for(int iBand = 0; iBand < gdalBands.length; iBand++) {

			int[] drawableBands = bandList.getBufferBandToDraw(fUtil.getFormatedRasterFileName(fileName), iBand);

			if(drawableBands == null || (drawableBands.length == 1 && drawableBands[0] == -1))

				continue;	

			if(dataType[iBand] == Gdal.GDT_Byte) {

				for (int line = y; line < yMax; line++) {

					gdalBuf = gdalBands[iBand].readRaster(x, line, w, 1, w, 1, dataType[iBand]);

					rasterBufLine = line - y;

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

						buf.setLineInBandByte(gdalBuf.buffByte, rasterBufLine, drawableBands[i]);

					}