Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.lizardtech.io.DefaultLizardtechIOLibrary

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.lizardtech.io;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

/**

 * Parameters for the Gdal provider

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

 */

public class LizardTechDataParameters extends AbstractRasterFileDataParameters {

	public LizardTechDataParameters() {

		initialize();

	}

	protected void initialize() {

		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						registerDynClass());

	}

	public String getDataStoreName() {

		return LizardTechProvider.NAME;

	}

	public String getDescription() {

		return LizardTechProvider.DESCRIPTION;

	}

	public static DynStruct registerDynClass() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition("LizardTechDataParameters_Persistent");

		if( definition == null ) {

			definition = manager.addDefinition(

					LizardTechDataParameters.class,

					"LizardTechDataParameters_Persistent",

					"LizardTechDataParameters Persistent",

					null, 

					null

			);

			AbstractRasterDataParameters.registerDynClass(definition);

		}

		return definition;

	}

}

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

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALLibrary;

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 DefaultLizardtechIOLibrary extends AbstractLibrary {	

	@SuppressWarnings("deprecation")

	public DefaultLizardtechIOLibrary() {

		super(DefaultLizardtechIOLibrary.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 {

		AbstractNewRasterStoreParameters.registerDynClass();

		// Registro de los drivers de lectura

		LizardTechProvider.register();

		LizardTechDataParameters.registerDynClass();

	}

}

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

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.io.IOException;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

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

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

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

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

import es.gva.cit.jmrsid.LTIDataType;

import es.gva.cit.jmrsid.LTIGeoCoord;

import es.gva.cit.jmrsid.LTIImageStage;

import es.gva.cit.jmrsid.LTIMetadataDatabase;

import es.gva.cit.jmrsid.LTIMetadataRecord;

import es.gva.cit.jmrsid.LTISceneBuffer;

import es.gva.cit.jmrsid.LTIUtils;

import es.gva.cit.jmrsid.MrSIDException;

import es.gva.cit.jmrsid.MrSIDImageReader;

public class LizardTechNative extends MrSIDImageReader {

	static boolean                  WITH_OVERVIEWS          = true;

	public int                      width                   = 0;

	public int                      height                  = 0;

	public double 					originX                 = 0D;

	public double 					originY                 = 0D;

	public String 					version                 = "";

	public LTIMetadataDatabase 		metadata;

	private int 					alpha                   = 0;

	protected int 					rBandNr                 = 1;

	protected int 					gBandNr                 = 2;

	protected int 					bBandNr                 = 3;

	protected byte[] 				bandR;

	protected byte[] 				bandG;

	protected byte[] 				bandB;

	private int 					dataType                = LTIDataType.LTI_DATATYPE_UINT8;

	//View

	private double                  zoomoverview            = 0.0;

	private int 					eSampleType;

	private int 					noverviews;

	public int                      xini;

	public int                      yini;

	/**

	 * Ancho y alto de la overview

	 */

	public int                      anchoOver;

	public int                      altoOver;

	public int                      blocksize               = 1;

	/**

	 * N?mero de bandas de la imagen

	 */

	public int                      nbands;

	/**

	 * Posici?n de la esquina superior izquierda en coordenadas pixel

	 */

	private double                  currentViewY            = -1;

	private double                  currentViewX            = 0D;

	/**

	 * Ancho y alto de la im�gen (pixeles en pantalla)

	 */

	private int 					currentViewWidth        = -1;

	private int 					currentViewHeight       = -1;

	/**

	 * Ancho y alto de la imagen completa en pixeles

	 */

	@SuppressWarnings("unused")

	private int 					currentFullWidth        = -1;

	@SuppressWarnings("unused")

	private int 					currentFullHeight       = -1;

	private int 					overviewFullWidth       = -1;

	private int 					overviewFullHeight      = -1;

	/**

	 * Escala del viewport en X e Y

	 */

	private double                  viewportScaleX          = 0D;

	private double                  viewportScaleY          = 0D;

	/**

	 * ?ltimo extent de la ventana seleccionada por el usuario. Este extent corresponde al de la

	 * imagen, no al del viewport de la vista.

	 */

	private double[]				currentImageView        = new double[4];

	public int[]					stepArrayX              = null;

	public int[]					stepArrayY              = null;

	public boolean  				isSupersampling         = false;

	private String					fileName                = null;

	protected AffineTransform       ownTransformation       = null;

	protected AffineTransform       externalTransformation  = new AffineTransform();

	/**

	 *Array de transformaciones afines donde cada elemento es la transformaci�n correspondiente a una overview

	 */

	protected AffineTransform[]     overviewsTransformation = null;

	/**

	 * Constructor

	 * @param fName

	 * @throws MrSIDException

	 * @throws IOException

	 */

	public LizardTechNative(String fName) throws MrSIDException, IOException {

		super(fName);

		init(fName);

	}

	/**

	 * Inicializa las variables de instancia con los valores de la imagen

	 * @param fName

	 * @throws MrSIDException

	 * @throws IOException

	 */

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

		this.initialize();

		fileName = fName;

		width = this.getWidth();

		height = this.getHeight();

		eSampleType = this.getDataType();

		nbands = this.getNumBands();

		//eColorSpace = this.getColorSpace();

		noverviews = this.getNumLevels();

		overviewsTransformation = new AffineTransform[noverviews];

		//Creamos una matriz de transformaci�n por nivel de overview con el factor de escala de esta overview

		overviewsTransformation[0] = new AffineTransform();

		int[] dims = this.getDimsAtMag(LTIUtils.levelToMag(0));

		int dimLastX = dims[0];

		int dimLastY = dims[1];

		for (int i = 1; i < noverviews; i++) {

			dims = this.getDimsAtMag(LTIUtils.levelToMag(i));

			double scaleFactorX = (double)dims[0] / (double)dimLastX;

			double scaleFactorY = (double)dims[1] / (double)dimLastY;

			//System.out.println("Over:" + i + " zoom:" + LTIUtils.levelToMag(i) + " dims:" + dims[0] + "X" + dims[1]);

			overviewsTransformation[i] = new AffineTransform(scaleFactorX, 0, 0, scaleFactorY, 0, 0);

		}

		metadata = this.getMetadata();

		double ox = 0D;

		double oy = 0D;

		double resx = 0D;

		double resy = 0D;

		LTIGeoCoord geoc = this.getGeoCoord();

		ox = geoc.getX();

		oy = geoc.getY();

		resx = geoc.getXRes();

		resy = geoc.getYRes();

    	ownTransformation = new AffineTransform(resx, 0, 0, resy, ox, oy);

    	externalTransformation = (AffineTransform)ownTransformation.clone();

		currentFullWidth = width;

		currentFullHeight = height;

		blocksize = this.getStripHeight();

		if(nbands == 1) {

			rBandNr = gBandNr = bBandNr = 1;

		}

		if(nbands == 2) {

			rBandNr = gBandNr = 1;

			bBandNr = 2;

		}

	}

	/**

	 * Asigna el valor de Alpha

	 * @param a        alpha

	 */

	public void setAlpha(int a) {

		alpha = a;

	}

	/**

	 * Asigna el tipo de datos

	 * @param dt        tipo de datos

	 */

	public void setDataType(int dt) {

		dataType = dt;

	}

	/**

	 * 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 de la imagen y el viewport a partir del ancho, alto y

	 * coordenadas del mundo real

	 * @param dWorldTLX        Coordenada X superior izquierda

	 * @param dWorldTLY        Coordenada Y superior izquierda

	 * @param dWorldBRX        Coordenada X inferior derecha

	 * @param dWorldBRY        Coordenada Y inferior derecha

	 * @param nWidth        ancho

	 * @param nHeight        alto

	 */

	public void setView(double ulx, double uly, double lrx, double lry, 

			int nWidth, int nHeight) {

		currentImageView[0] = ulx;

		currentImageView[1] = uly;

		currentImageView[2] = lrx;

		currentImageView[3] = lry;

		//Ancho y alto de la im�gen en pixeles (pixeles de la overview)

		overviewFullWidth = currentFullWidth = width;

		overviewFullHeight = currentFullHeight = height;

		//Ventana de la imagen. (en tama�o completo)

		//tl->esq sup izda en pixeles

		//br->esq inf der en pixeles

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

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

		Point2D tl = new Point2D.Double(Math.min(a.getX(), b.getX()), Math.min(a.getY(), b.getY()));

		Point2D br = new Point2D.Double(Math.max(a.getX(), b.getX()), Math.max(a.getY(), b.getY()));

		//Ancho y alto de la im�gen (pixeles en pantalla)

		currentViewWidth = nWidth;

		currentViewHeight = nHeight;

		//Posici�n de la esquina superior izquierda en coordenadas pixel

		currentViewX = tl.getX();

		currentViewY = tl.getY();

		//Escala de la vista en X e Y

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

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

		try {

			// calcula el overview a usar

			int[] dims = null;

			double zoom = 1.0;

			zoomoverview = 1.0;

			if (WITH_OVERVIEWS && ((noverviews - 1) > 0)) {

				for (int i = (noverviews - 1); i > 0; i--) {

					zoom = LTIUtils.levelToMag(i);

					dims = this.getDimsAtMag(zoom);

					if (dims[0] > (this.getWidth() * viewportScaleX)) {

						zoomoverview = zoom;

						viewportScaleX /= zoomoverview;

						viewportScaleY /= zoomoverview;

						overviewFullWidth = currentFullWidth = dims[0];

						overviewFullHeight = currentFullHeight = dims[1];

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

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

						tl.setLocation(Math.min(tl.getX(), br.getX()), Math.min(tl.getY(), br.getY()));

						overviewsTransformation[i].transform(tl, tl);

						//Hemos asignado currentFull solo para calcular tl en relaci�n al tama�o de la overview

						currentFullWidth = width;

						currentFullHeight = height;

						currentViewX = tl.getX();

						currentViewY = tl.getY();

						break;

					}

				}

			}

			setDataType(eSampleType);

		} catch (MrSIDException e) {

			e.printStackTrace();

		}

	}

	/**

	 * Muestra alguna informaci�n para la depuraci�n

	 */

	void pintaInfo() {

		try {

			System.out.println("GeoTransform:");

			LTIGeoCoord geoc = this.getGeoCoord();

			System.out.println("  param[0]=" + geoc.getX());

			System.out.println("  param[0]=" + geoc.getY());

			System.out.println("  param[0]=" + geoc.getXRes());

			System.out.println("  param[0]=" + geoc.getYRes());

			System.out.println("  param[0]=" + geoc.getXRot());

			System.out.println("  param[0]=" + geoc.getYRot());

			System.out.println("Metadata:");

			LTIMetadataDatabase metadata = this.getMetadata();

			for (int i = 0; i < metadata.getIndexCount(); i++) {

				LTIMetadataRecord rec = null;

				rec = metadata.getDataByIndex(i);

				System.out.println(rec.getTagName());

				if (rec.isScalar()) {

					System.out.println(rec.getScalarData());

				} else if (rec.isVector()) {

					String[] s = rec.getVectorData();

					for (int j = 0; j < s.length; j++)

						System.out.println("V" + j + "->" + s[j]);

				} else if (rec.isArray()) {

					String[] s = rec.getArrayData();

					for (int j = 0; j < s.length; j++)

						System.out.println("A" + j + "->" + s[j]);

				} else {

					System.out.println("");

				}

			}

		} catch (MrSIDException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	public LTISceneBuffer readBuffer(int x, int y, int SceneWidth, int SceneHeight)throws MrSIDException{

		LTISceneBuffer buffer = ((LTIImageStage) this).readScene((double)x, (double)y, (double)SceneWidth, (double)SceneHeight, zoomoverview, (MrSIDImageReader)this, SceneWidth, SceneHeight, true);

		return buffer;

	}

	/**

	 * Lee la escena de la imagen correspondiente a la vista seleccionada con

	 * currentView a trav�s de la libreria de MrSid. Esta escena es cargada sobre

	 * un buffer y asignada al par�metro de salida.

	 * @param line        Escena leida

	 * @throws MrSIDException Lanzada si ocurre un error en la lectura de la escena

	 */

	public void readScene(int[] line, RasterTask task) throws MrSIDException, ProcessInterruptedException {

		//Posici�n de inicio de la escena en entero para la petici�n a la libreria

		int x = (int) Math.floor(currentViewX);

		int y = (int) Math.floor(currentViewY);

		//Ancho y alto de la escena en pixeles

		int SceneWidth = 0;

		int SceneHeight = 0;

		SceneWidth = (int) Math.ceil((((double) currentViewWidth) / viewportScaleX) + 1);

		SceneHeight = (int) Math.ceil((((double) currentViewHeight) / viewportScaleY) + 1);

		while((x + SceneWidth) > overviewFullWidth)

			SceneWidth --;

		while((y + SceneHeight) > overviewFullHeight)

			SceneHeight --;

		if (SceneWidth == 0) 

			SceneWidth = 1;

		if (SceneHeight == 0)

			SceneHeight = 1;

		LTISceneBuffer buffer = null;

		buffer = ((LTIImageStage) this).readScene((double)x, (double)y, (double)SceneWidth, (double)SceneHeight, zoomoverview, (MrSIDImageReader)this, SceneWidth, SceneHeight, true);

		/*boolean  sizeOk = false;

			while (!sizeOk) {

				sizeOk = true;

				try {

					buffer = readBuffer(x, y, SceneWidth, SceneHeight);

				} catch (MrSIDException ex) {

					SceneWidth-- ;

					try{

						buffer = readBuffer(x, y, SceneWidth, SceneHeight);

					} catch (MrSIDException ex1) {

						SceneWidth++;

						SceneHeight--;

						try{

							buffer = readBuffer(x, y, SceneWidth, SceneHeight);

						} catch (MrSIDException ex2) {

							SceneWidth-- ;

							try{

								buffer = readBuffer(x, y, SceneWidth, SceneHeight);

							} catch (MrSIDException ex3) {

								sizeOk = false;

							}

						}

					}

				}

			}*/

		if(task.getEvent() != null)

			task.manageEvent(task.getEvent());

		if ((dataType == LTIDataType.LTI_DATATYPE_UINT8) ||

				(dataType == LTIDataType.LTI_DATATYPE_SINT8) ||

				(dataType == LTIDataType.LTI_DATATYPE_SINT16) ||

				(dataType == LTIDataType.LTI_DATATYPE_SINT32) ||

				(dataType == LTIDataType.LTI_DATATYPE_UINT16) ||

				(dataType == LTIDataType.LTI_DATATYPE_UINT32)) {

			int kd;

			int k;

			double scaleX = 1 / viewportScaleX;

			double scaleY = 1 / viewportScaleY;

			int alpha = (this.alpha & 0xff) << 24;

			if (rBandNr == 1) {

				bandR = buffer.buf1;

			} else if (rBandNr == 2) {

				bandR = buffer.buf2;

			} else if (rBandNr == 3) {

				bandR = buffer.buf3;

			}

			if (gBandNr == 1) {

				bandG = buffer.buf1;

			} else if (gBandNr == 2) {

				bandG = buffer.buf2;

			} else if (gBandNr == 3) {

				bandG = buffer.buf3;

			}

			if (bBandNr == 1) {

				bandB = buffer.buf1;

			} else if (bBandNr == 2) {

				bandB = buffer.buf2;

			} else if (bBandNr == 3) {

				bandB = buffer.buf3;

			}

			//Desplazamiento para la X y la Y leidas. Estas tienen efecto cuando un pixel no empieza a visualizarse

			//justo en su esquina superior izquierda y tiene que ser cortado en la visualizaci�n.

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

			double offsetY = Math.abs(currentViewY - ((int)currentViewY));

			for (int y1 = 0; y1 < currentViewHeight; y1++) {

				for (int x1 = 0; x1 < currentViewWidth; x1++) {

					kd = (y1 * currentViewWidth) + x1;

					k = (((int) ((y1 * scaleY) + offsetY)) * SceneWidth) + (int) ((x1 * scaleX) + offsetX);

					try {

						line[kd] = alpha + ((0xff & bandR[k]) << 16) + ((0xff & bandG[k]) << 8) + (0xff & bandB[k]);

					} catch (java.lang.ArrayIndexOutOfBoundsException e) {

					}

				}

				if(task.getEvent() != null)

					task.manageEvent(task.getEvent());

			}

		}

		buffer = null;

	}

	/**

	 * Reads a window of data. The size of the input window may not coincide 

	 * with the size of the buffer. In that case would have to resize

	 * @param buf

	 * @param bandList

	 * @param x

	 *        Initial X position in input buffer

	 * @param y

	 *        Initial Y position in input buffer

	 * @throws MrSIDException

	 * @throws ProcessInterruptedException

	 */

	public void readWindow(Buffer buf, 

			BandList bandList, 

			int x, int y, int w, int h, 

			int bufWidth, int bufHeight) throws MrSIDException, ProcessInterruptedException {

		if(bufWidth > buf.getWidth())

			bufWidth = buf.getWidth();

		if(bufHeight > buf.getHeight())

			bufHeight = buf.getHeight();

		if(buf.isCached()) {

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

			int lastBlock = bufHeight - (nBlocks * buf.getBlockHeight());

			int lastBlockSrc = (lastBlock * h) / bufHeight;

			int sizeBlockSrc = (buf.getBlockHeight() * h) / bufHeight;

			if(lastBlock > 0)

				nBlocks ++;

			int initSrc = y;

			int init = 0;

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

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

					double[] stepSrc = new double[]{x, initSrc, w, lastBlockSrc};

					int[] stepDst = new int[]{0, init, bufWidth, init + lastBlock};

					readWindowInMemory(buf, bandList, stepSrc, stepDst, w, lastBlock);

				} else {

					double[] stepSrc = new double[]{x, initSrc, w, sizeBlockSrc};

					int[] stepDst = new int[]{0, init, bufWidth, init + buf.getBlockHeight()};

					readWindowInMemory(buf, bandList, stepSrc, stepDst, w, buf.getBlockHeight());

					init += buf.getBlockHeight();

					initSrc += sizeBlockSrc;

				}

			}

		} else {

			readWindowInMemory(buf, bandList, x, y, w, h);

		}

	}

	/**

	 * Reads a window of data. The width and height is indicated by the size of the buffer 

	 * @param buf

	 * @param bandList

	 * @param x

	 *        Initial X position in input buffer

	 * @param y

	 *        Initial Y position in input buffer

	 * @throws MrSIDException

	 * @throws ProcessInterruptedException

	 */

	public void readWindow(Buffer buf, BandList bandList, int x, int y) throws MrSIDException, ProcessInterruptedException {

		int w = (x + buf.getWidth()) > getWidth() ? getWidth() - x : buf.getWidth();

		int h = (y + buf.getHeight()) > getHeight() ? getHeight() - y : buf.getHeight();

		if(buf.isCached()) {

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

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

			if(lastBlock > 0)

				nBlocks ++;

			int initYSrc = y;

			int initYBuffer = 0;

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

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

					double[] stepSrc = new double[]{x, initYSrc, w, lastBlock};

					int[] stepDst = new int[]{0, initYBuffer, w, initYBuffer + lastBlock};

					readWindowInMemory(buf, bandList, stepSrc, stepDst, w, lastBlock);

				} else {

					double[] stepSrc = new double[]{x, initYSrc, w, buf.getBlockHeight()};

					int[] stepDst = new int[]{0, initYBuffer, w, initYBuffer + buf.getBlockHeight()};

					readWindowInMemory(buf, bandList, stepSrc, stepDst, w, buf.getBlockHeight());

					initYSrc += buf.getBlockHeight();

					initYBuffer += buf.getBlockHeight();

				}

			}

		} else {

			readWindowInMemory(buf, bandList, x, y, w, h);

		}

	}

	private void readWindowInMemory(Buffer buf, BandList bandList, double[] srcPxPos, int[] stepDst, int sizeSrcX, int sizeSrcY) throws MrSIDException, ProcessInterruptedException {

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

		isSupersampling = false;

		LTISceneBuffer buffer = ((LTIImageStage) this).readScene(

					srcPxPos[0], srcPxPos[1], srcPxPos[2], srcPxPos[3], 

					1.0, 

					(MrSIDImageReader)this, 

					sizeSrcX, sizeSrcY, 

					true);

		byte[] bandBuf = null;

		for(int iBand = 0; iBand < getNumBands(); iBand++) {

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

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

				continue;

			switch(iBand) {

			case 0:  bandBuf = buffer.buf1; break;

			case 1:  bandBuf = buffer.buf2; break;

			case 2:  bandBuf = buffer.buf3; break;

			}

			int lineSrc = 0;

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

				int colSrc = 0;

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

					int kd = (int)((lineSrc * srcPxPos[2]) + colSrc);

					buf.setElem(line, col, iBand, (byte)bandBuf[kd]);

					colSrc ++;

				}

				lineSrc ++;

				if(task.getEvent() != null)

					task.manageEvent(task.getEvent());

			}

		}

	}

	/**

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

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

	 */

	private void readWindowInMemory(Buffer buf, BandList bandList, int x, int y, int w, int h) throws MrSIDException, ProcessInterruptedException {

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

		isSupersampling = false;

		LTISceneBuffer buffer = ((LTIImageStage) this).readScene((double)x, (double)y, (double)w, (double)h, 1.0, (MrSIDImageReader)this, w, h, true);

		byte[] bandBuf = null;

		for(int iBand = 0; iBand < getNumBands(); iBand++) {

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

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

				continue;

			switch(iBand) {

			case 0:  bandBuf = buffer.buf1; break;

			case 1:  bandBuf = buffer.buf2; break;

			case 2:  bandBuf = buffer.buf3; break;

			}

			for (int line = 0; line < h; line++){

				for (int col = 0; col < w; col++){

					int kd = (line * w) + col;

					buf.setElem(line, col, iBand, (byte)bandBuf[kd]);

				}

				if(task.getEvent() != null)

					task.manageEvent(task.getEvent());

			}

		}

	}

	/**

	 * Lee una ventana de la imagen y devuelve un buffer de bytes

	 * @param ulX        Coordenada X de la esquina superior izquierda

	 * @param ulY        Coordenada Y de la esquina superior izquierda

	 * @param sizeX        Tama�o X de la imagen

	 * @param sizeY        Tama�o Y de la image

	 * @param band        N�mero de bandas

	 * @return        buffer con la ventana leida

	 * @throws MrSIDException

	 */

	public byte[] getWindow(int ulX, int ulY, int sizeX, int sizeY, int band) throws MrSIDException {

		LTISceneBuffer buffer = ((LTIImageStage) this).readScene((double)ulX, (double)ulY, (double)sizeX, (double)sizeY, 1.0, (MrSIDImageReader)this, sizeX, sizeY, true);

		if (band == 1) {

			return buffer.buf1;

		} else if (band == 2) {

			return buffer.buf2;

		} else if (band == 3) {

			return buffer.buf3;

		}

		return null;

	}

	/**

	 * Obtiene el valor de un pixel determinado por las coordenadas x e y que se pasan

	 * por par�metro

	 * @param x Coordenada X del pixel

	 * @param y Coordenada Y del pixel

	 * @return Array de Object donde cada posici�n representa una banda y el valor ser� Integer

	 * en caso de ser byte, shot o int, Float en caso de ser float y Double en caso de ser double.

	 */

	public Object[] getData(int x, int y) {

		try {

			Object[] data = new Object[nbands];

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

				byte[] b = getWindow(x, y, 1, 1, nbands);

				switch(dataType){

				case 0:	break;						

				case 1:	data[i] = new Integer(b[0]);

						break;

				case 2:								

				case 3:	data[i] = new Integer(b[0]);

						break;

				case 4:								

				case 5: data[i] = new Integer(b[0]);

						break;

				case 6:	data[i] = new Float(b[0]);

						break;

				case 7:	data[i] = new Double(b[0]);

						break;

				}

			}

			return data;

		} catch (MrSIDException e) {

			return null;

		}

	}

	/**

	 * Asigna una transformaci�n que es aplicada sobre la que ya tiene el propio fichero

	 * @param t

	 */

	public void setExternalTransform(AffineTransform t){

		externalTransformation = t;

	}

	/**

	 * Devuelve la transformaci�n del fichero de georreferenciaci�n

	 * @return AffineTransform

	 */

	public AffineTransform getOwnTransformation() {

		return ownTransformation;

	}

}

