Application: gvSIG desktop » gvSIG raster

import org.gdal.gdal.Dataset;

import org.gdal.gdal.gdal;

import org.gdal.ogr.ogr;

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.tools.task.TaskStatus;

/**

 * Soporte 'nativo' para ficheros desde GDAL.

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

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

 */

	private int[]                        dataType                = null;

	DataStoreMetadata                    metadata                = null;

	protected boolean                    georeferenced           = true;

	/**

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

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

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

	 */

	public int[]                              stepArrayX             = null;

	public int[]                              stepArrayY             = null;

	protected DataStoreColorInterpretation    colorInterpr           = null;

	protected AffineTransform                 ownTransformation      = null;

	protected AffineTransform                 externalTransformation = new AffineTransform();

	public static int getGdalTypeFromRasterBufType(int rasterBufType) {

		switch (rasterBufType) {

			case Buffer.TYPE_BYTE: return Gdal.GDT_Byte;

		}

		return Gdal.GDT_Unknown;

	}

	/**

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

	 * @param gdalType Tipo de dato de gdal

		}

		return Buffer.TYPE_UNDEFINED;

	}

	/**

	 * Overview usada en el ?ltimo setView

	 */

	int currentOverview = -1;

	public GdalNative(String fName) throws GdalException, IOException {

		super();

		init(fName);

	}

	private static long 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 GdalDataset.getCPtr(data);

	}

//		isInitialized = true;

//		init(fName);

//	}

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

		gdal.AllRegister();

		ogr.RegisterAll();

					isCorrect = true;

			if (!isCorrect)

				throw new GdalException("");

			double psX = trans.adfgeotransform[1];

			double psY = trans.adfgeotransform[5];

			double rotX = trans.adfgeotransform[4];

			double rotY = trans.adfgeotransform[2];

			double offX = trans.adfgeotransform[0];

			double offY = trans.adfgeotransform[3];

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

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

			externalTransformation = (AffineTransform) ownTransformation.clone();

		}

//		}

	}

	/**

	 * 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

		}

		return false;

	}

	/**

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

	 * en una banda concreta.

	 * Asigna el tipo de dato

	 * @param dt entero que representa el tipo de dato

	 */

	}

	/**

	 * Obtiene el tipo de dato

	 * @return entero que representa el tipo de dato

	 */

	}

	/**

	 * Gets the color interpretation

	 * @return

	 */

	}

	/**

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

	 */

	public Point2D worldToRasterWithoutRot(Point2D pt) {

		Point2D p = new Point2D.Double();

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

		try {

			at.inverseTransform(pt, p);

		}

		return p;

	}

	/**

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

	 * del punto real.

		}

		return p;

	}

	/**

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

	 * @param pt Punto en coordenadas reales

	 * @return Punto en coordenadas pixel.

	 */

		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

			}

		}

	}

	public void setView(double dWorldTLX, double dWorldTLY,

						double dWorldBRX, double dWorldBRY,

						int nWidth, int nHeight) throws GdalException {

		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.

			}

		}

	}

	int lastY = -1;

	/**

	 * Lee una l�nea de bytes

	 * @param line Buffer donde se cargan los datos

			}

		}

	}

	/**

	 * Lee una l�nea de shorts

	 * @param line Buffer donde se cargan los datos

			}

		}

	}

	/**

	 * Lee una l�nea de doubles

	 * @param line Buffer donde se cargan los datos

	/**

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

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

		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

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

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

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

		GdalRasterBand[] gdalBand = new GdalRasterBand[bBandNr];

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

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

						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 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];

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

						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

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

			y--;

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

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

		return;

	}

	private List<ColorItem> gdalColorTable2ColorItems(GdalColorTable table) {

		try {

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

		}

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

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

			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;

				x  = 0;

			if(y < 0)

				y  = 0;

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

			return;

		}

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

		selectGdalBands(getRasterCount());

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

		adjustedWindow = getAdjustedWindowInOverviewCoordinates(adjustedWindow);

				0, 0, stpBuffer, status);

	}

	/**

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

	 * in the overview scale

		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.

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

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

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

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

		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

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

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

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

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

			return;

		}

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

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

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

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

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

	}

	 */

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

		gdalBands = new GdalRasterBand[getRasterCount()];

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

			isSupersampling = false;

		if(gdalBands.length == 0)

			return;

		// Selecciona las bandas

		gdalBands[0] = getRasterBand(1);

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

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

		assignDataTypeFromGdalRasterBands(gdalBands);

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

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

	}

	/**

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

	 * @param gdalBands

		}

		setDataType(dt);

	}

	/**

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

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

	 * </UL>

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

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

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

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

	 * parte de ellos.

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

	 * <UL>

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

	 * </UL>

	 * @throws GdalException

	 */

			int[] stepBuffer,

			TaskStatus status) throws GdalException, ProcessInterruptedException {

		if(buf.isCached()) {

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

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

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

							bufWidth, lastblock, 0, 0, newStepBuffer);

				} else {

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

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

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

					initYSrc += stepYSrc;

					initYBuffer += buf.getBlockHeight();

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

		}

	}

	/**

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

	 * @param buf Buffer donde se almacenan los datos

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

	 * @param inputWindow

	 * </UL>

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

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

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

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

	 * parte de ellos.

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

	 * <UL>

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

	 * </UL>

	 * @throws GdalException

	 */

			int[] stepBuffer) throws GdalException, ProcessInterruptedException {

		GdalBuffer gdalBuf = null;

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

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

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

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

			int pos = init;

													dataType[iBand]);

			int lineInputWindow = 0;

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

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

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

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

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

						pos ++;

					}

			}

		}

	}

	/**

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

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

		GdalBuffer gdalBuf = null;

		int rasterBufLine;

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

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

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

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

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

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

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

			}

		}

	}

	/**

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

	 * por par�metro

			return null;

		}

	}

	public int getBlockSize(){

		return this.getBlockSize();

	}

	public AffineTransform getOwnTransformation() {

		return ownTransformation;

	}

	/**

	 * Calcula el extent en coordenadas del mundo real sin rotaci�n. Solo coordenadas y tama�o de pixel

	 * @return Extent

	 */

	public Extent getExtentWithoutRot() {

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

		Point2D p1 = new Point2D.Double(0, 0);

		Point2D p2 = new Point2D.Double(width, height);

		at.transform(p2, p2);

		return new ExtentImpl(p1, p2);

	}

	/**

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

	 * @param t

	public String getGdalShortName() {

		return shortName;

	}

	public void dispose() {

		open = false;

		try {

		} catch (Throwable e) {

		}

	}

	protected void finalize() {

		fileTransparency       = null;

		palette                = null;

		version                = null;

		dataType               = null;

		metadata                = null;

		if(gdalBands != null) {

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

				gdalBands[i] = null;

		}

		this.finalize();

	}

}