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

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gdal.osr.SpatialReference;

import org.gvsig.fmap.crs.CRSFactory;

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

/**

 * Esta clase se encarga de hacer la conversion entre Wkt e IProjection.

 *

 * El uso se hace mediante dos llamadas estaticas que son:

 * convertIProjectionToWkt y

 * convertWktToIProjection.

 *

 * Antes de usarlos, hay que saber si tenemos acceso a gvSIG e intentar coger el

 * factory desde all?.

 * Ya que su uso consume tiempo y espacio de memoria y es preferible

 * reaprovechar ese objeto ya

 * creado. Esto se hace con setCRSFactory.

 *

 * En caso de no asignarse el ya existente, el crear? uno interno y lo dejara en

 * una variable estatica.

 *

 * @version 11/07/2008

 * @author BorSanZa - Borja S?nchez Zamorano (borja.sanchez@iver.es)

 */

public class DefaultCRSUtils implements CRSUtils {

    private ICRSFactory factory = null;

    public void setCRSFactory(ICRSFactory factory) {

        this.factory = factory;

    }

    /**

     * Devuelve el CRSFactory asignado desde fuera o creado desde dentro, todo

     * depende de como se haya

     * usado.

     *

     * @param code

     * @return

     */

    private IProjection getCRS(String code) {

        if (factory == null)

            factory = CRSFactory.getCRSFactory(); // new ProjectionPool();

        return factory.get(code);

    }

    public IProjection convertWktToIProjection(String wkt) {

        if (wkt == null || wkt.equals(""))

            return null;

        String code = null;

        String name = null;

        SpatialReference oSRSSource = new SpatialReference();

        oSRSSource.ImportFromWkt(wkt);

        code = oSRSSource.GetAuthorityCode("PROJCS");

        if (code == null)

            code = oSRSSource.GetAuthorityCode("GEOGCS");

        name = oSRSSource.GetAuthorityName("PROJCS");

        if (name == null)

            name = oSRSSource.GetAuthorityName("GEOGCS");

        try {

            if (name != null && code != null)

                return getCRS(name + ":" + code);

        } catch (NumberFormatException ex) {

            return null;

        }

        return null;

    }

    public String convertIProjectionToWkt(IProjection projection) {

        if (projection == null)

            return null;

        return projection.export(ICRSFactory.FORMAT_WKT);

    }

}

/* 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 java.awt.geom.AffineTransform;

import java.io.File;

import java.io.IOException;

import org.cresques.cts.IProjection;

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

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

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

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

import org.gvsig.jgdal.GdalDataset;

import org.gvsig.jgdal.GdalDriver;

import org.gvsig.jgdal.GdalException;

import org.gvsig.raster.gdal.io.features.PngFeatures;

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

import org.gvsig.raster.impl.store.writer.DefaultRasterWriter;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

/**

 * Driver para la escritura de Png.

 * Este driver utiliza GdalWriter para salvar Png.

 * La escritura de un png no es posible utilizando un servidor de datos

 * como el que usan los drivers comunes por lo que ser? necesario salvar antes

 * a Tif con el driver de Gdal para posteriormente convertir la imagen completa

 * a png. El problema que tiene es el mismo del jpg y es que el dataset solo soporta la

 * escritura rw y no rw+.

 *

 * @version 22/07/2008

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

 */

public class PngWriter extends DefaultRasterWriter {

	// Datos de registro de drivers

	public static void register() {

		DefaultProviderServices pInfo = (DefaultProviderServices)RasterLocator.getManager().getProviderServices();

		ExtensionPointManager extensionPoints =ToolsLocator.getExtensionPointManager();

		ExtensionPoint point=extensionPoints.get("RasterWriter");

		point.append("png", "", PngWriter.class);

		pInfo.getFileFeature().put("png", new PngFeatures());

	}

	private GdalWriter gdalWriter = null;

	private String     outTif     = null;

	private String     outPng     = null;

	/**

	 * Carga los par?metros de este driver.

	 */