package org.gvsig.raster.lizardtech.io;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.net.URI;

import java.net.URISyntaxException;

import es.gva.cit.jmrsid.MrSIDException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

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

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.exception.OpenException;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.metadata.MetadataLocator;

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

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

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.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.tile.FileTileServer;

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

/**

 * Clase encargada del acceso a los datos y repintado de imagenes MrSID. Estos

 * son registrados con la extensi?n sid

 *

 * @version 15/05/2008

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

 */

public class LizardTechProvider extends AbstractRasterProvider {

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

	public static String                 NAME                     = "LizardTech Store";

	public static String                 DESCRIPTION              = "LizardTech Raster file";

	public static final String           METADATA_DEFINITION_NAME = "LizardTechStore";

	protected LizardTechNative           lztNative                     = null;

	private Extent                       viewRequest              = null;

	private DataStoreColorInterpretation colorInterpr             = null;

	protected DataStoreTransparency      fileTransparency         = null;

	private boolean                      open                     = false;

	protected static String[]            formatList               = null;

	public static void register() {

		RasterLocator.getManager().getProviderServices().registerFileProvidersTiled(LizardTechProvider.class);

		registerFormats();

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

			dataman.registerStoreProvider(NAME,

					LizardTechProvider.class, LizardTechDataParameters.class);

		}

		if(DALFileLocator.getFilesystemServerExplorerManager() != null)

			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

					NAME, DESCRIPTION,

					LizardTechFilesystemServerExplorer.class);

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	private static void registerFormats() {

		formatList      = new String[] {"sid"};

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

			RasterLocator.getManager().getProviderServices().addFormat(formatList[i], LizardTechProvider.class);

	}

	public String[] getFormatList() {

		return formatList;

	}

	/**

	 * Returns true if the extension is supported and false if doesn't

	 * @param ext

	 * @return

	 */

	public boolean isExtensionSupported(String ext) {

		if(ext.indexOf(".") != -1)

			ext = ext.substring(ext.lastIndexOf(".") + 1, ext.length());

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

			if(formatList[i].compareTo(ext) == 0)

				return true;

		}

		return false;

	}

	/**

	 * Mandatory constructor to instantiate an empty provider

	 */

	public LizardTechProvider() {

	}

	/**

	 * Constructor. Abre el dataset.

	 * @param proj Proyecci?n

	 * @param fName Nombre del fichero ecw

	 * @throws NotSupportedExtensionException

	 * @throws OpenException

     * @deprecated use {@link #LizardTechProvider(URI)}, this constructor will be removed in gvSIG 2.5

	 */

	public LizardTechProvider(String params) throws NotSupportedExtensionException, OpenException {

		super(params);

        logger.info("Deprecated use of LizardTechProvider constructor");

		if(params instanceof String) {

			LizardTechDataParameters p = new LizardTechDataParameters();

            URI uriObj;

            try {

                uriObj = new URI((String)params);

            } catch (URISyntaxException e) {

                throw new OpenException("Can't create uri from "+(String)params, e);

            }

            p.setURI(uriObj);

			super.init(p, null, ToolsLocator.getDynObjectManager()

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

									DataStore.METADATA_DEFINITION_NAME)));

			init(p, null);

		}

	}

    /**

     * Constructor. Abre el dataset.

     * @param proj Proyecci?n

     * @param fName Nombre del fichero ecw

     * @throws NotSupportedExtensionException

     */

    public LizardTechProvider(URI uri) throws NotSupportedExtensionException {

        super(uri);

        LizardTechDataParameters p = new LizardTechDataParameters();

        p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

                MetadataLocator.getMetadataManager().getDefinition(DataStore.METADATA_DEFINITION_NAME)));

        init(p, null);

    }

	public LizardTechProvider(LizardTechDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Contructor. Abre el fichero mrsid

	 * @param proj Proyecci?n

	 * @param fName Nombre del fichero mrsid

	 */

	public void init(AbstractRasterDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

		setParam(storeServices, params);

		try {

			lztNative = new LizardTechNative(new File(params.getURI()).getAbsolutePath());

			load();

			bandCount = lztNative.nbands;

			int[] dt = new int[bandCount];

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

				dt[i] = Buffer.TYPE_BYTE;

			setDataType(dt);

			super.init();

			try {

				loadFromRmf(getRmfBlocksManager());

			} catch (ParsingException e) {

				// No lee desde rmf

			}

		} catch (Exception e) {

			System.out.println("Error en constructor de MrSID");

			e.printStackTrace();

			lztNative = null;

		}

		open = true;

	}

	public RasterProvider load() {

		ownTransformation = lztNative.getOwnTransformation();

		externalTransformation = (AffineTransform) ownTransformation.clone();

		return this;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

		if (lztNative != null) {

			lztNative.close();

			lztNative = null;

		}

		open = false;

	}

	public void setView(Extent e) {

		viewRequest = new ExtentImpl(e);

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		return lztNative.width;

	}

	public double getHeight() {

		return lztNative.height;

	}

	/**

	 * Asigna al objeto Image los valores con los dato de la imagen contenidos en

	 * el vector de enteros.

	 * @param image imagen con los datos actuales

	 * @param startX inicio de la posici?n en X dentro de la imagen

	 * @param startY inicio de la posici?n en X dentro de la imagen

	 * @param w Ancho de la imagen

	 * @param h Alto de la imagen

	 * @param rgbArray vector que contiene la banda que se va a sustituir

	 * @param offset desplazamiento

	 * @param scansize tama?o de imagen recorrida por cada p

	 */

	protected void setRGBLine(BufferedImage image, int startX, int startY, int w, int h,

														int[] rgbArray, int offset, int scansize) {

		image.setRGB(startX, startY, w, h, rgbArray, offset, scansize);

	}

	public Object getData(int x, int y, int band) throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		if (lztNative != null) {

			if (x < 0 || y < 0 || x >= lztNative.width || y >= lztNative.height)

				throw new InvalidSetViewException("Request out of grid");

			Object[] data = lztNative.getData(x, y);

			return data[band];

		}

		throw new FileNotOpenException("MrSIDNative not exist");

	}

	public int getBlockSize() {

		return lztNative.blocksize;

	}

	/**

	 * Informa de si el driver ha supersampleado en el ?ltimo dibujado. Es el

	 * driver el que colocar? el valor de esta variable cada vez que dibuja.

	 * @return true si se ha supersampleado y false si no se ha hecho.

	 */

	public boolean isSupersampling() {

		return lztNative.isSupersampling;

	}

	@Override

	public void loadBuffer(SpiRasterQuery query)

			throws ProcessInterruptedException, RasterDriverException {

		setView(query.getAdjustedRequestBoundingBox());

		int width = query.getAdjustedBufWidth();

		int height = query.getAdjustedBufHeight();

		lztNative.setView(viewRequest.getULX(), viewRequest.getULY(), viewRequest.getLRX(), viewRequest.getLRY(), width, height);

		int[] pRGBArray = new int[width * height];

		try {

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

			lztNative.readScene(pRGBArray, task);

			loadBuffer(height,

					width,

					query.getBandList(),

					query.getBufferForProviders(),

					pRGBArray);

		} catch (MrSIDException e) {

			throw new RasterDriverException("Error reading data");

		}

	}