	public void loadParams(String ident) {

		WriteFileFormatFeatures wfff = (WriteFileFormatFeatures) pInfo.getFileFeature().get(ident);

		wfff.loadParams();

		driverParams = wfff.getParams();

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.coverage.store.RasterWriter#getProviderName()

	 */

	public String getProviderName() {

		return GdalProvider.NAME;

	}

	/**

	 * Constructor para la obtenci?n de par?metros del driver

	 * @param drvType Tipo de driver

	 */

	public PngWriter(String fileName) {

		ident = fileUtil.getExtensionFromFileName(fileName);

		driver = ((WriteFileFormatFeatures) pInfo.getFileFeature().get(ident)).getDriverName();

		gdalWriter = new GdalWriter(fileName);

		loadParams(ident);

	}

	/**

	 * Constructor para salvar datos servidos por el cliente

	 * @param dataWriter Objeto servidor de datos para el driver de escritura

	 * @param outSizeX N?mero de pixels en X de la imagen de salida

	 * @param outSizeY N?mero de pixels en Y de la imagen de salida

	 * @param outFilename Fichero de salida

	 * @param extentMaxX Posici?n en X m?xima del extent

	 * @param extentMinX Posici?n en X m?nima del extent

	 * @param extentMaxY Posici?n en Y m?xima del extent

	 * @param extentMinY Posici?n en Y m?nima del extent

	 * @param nBands N?mero de bandas

	 * @param drvType Tipo de driver

	 * @throws GdalException

	 * @throws IOException

	 */

	public PngWriter(DataServerWriter dataWriter,

							String outFileName,

							Integer nBands,

							AffineTransform at,

							Integer outSizeX,

							Integer outSizeY,

							Integer dataType,

							Params params,

							IProjection proj,

							Boolean geo)throws GdalException, IOException  {

		ident = fileUtil.getExtensionFromFileName(outFileName);

		driver = ((WriteFileFormatFeatures) pInfo.getFileFeature().get(ident)).getDriverName();

		outPng = outFileName;

		outTif = outFileName.substring(0, outFileName.lastIndexOf("."));

		outTif += ".tif";

		this.at = at;

		gdalWriter = new GdalWriter(dataWriter, outTif, nBands, at, outSizeX, outSizeY, dataType, params, proj, geo);

		if (params == null)

			loadParams(ident);

		else

			this.driverParams = params;

	}

	/**

	 * Asigna el tipo de driver con el que se salvar? la imagen

	 * @param drvType Tipo de driver

	 */

	public void setDriverType(String drvType) {

		gdalWriter.setDriverType(drvType);

	}

		/**

	 * Realiza la funci?n de compresi?n a partir de un GeoRasterFile.

	 * @throws IOException

	 */

	public void fileWrite() throws IOException, ProcessInterruptedException {

		gdalWriter.fileWrite();

	}

	/**

	 * Realiza una copia en el formato especificado.

	 * @throws IOException

	 */

	public static void createCopy(GdalDriver driverDst, String dst, String src,

			boolean bstrict, String[] params) throws IOException, GdalException {

		GdalWriter.createCopy(driverDst, dst, src, bstrict, params);

	}

	/**

	 * Realiza la escritura de datos con los datos que le pasa el cliente.

	 * @throws IOException

	 */

	public void dataWrite() throws IOException, ProcessInterruptedException {

		if(colorInterp != null)

			gdalWriter.setColorBandsInterpretation(colorInterp.getValues());

		gdalWriter.dataWrite();

		if (gdalWriter.isWrite()) {

			gdalWriter.writeClose();

			if (outTif != null) {

				GdalDriver driver = null;

				try {

					driver = GdalDataset.getDriverByName("PNG");

					GdalWriter.createCopy(driver, outPng, outTif, false, gdalWriter.gdalParamsFromRasterParams(driverParams));

				} catch (GdalException exc) {

					throw new IOException("No se ha podido obtener el driver.");

				}

				File file = new File(outTif);

				file.delete();

			}

		}

	}

	/**

	 * Cancela el salvado de datos.

	 */

	public void writeCancel() {

		gdalWriter.setWrite(false);

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.dataset.GeoRasterWriter#setParams(org.gvsig.raster.dataset.Params)

	 */

	public void setParams(Params params) {

		driverParams = params;

		if (gdalWriter != null)

			gdalWriter.setParams(params);

	}

	/**

	 * Cierra el compresor ecw.

	 * @throws GdalException

	 */

	public void writeClose() {

	// El close del tif se hizo en dataWrite

	}

	public void setWkt(String wkt) {}

}

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

import org.gdal.ogr.ogr;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.jgdal.GdalColorEntry;

import org.gvsig.jgdal.GdalColorTable;

import org.gvsig.jgdal.GdalDataset;

import org.gvsig.jgdal.GdalException;

import org.gvsig.jgdal.GdalRasterBand;

import org.gvsig.jgdal.GeoTransform;

import org.gvsig.jgdal.GeoTransform.GeoTransformException;

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.

 */

public class GdalDataSource extends GdalDataset 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;

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

	/**

	 * 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 GdalDataset.GDT_Byte;

			case Buffer.TYPE_USHORT: return GdalDataset.GDT_UInt16;

			case Buffer.TYPE_SHORT: return GdalDataset.GDT_Int16;

			case Buffer.TYPE_INT: return GdalDataset.GDT_Int32;

			case Buffer.TYPE_FLOAT: return GdalDataset.GDT_Float32;

			case Buffer.TYPE_DOUBLE: return GdalDataset.GDT_Float64;

			case Buffer.TYPE_UNDEFINED: return GdalDataset.GDT_Unknown;

			case Buffer.TYPE_IMAGE: return GdalDataset.GDT_Byte;

		}

		return GdalDataset.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 GdalDataSource(String fName) throws GdalException, IOException {

		super();

		init(fName);

	}

//	private static Dataset initializeGdal(String fName) throws GdalException {

//		gdal.AllRegister();

//		ogr.RegisterAll();

//		Dataset data = gdal.Open(fName, 1);

//		if (data == null)

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

//

//		return data;

//	}

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

		gdal.AllRegister();

		ogr.RegisterAll();

		fileName = fName;

		open(fName, GA_ReadOnly);

		open = true;

		if (getDataset() == null)

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

		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();

                        if( !trans.isValid() ) {

                            throw new GeoTransformException();

                        }

			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 (GeoTransformException 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

		    logger.warn("Can't retrieve transformation from file '"+fName+"' use default.");

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

                    externalTransformation = (AffineTransform) ownTransformation.clone();

                    overviewWidth = width;

                    overviewHeight = height;

                    this.georeferenced = false;

                } catch (Exception 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

		    logger.warn("Can't retrieve transformation from file '"+fName+"' use default.", exc);

			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());

	}