//	private void loadCachedBuffer(	Buffer buf,

//									Extent inputWindow,

//									RasterTask task,

//									int[] pRGBArray,

//									BandList bandList) throws ProcessInterruptedException, MrSIDException {

//		if(buf.isCached()) {

//			Point2D blockHeightWC = rasterToWorld(new Point2D.Double(buf.getBlockHeight(), buf.getBlockHeight()));

//			int nBlocks = (int)(inputWindow.height() / blockHeightWC.getX());

//			double lastblockWC = inputWindow.height() - (nBlocks * blockHeightWC.getX());

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

//			if(lastblockWC > 0)

//				nBlocks ++;

//			double init = inputWindow.getULY();

//			Extent ext = null;

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

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

//					ext = RasterLocator.getManager().getDataStructFactory().createExtent(

//							inputWindow.getULX(),

//							init,

//							inputWindow.getLRX(),

//							lastblockWC);

//					file.setView(ext.getULX(), ext.getULY(), ext.getLRX(), ext.getLRY(), buf.getWidth(), buf.getBlockHeight());

//					file.readScene(pRGBArray, task);

//					loadPartialBuffer(new int[]{0, i * buf.getBlockHeight(), buf.getWidth(), buf.getHeight() },

//									bandList,

//									buf,

//									pRGBArray,

//									buf.getWidth());

//				} else {

//					ext = RasterLocator.getManager().getDataStructFactory().createExtent(

//							inputWindow.getULX(),

//							init,

//							inputWindow.getLRX(),

//							init - blockHeightWC.getX());

//					file.setView(ext.getULX(), ext.getULY(), ext.getLRX(), ext.getLRY(), buf.getWidth(), lastBlock);

//					file.readScene(pRGBArray, task);

//					loadPartialBuffer(new int[]{0, i * buf.getBlockHeight(), buf.getWidth(), i * buf.getBlockHeight() + buf.getBlockHeight() },

//							bandList,

//							buf,

//							pRGBArray,

//							buf.getWidth());

//					init += buf.getBlockHeight();

//				}

//			}

//		} else {

//			file.setView(inputWindow.getULX(), inputWindow.getULY(), inputWindow.getLRX(), inputWindow.getLRY(), buf.getWidth(), buf.getHeight());

//			file.readScene(pRGBArray, task);

//			loadBuffer(buf.getWidth(), buf.getHeight(), bandList, buf, pRGBArray);

//		}

//	}

//

//	private void loadPartialBuffer(int[] stepBuffer,

//			BandList bandList,

//			Buffer rasterBuf,

//			int[] pRGBArray,

//			int bufWidth) throws ProcessInterruptedException {

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

//		int[] drawableBandsR = bandList.getBufferBandToDraw(getURIOfFirstProvider(), 0);

//		int[] drawableBandsG = bandList.getBufferBandToDraw(getURIOfFirstProvider(), 1);

//		int[] drawableBandsB = bandList.getBufferBandToDraw(getURIOfFirstProvider(), 2);

//		int element = 0;

//		int rowSrc = 0;

//

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

//			int colSrc = 0;

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

//				element = pRGBArray[(rowSrc * bufWidth) + colSrc];

//				if(drawableBandsR != null) {

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

//						if(drawableBandsR[i] >= 0 && drawableBandsR[i] < rasterBuf.getBandCount())

//							rasterBuf.setElem(row, col, drawableBandsR[i], (byte) ((element & 0x00ff0000) >> 16));

//					}

//				}

//				if(drawableBandsG != null) {

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

//						if(drawableBandsG[i] >= 0 && drawableBandsG[i] < rasterBuf.getBandCount())

//							rasterBuf.setElem(row, col, drawableBandsG[i], (byte) ((element & 0x0000ff00) >> 8));

//					}

//				}

//				if(drawableBandsB != null) {

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

//						if(drawableBandsB[i] >= 0 && drawableBandsB[i] < rasterBuf.getBandCount())

//							rasterBuf.setElem(row, col, drawableBandsB[i], (byte) (element & 0x000000ff));

//					}

//				}

//				colSrc ++;

//			}

//			if (task.getEvent() != null)

//				task.manageEvent(task.getEvent());

//			rowSrc ++;

//		}

//	}

	private void loadBuffer(int h, int w, BandList bandList, Buffer rasterBuf, int[] pRGBArray) throws ProcessInterruptedException {

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

		String absolutePath = new File(getURIOfFirstProvider()).getAbsolutePath();

        int[] drawableBandsR = bandList.getBufferBandToDraw(absolutePath, 0);

		int[] drawableBandsG = bandList.getBufferBandToDraw(absolutePath, 1);

		int[] drawableBandsB = bandList.getBufferBandToDraw(absolutePath, 2);

		int element = 0;

		for (int row = 0; row < h; row++) {

			for (int col = 0; col < w; col++) {

				element = pRGBArray[(row * w) + col];

				if(drawableBandsR != null) {

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

						if(drawableBandsR[i] >= 0 && drawableBandsR[i] < rasterBuf.getBandCount())

							rasterBuf.setElem(row, col, drawableBandsR[i], (byte) ((element & 0x00ff0000) >> 16));

					}

				}

				if(drawableBandsG != null) {

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

						if(drawableBandsG[i] >= 0 && drawableBandsG[i] < rasterBuf.getBandCount())

							rasterBuf.setElem(row, col, drawableBandsG[i], (byte) ((element & 0x0000ff00) >> 8));

					}

				}

				if(drawableBandsB != null) {

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

						if(drawableBandsB[i] >= 0 && drawableBandsB[i] < rasterBuf.getBandCount())

							rasterBuf.setElem(row, col, drawableBandsB[i], (byte) (element & 0x000000ff));

					}

				}

			}

			if (task.getEvent() != null)

				task.manageEvent(task.getEvent());

		}

	}

	public Object readBlock(int pos, int blockHeight, double scale) throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

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

		if (pos < 0)

			throw new InvalidSetViewException("Request out of grid");

		if ((pos + blockHeight) > lztNative.height)

			blockHeight = Math.abs(lztNative.height - pos);

		Point2D begin = rasterToWorld(new Point2D.Double(0, pos));

		Point2D end = rasterToWorld(new Point2D.Double(lztNative.width, pos + blockHeight));

		int w = lztNative.width;

		lztNative.setView(begin.getX(), begin.getY(), end.getX(), end.getY(), w, blockHeight);

		int[] pRGBArray = new int[lztNative.width * blockHeight];

		try {

			lztNative.readScene(pRGBArray, task);

			byte[][][] buf = new byte[3][blockHeight][w];

			for (int row = 0; row < blockHeight; row++) {

				for (int col = 0; col < w; col++) {

					buf[0][row][col] = (byte) ((pRGBArray[(row * w) + col] & 0x00ff0000) >> 16);

					buf[1][row][col] = (byte) ((pRGBArray[(row * w) + col] & 0x0000ff00) >> 8);

					buf[2][row][col] = (byte) (pRGBArray[(row * w) + col] & 0x000000ff);

				}

				if (task.getEvent() != null)

					task.manageEvent(task.getEvent());

			}

			return buf;

		} catch (MrSIDException e) {

			throw new RasterDriverException("Error reading data");

		}

	}

	/**

	 * Read a line from the file

	 * @param line

	 * @param band

	 * @return

	 * @throws InvalidSetViewException

	 * @throws FileNotOpenException

	 * @throws RasterDriverException

	 * @Deprecated This operation is deprecated because is not useful and in the future

	 * it will not be maintained. The abstract operation has dissapear

	 */

	public Object readCompleteLine(int line, int band)

					throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

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

		if (line > this.getHeight() || band > this.getBandCount())

			throw new InvalidSetViewException("Request out of grid");

		try {

			Extent extent = getExtent();

			Point2D pt = rasterToWorld(new Point2D.Double(extent.minX(), line));

			lztNative.setView(extent.minX(), pt.getY(), extent.maxX(), pt.getY(), (int)getWidth(), 1);

			int[] pRGBArray = new int[(int)getWidth()];

			lztNative.readScene(pRGBArray, task);

			return pRGBArray;

		} catch (MrSIDException e) {

			throw new RasterDriverException("Error reading data from MrSID library");

		} catch (ProcessInterruptedException e) {

			// El proceso que debe ser interrumpido es el que llama a readLine.

		}

		return null;

	}

	public DataStoreTransparency getTransparency() {

		if (fileTransparency == null)

			fileTransparency = new DataStoreTransparency(getColorInterpretation());

		return fileTransparency;

	}

	public DataStoreColorInterpretation getColorInterpretation() {

		if(colorInterpr == null) {

			colorInterpr = new DataStoreColorInterpretation();

			colorInterpr.initColorInterpretation(getBandCount());

			if(getBandCount() == 1)

				colorInterpr = DataStoreColorInterpretation.createGrayInterpretation();

			if(getBandCount() == 3) {

				colorInterpr =  DataStoreColorInterpretation.createRGBInterpretation();

			}

			if(getBandCount() >= 4) {

				colorInterpr = DataStoreColorInterpretation.createRGBAInterpretation();

			}

		}

		return colorInterpr;

	}

	public String getWktProjection() {

		// System.err.println("======>" + file);

		return null;

	}

	public void setAffineTransform(AffineTransform t) {

		super.setAffineTransform(t);

		lztNative.setExternalTransform(t);

	}

	public int getOverviewCount(int band) throws BandAccessException, RasterDriverException {

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		try {

			return lztNative.getNumLevels();

		} catch (MrSIDException e) {

			throw new RasterDriverException("");

		}

	}

	public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException {

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

	public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException {

		if (band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

	public boolean isOverviewsSupported() {

		// No podemos escribir por lo que no podemos informar de que soporta overviews aunque el formato si lo haga.

		return false;

	}

	public String getProviderName() {

		return NAME;

	}

	public void setStatus(RasterProvider provider) {

		if(provider instanceof LizardTechProvider) {

			//Not implemented yet

		}

	}

	public TileServer getTileServer() {

		if(tileServer == null) {

			DefaultRasterStore store = new DefaultRasterStore();

			store.setProvider(this);

			tileServer = new FileTileServer(store);

		}

		return tileServer;

	}

    public void addFile(File file) throws InvalidSourceException {

        // Do nothing

    }

    public void removeFile(File file) {

        // Do nothing

    }

}