Application: gvSIG desktop » gvSIG raster

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

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import org.cresques.cts.ICoordTrans;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.TaskStatus;

/**

 * Driver para datos cargados en un objeto IBuffer

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

 *

 */

public class MemoryRasterProvider extends AbstractRasterProvider {

	public static String        NAME                     = "Gdal Store";

	public static String        DESCRIPTION              = "Gdal Raster file";

	public static final String  METADATA_DEFINITION_NAME = "GdalStore";

	private Extent              v                        = null;

	protected Buffer            buffer                   = null;

	private Extent 		        extent                   = null;

	private boolean             open                     = false;

	public static void register() {

	}

	public void registerTileProviderFormats(Class<RasterProvider> c) {

	}

	/**

	 * Mandatory constructor to instantiate an empty provider

	 */

	public MemoryRasterProvider() {}

	/**

	 * Constructor. Asigna el buffer de datos y la extensi?n

	 * @param proj Proyecci?n

	 * @param buf Buffer

	 * @throws NotSupportedExtensionException

	 */

	public MemoryRasterProvider(AbstractRasterDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								METADATA_DEFINITION_NAME)));

		setParam(storeServices, params);

		if(!(params instanceof MemoryDataParameters))

			throw new NotSupportedExtensionException("Buffer not supported");

		extent = ((MemoryDataParameters)params).getExtent();

		this.buffer = ((MemoryDataParameters)params).getBuffer();

		if(extent != null) {

			double psX = (extent.maxX() - extent.minX()) / buffer.getWidth();

			double psY = (extent.minY() - extent.maxY()) / buffer.getHeight();

			ownTransformation = new AffineTransform(psX, 0, 0, psY, extent.minX(), extent.maxY());

		} else

			ownTransformation = new AffineTransform(1, 0, 0, -1, 0, buffer.getHeight());

		if(buffer == null)

			throw new NotSupportedExtensionException("Buffer invalid");

		load();

		bandCount = buffer.getBandCount();

		//Obtenemos el tipo de dato de gdal y lo convertimos el de RasterBuf

		int[] dt = new int[buffer.getBandCount()];

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

			dt[i] = buffer.getDataType();

		setDataType(dt);

		open = true;

	}

	public RasterProvider load() {

		return this;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

		buffer = null;

		open = false;

	}

	/**

	 * Asigna el extent de la vista actual.

	 */

	public void setView(Extent e) {

		v = e;

	}

	/**

	 * Obtiene extent de la vista actual

	 */

	public Extent getView() {

		return v;

	}

	/**

	 * Obtiene la anchura del fichero

	 */

	public double getWidth() {

		return buffer.getWidth();

	}

	/**

	 * Obtiene la altura del fichero

	 */

	public double getHeight() {

		return buffer.getHeight();

	}

	public void reProject(ICoordTrans rp) {

	}

	/**

	 * Obtiene la orientaci?n de la imagen a partir del signo del tama?o de pixel para poder

	 * asignarlo en el setView. Esto es util para poder conocer como debe leerse la image,

	 * de abajo a arriba, de arriba a abajo, de izquierda a derecha o de derecha a izquierda.

	 * La posici?n habitual es la que el pixel size en X es positivo y en Y negativo leyendose

	 * en este caso las X de menor a mayor y las Y de mayor a menor. Los casos posibles son:

	 * <UL>

	 * <LI><B>X > 0; Y < 0;</B> {true, false}</LI>

	 * <LI><B>X > 0; Y > 0;</B> {true, true}</LI>

	 * <LI><B>X < 0; Y > 0;</B> {false, true}</LI>

	 * <LI><B>X < 0; Y < 0;</B> {false, false}</LI>

	 * </UL>

	 *

	 * @return

	 */

	/*private boolean[] getOrientation(){

		boolean[] orientation = {true, false};

		return orientation;

	}*/

	public Object getData(int x, int y, int band) {

		if(buffer.getDataType() == Buffer.TYPE_BYTE){

			return new Integer(buffer.getElemByte(y, x, band));

		}else if(buffer.getDataType() == Buffer.TYPE_SHORT){

			return new Integer(buffer.getElemShort(y, x, band));

		}else if(buffer.getDataType() == Buffer.TYPE_INT){

			return new Integer(buffer.getElemInt(y, x, band));

		}else if(buffer.getDataType() == Buffer.TYPE_FLOAT){

			return new Float(buffer.getElemFloat(y, x, band));

		}else if(buffer.getDataType() == Buffer.TYPE_DOUBLE){

			return new Double(buffer.getElemDouble(y, x, band));

		}

		return null;

	}

	/**

	 * Devuelve el tama?o de bloque

	 * @return Tama?o de bloque

	 */

	public int getBlockSize(){

		return 0;

	}

	/**

	 * Obtiene el flag que dice si la imagen est? o no georreferenciada

	 * @return true si est? georreferenciada y false si no lo est?.

	 */

	public boolean isGeoreferenced() {

		return (this.extent != null);

	}

	/**

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

	}

	/**

	 * @return Returns the dataType.

	 */

	public int[] getDataType() {

		int[] dt = new int[buffer.getBandCount()];

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

			dt[i] = buffer.getDataType();

		return dt;

	}

	/**

	 * Ajusta los puntos pasados por par?metro a los l?mites del buffer. Es decir si alguno excede

	 * los l?mites por arriba o por abajo los ajusta.

	 * @param begin Punto inicial

	 * @param end Punto final

	 */

	private void adjustPointsToBufferLimits(Point2D begin, Point2D end) {

		if(begin.getX() < 0)

			begin.setLocation(0, begin.getY());

		if(begin.getY() > buffer.getHeight())

			begin.setLocation(begin.getX(), buffer.getHeight());

		if(end.getY() < 0)

			end.setLocation(begin.getX(), 0);

		if(end.getX() > buffer.getWidth())

			begin.setLocation(buffer.getWidth(), begin.getY());

	}

	public void loadBuffer(SpiRasterQuery q)

			throws ProcessInterruptedException, RasterDriverException {

		getWindow(q.getAdjustedRequestBoundingBox(), q.getBandList(), q.getBufferForProviders(), q.getTaskStatus());

	}

	public Buffer getWindow(Extent ex, BandList bandList, Buffer rasterBuf, TaskStatus status) {

		Point2D begin = worldToRaster(new Point2D.Double(ex.getULX(), ex.getULY()));

		Point2D end = worldToRaster(new Point2D.Double(ex.getLRX(), ex.getLRY()));

		setView(ex);

		adjustPointsToBufferLimits(begin, end);

		switch(buffer.getDataType()){

		case Buffer.TYPE_BYTE: writeByteBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_SHORT: writeShortBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_INT: writeIntBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_FLOAT: writeFloatBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_DOUBLE: writeDoubleBuffer(rasterBuf, 1, 1, begin, bandList); break;

		}

		return rasterBuf;

	}

	public Buffer getWindow(double x, double y, double w, double h,

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) {

		Point2D begin = worldToRaster(new Point2D.Double(x, y));

		Point2D end = worldToRaster(new Point2D.Double(x + w, y - h));

		setView(new ExtentImpl(x, y, x + w, y - h));

		adjustPointsToBufferLimits(begin, end);

		switch(buffer.getDataType()){

		case Buffer.TYPE_BYTE: writeByteBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_SHORT: writeShortBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_INT: writeIntBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_FLOAT: writeFloatBuffer(rasterBuf, 1, 1, begin, bandList); break;

		case Buffer.TYPE_DOUBLE: writeDoubleBuffer(rasterBuf, 1, 1, begin, bandList); break;

		}

		return rasterBuf;

	}

	public Buffer getWindow(Extent extent, int bufWidth, int bufHeight,

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) {

		Point2D begin = worldToRaster(new Point2D.Double(extent.getMin().getX(), extent.getMax().getY()));

		Point2D end = worldToRaster(new Point2D.Double(extent.getMax().getX(), extent.getMin().getY()));

		setView(extent);

		adjustPointsToBufferLimits(begin, end);

		//Ancho y alto en pixels (double) del area seleccionada.

		double w = Math.abs(end.getX() - begin.getX());

		double h = Math.abs(end.getY() - begin.getY());

		//Relaci?n entre el n?mero de pixels del buffer origen (area seleccionada) y el destino

		double stepX = w / ((double)bufWidth);

		double stepY = h / ((double)bufHeight);

		//Escritura separada en 5 llamadas para mejorar el rendimiento

		switch(buffer.getDataType()){

		case Buffer.TYPE_BYTE: writeByteBuffer(rasterBuf, stepX, stepY, begin, bandList); break;

		case Buffer.TYPE_SHORT: writeShortBuffer(rasterBuf, stepX, stepY, begin, bandList); break;

		case Buffer.TYPE_INT: writeIntBuffer(rasterBuf, stepX, stepY, begin, bandList); break;

		case Buffer.TYPE_FLOAT: writeFloatBuffer(rasterBuf, stepX, stepY, begin, bandList); break;

		case Buffer.TYPE_DOUBLE: writeDoubleBuffer(rasterBuf, stepX, stepY, begin, bandList); break;

		}

		/*int xPx = 0, yPx = 0;

		for (int iBand = 0; iBand < rasterBuf.getBandCount(); iBand++) {

			yPx = 0;

			for(double row = begin.getY(); yPx < bufHeight; row += stepY) {

				xPx = 0;

				for(double col = begin.getX(); xPx < bufWidth; col += stepX) {

					switch(buffer.getDataType()){

					case Buffer.TYPE_BYTE: rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemByte((int)row, (int)col, iBand)); break;

					case Buffer.TYPE_SHORT: rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemShort((int)row, (int)col, iBand)); break;

					case Buffer.TYPE_INT: rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemInt((int)row, (int)col, iBand)); break;

					case Buffer.TYPE_FLOAT: rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemFloat((int)row, (int)col, iBand)); break;

					case Buffer.TYPE_DOUBLE: rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemDouble((int)row, (int)col, iBand)); break;

					}

					xPx ++;

				}

				yPx ++;

			}

		}*/

		return rasterBuf;

	}

	/**

	 * Escribe sobre el buffer pasado por par?metro los valores solicitados, desde el buffer de la clase. Los valores

	 * se solicitan a trav?s de los par?metros. En ellos se especifica el tama?o del buffer de destino, las bandas a

	 * escribir, el punto inicial en coordenadas pixel (double) y el incremento.

	 * @param rasterBuf Buffer donde se escriben los datos

	 * @param stepX Incremento en X. Cada vez que se escribe un pixel en X se incrementa el contador en stepX pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo ancho que el de origen. Este valor suele ser ancho_buffer_origen / ancho_buffer_destino.

	 * @param stepY Incremento en Y. Cada vez que se escribe un pixel en Y se incrementa el contador en stepY pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo alto que el de origen. Este valor suele ser alto_buffer_origen / alto_buffer_destino.

	 * @param begin pixel donde se comienza a leer en el buffer de origen. Este valor es decimal ya que no tiene porque empezar a leerse al principio

	 * del pixel. Esto es util cuando se supersamplea.

	 */

	private void writeByteBuffer(Buffer rasterBuf, double stepX, double stepY, Point2D begin, BandList bandList) {

		int xPx = 0, yPx = 0;

		for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

			int[] drawableBands = bandList.getBufferBandToDraw(new File(this.getURIOfFirstProvider()).getAbsolutePath(), iBand);

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

				continue;

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

				yPx = 0;

				for(double row = begin.getY(); (yPx < rasterBuf.getHeight() && row < buffer.getHeight()); row += stepY) {

					xPx = 0;

					for(double col = begin.getX(); (xPx < rasterBuf.getWidth() && col < buffer.getWidth()); col += stepX) {

						rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemByte((int)row, (int)col, iBand));

						xPx ++;

					}

					yPx ++;

				}

			}

		}

	}

	/**

	 * Escribe sobre el buffer pasado por par?metro los valores solicitados, desde el buffer de la clase. Los valores

	 * se solicitan a trav?s de los par?metros. En ellos se especifica el tama?o del buffer de destino, las bandas a

	 * escribir, el punto inicial en coordenadas pixel (double) y el incremento.

	 * @param rasterBuf Buffer donde se escriben los datos

	 * @param stepX Incremento en X. Cada vez que se escribe un pixel en X se incrementa el contador en stepX pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo ancho que el de origen. Este valor suele ser ancho_buffer_origen / ancho_buffer_destino.

	 * @param stepY Incremento en Y. Cada vez que se escribe un pixel en Y se incrementa el contador en stepY pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo alto que el de origen. Este valor suele ser alto_buffer_origen / alto_buffer_destino.

	 * @param begin pixel donde se comienza a leer en el buffer de origen. Este valor es decimal ya que no tiene porque empezar a leerse al principio

	 * del pixel. Esto es util cuando se supersamplea.

	 */

	private void writeShortBuffer(Buffer rasterBuf, double stepX, double stepY, Point2D begin, BandList bandList) {

		int xPx = 0, yPx = 0;

		for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

			int[] drawableBands = bandList.getBufferBandToDraw(new File(this.getURIOfFirstProvider()).getAbsolutePath(), iBand);

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

				continue;

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

				yPx = 0;

				for(double row = begin.getY(); yPx < rasterBuf.getHeight(); row += stepY) {

					xPx = 0;

					for(double col = begin.getX(); xPx < rasterBuf.getWidth(); col += stepX) {

						rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemShort((int)row, (int)col, iBand));

						xPx ++;

					}

					yPx ++;

				}

			}

		}

	}

	/**

	 * Escribe sobre el buffer pasado por par?metro los valores solicitados, desde el buffer de la clase. Los valores

	 * se solicitan a trav?s de los par?metros. En ellos se especifica el tama?o del buffer de destino, las bandas a

	 * escribir, el punto inicial en coordenadas pixel (double) y el incremento.

	 * @param rasterBuf Buffer donde se escriben los datos

	 * @param stepX Incremento en X. Cada vez que se escribe un pixel en X se incrementa el contador en stepX pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo ancho que el de origen. Este valor suele ser ancho_buffer_origen / ancho_buffer_destino.

	 * @param stepY Incremento en Y. Cada vez que se escribe un pixel en Y se incrementa el contador en stepY pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo alto que el de origen. Este valor suele ser alto_buffer_origen / alto_buffer_destino.

	 * @param begin pixel donde se comienza a leer en el buffer de origen. Este valor es decimal ya que no tiene porque empezar a leerse al principio

	 * del pixel. Esto es util cuando se supersamplea.

	 */

	private void writeIntBuffer(Buffer rasterBuf, double stepX, double stepY, Point2D begin, BandList bandList) {

		int xPx = 0, yPx = 0;

		for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

			int[] drawableBands = bandList.getBufferBandToDraw(new File(this.getURIOfFirstProvider()).getAbsolutePath(), iBand);

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

				continue;

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

				yPx = 0;

				for(double row = begin.getY(); yPx < rasterBuf.getHeight(); row += stepY) {

					xPx = 0;

					for(double col = begin.getX(); xPx < rasterBuf.getWidth(); col += stepX) {

						rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemInt((int)row, (int)col, iBand));

						xPx ++;

					}

					yPx ++;

				}

			}

		}

	}

	/**

	 * Escribe sobre el buffer pasado por par?metro los valores solicitados, desde el buffer de la clase. Los valores

	 * se solicitan a trav?s de los par?metros. En ellos se especifica el tama?o del buffer de destino, las bandas a

	 * escribir, el punto inicial en coordenadas pixel (double) y el incremento.

	 * @param rasterBuf Buffer donde se escriben los datos

	 * @param stepX Incremento en X. Cada vez que se escribe un pixel en X se incrementa el contador en stepX pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo ancho que el de origen. Este valor suele ser ancho_buffer_origen / ancho_buffer_destino.

	 * @param stepY Incremento en Y. Cada vez que se escribe un pixel en Y se incrementa el contador en stepY pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo alto que el de origen. Este valor suele ser alto_buffer_origen / alto_buffer_destino.

	 * @param begin pixel donde se comienza a leer en el buffer de origen. Este valor es decimal ya que no tiene porque empezar a leerse al principio

	 * del pixel. Esto es util cuando se supersamplea.

	 */

	private void writeFloatBuffer(Buffer rasterBuf, double stepX, double stepY, Point2D begin, BandList bandList) {

		int xPx = 0, yPx = 0;

		for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

			int[] drawableBands = bandList.getBufferBandToDraw(new File(this.getURIOfFirstProvider()).getAbsolutePath(), iBand);

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

				continue;

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

				yPx = 0;

				for(double row = begin.getY(); yPx < rasterBuf.getHeight(); row += stepY) {

					xPx = 0;

					for(double col = begin.getX(); xPx < rasterBuf.getWidth(); col += stepX) {

						rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemFloat((int)row, (int)col, iBand));

						xPx ++;

					}

					yPx ++;

				}

			}

		}

	}

	/**

	 * Escribe sobre el buffer pasado por par?metro los valores solicitados, desde el buffer de la clase. Los valores

	 * se solicitan a trav?s de los par?metros. En ellos se especifica el tama?o del buffer de destino, las bandas a

	 * escribir, el punto inicial en coordenadas pixel (double) y el incremento.

	 * @param rasterBuf Buffer donde se escriben los datos

	 * @param stepX Incremento en X. Cada vez que se escribe un pixel en X se incrementa el contador en stepX pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo ancho que el de origen. Este valor suele ser ancho_buffer_origen / ancho_buffer_destino.

	 * @param stepY Incremento en Y. Cada vez que se escribe un pixel en Y se incrementa el contador en stepY pixels. Esto es necesario

	 * ya que el buffer destino no tiene porque tener el mismo alto que el de origen. Este valor suele ser alto_buffer_origen / alto_buffer_destino.

	 * @param begin pixel donde se comienza a leer en el buffer de origen. Este valor es decimal ya que no tiene porque empezar a leerse al principio

	 * del pixel. Esto es util cuando se supersamplea.

	 */

	private void writeDoubleBuffer(Buffer rasterBuf, double stepX, double stepY, Point2D begin, BandList bandList) {

		int xPx = 0, yPx = 0;

		for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

			int[] drawableBands = bandList.getBufferBandToDraw(new File(this.getURIOfFirstProvider()).getAbsolutePath(), iBand);

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

				continue;

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

				yPx = 0;

				for(double row = begin.getY(); yPx < rasterBuf.getHeight(); row += stepY) {

					xPx = 0;

					for(double col = begin.getX(); xPx < rasterBuf.getWidth(); col += stepX) {

						rasterBuf.setElem(yPx, xPx, iBand, buffer.getElemDouble((int)row, (int)col, iBand));

						xPx ++;

					}

					yPx ++;

				}

			}

		}

	}

	/*

	 *  (non-Javadoc)

	 * @see org.gvsig.raster.dataset.RasterDataset#getWindowRaster(int, int, org.gvsig.raster.dataset.BandList, org.gvsig.raster.dataset.Buffer)

	 */

//	public Buffer getWindow(int x, int y, BandList bandList, Buffer rasterBuf) {

//		int w = rasterBuf.getWidth();

//		int h = rasterBuf.getHeight();

//		setView(

//				new ExtentImpl( rasterUtil.getMapRectFromPxRect(getExtent().toRectangle2D(),

//							getWidth(),

//							getHeight(),

//							new Rectangle2D.Double(x, y, w, h)))

//				);

//

//		for(int iBand = 0; iBand < buffer.getBandCount(); iBand ++){

//			int[] drawableBands = bandList.getBufferBandToDraw(this.getURIOfFirstProvider(), iBand);

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

//				continue;

//			if(buffer.getDataType() == Buffer.TYPE_BYTE) {

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

//					for(int line = y; line < (y + h); line ++)

//						for(int col = x; col < (x + w); col ++)

//							rasterBuf.setElem((line - y), (col - x), drawableBands[drawBands], buffer.getElemByte(line, col, drawableBands[drawBands]));

//				}

//			}else if(buffer.getDataType() == Buffer.TYPE_SHORT){

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

//					for(int line = y; line < (y + h); line ++)

//						for(int col = x; col < (x + w); col ++)

//							rasterBuf.setElem((line - y), (col - x), drawableBands[drawBands], buffer.getElemShort(line, col, drawableBands[drawBands]));

//				}

//			}else if(buffer.getDataType() == Buffer.TYPE_INT){

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

//					for(int line = y; line < (y + h); line ++)

//						for(int col = x; col < (x + w); col ++)

//							rasterBuf.setElem((line - y), (col - x), drawableBands[drawBands], buffer.getElemInt(line, col, drawableBands[drawBands]));

//				}

//			}else if(buffer.getDataType() == Buffer.TYPE_FLOAT){

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

//					for(int line = y; line < (y + h); line ++)

//						for(int col = x; col < (x + w); col ++)

//							rasterBuf.setElem((line - y), (col - x), drawableBands[drawBands], buffer.getElemFloat(line, col, drawableBands[drawBands]));

//				}

//			}else if(buffer.getDataType() == Buffer.TYPE_DOUBLE){

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

//					for(int line = y; line < (y + h); line ++)

//						for(int col = x; col < (x + w); col ++)

//							rasterBuf.setElem((line - y), (col - x), drawableBands[drawBands], buffer.getElemDouble(line, col, drawableBands[drawBands]));

//				}

//			}

//		}

//		return rasterBuf;

//	}

	public Buffer getWindow(int x, int y, int w, int h,

			BandList bandList, Buffer rasterBuf, TaskStatus status) {

		setView(

				new ExtentImpl( rasterUtil.getMapRectFromPxRect(getExtent().toRectangle2D(),

							getWidth(),

							getHeight(),

							new Rectangle2D.Double(x, y, w, h)))

				);

		//Relaci?n entre el n?mero de pixels del buffer origen (area seleccionada) y el destino

		double stepX = w / ((double)rasterBuf.getWidth());

		double stepY = h / ((double)rasterBuf.getHeight());

		switch(buffer.getDataType()){

		case Buffer.TYPE_BYTE: writeByteBuffer(rasterBuf, stepX, stepY, new Point2D.Double(x, y), bandList); break;

		case Buffer.TYPE_SHORT: writeShortBuffer(rasterBuf, stepX, stepY, new Point2D.Double(x, y), bandList); break;

		case Buffer.TYPE_INT: writeIntBuffer(rasterBuf, stepX, stepY, new Point2D.Double(x, y), bandList); break;

		case Buffer.TYPE_FLOAT: writeFloatBuffer(rasterBuf, stepX, stepY, new Point2D.Double(x, y), bandList); break;

		case Buffer.TYPE_DOUBLE: writeDoubleBuffer(rasterBuf, stepX, stepY, new Point2D.Double(x, y), bandList); break;

		}

		return rasterBuf;

	}

	public Object readCompleteLine(int line, int band) throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		switch(buffer.getDataType()){

		case Buffer.TYPE_BYTE: return buffer.getLineFromBandByte(line, band);

		case Buffer.TYPE_SHORT: return buffer.getLineFromBandShort(line, band);

		case Buffer.TYPE_INT: return buffer.getLineFromBandInt(line, band);

		case Buffer.TYPE_FLOAT: return buffer.getLineFromBandFloat(line, band);

		case Buffer.TYPE_DOUBLE: return buffer.getLineFromBandDouble(line, band);

		}

		return null;

	}

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

		if(pos < 0)

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

		if((pos + blockHeight) > buffer.getHeight())

			blockHeight = Math.abs(buffer.getHeight() - pos);

		switch(buffer.getDataType()){

		case Buffer.TYPE_BYTE:

			byte[][][] bufb = new byte[getBandCount()][][];

			for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

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

					bufb[iBand][row] = buffer.getLineFromBandByte(row, iBand);

				}

			}

			return bufb;

		case Buffer.TYPE_SHORT:

			short[][][] bufs = new short[getBandCount()][][];

			for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

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

					bufs[iBand][row] = buffer.getLineFromBandShort(row, iBand);

				}

			}

			return bufs;

		case Buffer.TYPE_INT:

			int[][][] bufi = new int[getBandCount()][][];

			for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

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

					bufi[iBand][row] = buffer.getLineFromBandInt(row, iBand);

				}

			}

			return bufi;

		case Buffer.TYPE_FLOAT:

			float[][][] buff = new float[getBandCount()][][];

			for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

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

					buff[iBand][row] = buffer.getLineFromBandFloat(row, iBand);

				}

			}

			return buff;

		case Buffer.TYPE_DOUBLE:

			double[][][] bufd = new double[getBandCount()][][];

			for (int iBand = 0; iBand < buffer.getBandCount(); iBand++) {

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

					bufd[iBand][row] = buffer.getLineFromBandDouble(row, iBand);

				}

			}

			return bufd;

		}

		return null;

	}

		/**

	 * Obtiene el objeto que contiene el estado de la transparencia

	 */

	public Transparency getTransparency() {

		if(transparency == null)

			transparency = new DataStoreTransparency(getColorInterpretation());

		return transparency;

	}

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

		if(band >= getBandCount())

			throw new BandAccessException("Wrong band");

		return 0;

	}

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

		return false;

	}

	public String getProviderName() {

		return NAME;

	}

        public String getName() {

		return "buffer"+this.hashCode();

	}

        public String getFullName() {

		return this.getName();

	}

	public void setStatus(RasterProvider provider) {

		if(provider instanceof MemoryRasterProvider) {

			//Not implemented yet

		}

	}

	public TileServer getTileServer() {

		return null;

	}

    public void addFile(File file) throws InvalidSourceException {

        // Do nothing

    }

    public void removeFile(File file) {

        // Do nothing

    }

}

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

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

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

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

/**

 * Parameters for the memory provider

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

 */

public class MemoryDataParameters extends AbstractRasterFileDataParameters {

	private final String id = "memory";

	private Buffer buffer = null;

	private Extent extent = null;

	/**

	 * Constructor vacio

	 */

	public MemoryDataParameters() {

	}

	/**

	 * Contructor

	 * @param buf buffer del driver

	 * @param ext extensi?n del buffer

	 */

	public MemoryDataParameters(Buffer buf, Extent ext) {

		this.buffer = buf;

		this.extent = ext;

	}

	/**

	 * Obtiene el buffer de datos

	 * @return Buffer

	 */

	public Buffer getBuffer() {

		return buffer;

	}

	/**

	 * Asigna el buffer de datos

	 * @param buffer Buffer

	 */

	public void setBuffer(Buffer buffer) {

		this.buffer = buffer;

	}

	/**

	 * Obtiene la extensi?n del buffer de datos

	 * @return Extent

	 */

	public Extent getExtent() {

		return extent;

	}

	/**O

	 * Asigna la extensi?n del buffer de datos

	 * @param extent

	 */

	public void setExtent(Extent extent) {

		this.extent = extent;

	}

	/**

	 * Obtiene el identificador del driver

	 * @return String 

	 */

	public String getFormatID() {

		return id;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.DataStoreParameters#getDataStoreName()

	 */

	public String getDataStoreName() {

		return MemoryRasterProvider.NAME;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.DataStoreParameters#getDescription()

	 */

	public String getDescription() {

		return MemoryRasterProvider.DESCRIPTION;

	}

}

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

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.gdal.io;

import java.awt.geom.AffineTransform;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.store.parameter.NewRasterStoreParameters;

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

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

import org.gvsig.tools.locator.LocatorException;

public class GdalFilesystemServerExplorer extends AbstractFilesystemServerExplorerProvider {

	public boolean canCreate() {

		return false;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		return false;

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		NewRasterStoreParameters p = null;

		if(parameters instanceof NewRasterStoreParameters)

			 p = (NewRasterStoreParameters)parameters;

		DataServerWriter dataWriter = p.getDataServer();

		if(dataWriter == null)

			dataWriter = RasterLocator.getManager().createDataServerWriter();

		dataWriter.setBuffer(p.getBuffer(), p.getBand());

		Params params;

		try {

			if(p.getDriverParams() != null)

				params = p.getDriverParams();

			else

				params = RasterLocator.getManager().createWriter(p.getFileName()).getParams();

			AffineTransform affineTransform = p.getAffineTransform();

			if(affineTransform == null) {

				if(p.getBuffer().getDataExtent() != null) {

					double x = p.getBuffer().getDataExtent().getMinX();

					double y = p.getBuffer().getDataExtent().getMaxY();

					double pixelSizeX = p.getBuffer().getDataExtent().getWidth() / p.getBuffer().getWidth();

					double pixelSizeY = p.getBuffer().getDataExtent().getHeight() / p.getBuffer().getHeight();

					affineTransform = new AffineTransform(pixelSizeX, 0, 0, -pixelSizeY, x, y);

				} else {

					affineTransform = new AffineTransform();

				}

			}

			RasterWriter writer = RasterLocator.getManager().createWriter(

					dataWriter, 

					p.getPath() + File.separator + p.getFileName(),

					p.getBand() < 0 ? p.getBuffer().getBandCount() : 1, 

					affineTransform, 

					p.getBuffer().getWidth(),

					p.getBuffer().getHeight(), 

					p.getBuffer().getDataType(), 

					params, 

					null);

			if(p.getColorInterpretation() != null)

				writer.setColorBandsInterpretation(p.getColorInterpretation());

			writer.setWkt(p.getWktProjection());

			writer.dataWrite();

			writer.writeClose();

		} catch (LocatorException e) {

			throw new CreateException("", e);

		} catch (NotSupportedExtensionException e) {

			throw new CreateException("", e);

		} catch (RasterDriverException e) {

			throw new CreateException("", e);

		} catch (ProcessInterruptedException e) {

			//Fin del proceso

		} catch (IOException e) {

			throw new CreateException("", e);

		}

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		return new GdalNewRasterStoreParameters();

	}

	public void initialize(FilesystemServerExplorerProviderServices serverExplorer) {

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		throw new UnsupportedOperationException();

	}

	public String getDataStoreProviderName() {

		return GdalProvider.NAME;

	}

	public boolean accept(File pathname) {

		if (pathname.getParentFile() != null && 

			pathname.getParentFile().getName().equals("cellhd")) {

			if (pathname.getName().endsWith(".rmf")

					|| pathname.getName().endsWith(".rmf~")) {

				return false;

			}

			return true;

		}

		// Comprobamos que no sea un rmf propio, osea, que contenga xml

		if (pathname.getName().toLowerCase().endsWith(".rmf")) {

			FileInputStream reader = null;

			try {

				reader = new FileInputStream(pathname);

				String xml = "";

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

					xml += (char) reader.read();

				}

				if (xml.equals("<?xml ")) {

					return false;

				}

			} catch (Exception e) {

			} finally {

				try {

					reader.close();

				} catch (Exception e) {

				}

			}

		}

		return RasterLocator.getManager().getProviderServices().isExtensionSupported(

				pathname.getAbsolutePath(), 

				GdalProvider.class);

	}

	public String getDescription() {

		return GdalProvider.DESCRIPTION;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		AbstractRasterFileDataParameters params = (AbstractRasterFileDataParameters) manager

				.createStoreParameters(this.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public int getMode() {

		return DataServerExplorer.MODE_RASTER;

	}

}

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

import java.io.File;

import java.io.IOException;

import java.sql.Savepoint;

import java.util.ArrayList;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

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

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

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

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

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

import org.gvsig.jgdal.GdalBuffer;

import org.gvsig.jgdal.GdalDataset;

import org.gvsig.jgdal.GdalDriver;

import org.gvsig.jgdal.GdalException;

import org.gvsig.jgdal.GdalRasterBand;

import org.gvsig.jgdal.GeoTransform;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 a trav?s de Gdal.

 * Puede exportar un fichero de un formato a otro desde un GeoRasterFile

 * en cualquier formato soportado por la lectura a un formato que este incluido

 * en la lista supportedDrv.

 *

 * Puede salvar a disco en un formato que este incluido en la lista supportedDrv

 * obteniendo los datos que van siendo servidos desde el cliente. Este cliente

 * debe implementar un DataServerWriter o tener un objeto que lo implemente. Inicialmente

 * le pasar? los par?metros de la imagen de salida y cuando el driver comience a

 * escribir le ir? solicitando m?s a trav?s del m?todo readData de DataServerWriter.

 * El cliente ser? el que lleve el control de lo que va sirviendo y lo que le queda

 * por servir.

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

 */

public class GdalWriter extends DefaultRasterWriter {

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

	/**

	 *

	 */

	public static void register() {

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

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

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

		point.append("tif", "", GdalWriter.class);

		pInfo.getFileFeature().put("tif", new GTiffFeatures());

		point.append("img", "", GdalWriter.class);

		pInfo.getFileFeature().put("img", new HFAFeatures());

		point.append("bmp", "", GdalWriter.class);

		pInfo.getFileFeature().put("bmp", new BMPFeatures());

		point.append("pgm", "", GdalWriter.class);

		pInfo.getFileFeature().put("pgm", new PNM_PgmFeatures());

		point.append("ppm", "", GdalWriter.class);

		pInfo.getFileFeature().put("ppm", new PNM_PpmFeatures());

		point.append("mpl", "", GdalWriter.class);

		pInfo.getFileFeature().put("mpl", new ILWIS_MprFeatures());

		point.append("rst", "", GdalWriter.class);

		pInfo.getFileFeature().put("rst", new IDRISIFeatures());

		point.append("jp2", "", GdalWriter.class);

		pInfo.getFileFeature().put("jp2", new Jpeg2000Features());

		//La exportaci?n no es correcta del todo

//		point.append("rmf", "", GdalWriter.class);

//		pInfo.getFileFeature().put("rmf", new RMFFeatures());

		//No salva datos. Siempre sale negra la imagen

		//point.register("aux", GdalWriter.class);

		//fileFeature.put("aux", new PAuxFeatures());

	}

	private GdalDriver	                 	drv;

	private GdalDataset 							dstDataset = null;

	private GdalRasterBand 					rband = null;

	private GeoTransform 					geot = null; //Datos de georeferenciaci?n

	//private OGRSpatialReference 			oSRS; //Datos de proyecci?n

	private GdalBuffer[]					bufBands = null;

	private int 							nBlocks = 0; //N?mero de bloques en Y en el que se divide la imagen para escribir

	private int 							anchoResto = 0; //Tama?o del ?ltimo bloque de la imagen.

	private boolean							write = true; //Cuando est? a true se puede escribir en la imagen de salida. Si est? a false el proceso es interrumpido

	private int 							dataType = RasterBuffer.TYPE_UNDEFINED;

	/**

	 * Carga los par?metros de este driver.

	 * @param ident

	 */

	public void loadParams(String ident) {

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

		wfff.loadParams();

		driverParams = (ParamsImpl)wfff.getParams();

	}

	public String getProviderName() {

		return GdalProvider.NAME;

	}

	/**

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

	 * @param fileName

	 */

	public GdalWriter(String fileName) {

		ident = fileUtil.getExtensionFromFileName(fileName);

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

		loadParams(ident);

	}

	/**

	 * Constructor para salvar datos servidos por el cliente

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

	 * @param outFileName      	Fichero de salida

	 * @param nBands            N?mero de bandas

	 * @param at                Transformaci?n afin

	 * @param outSizeX		  	Tama?o de salida en X

	 * @param outSizeY			Tama?o de salida en Y

	 * @param dataType			Tipo de dato

	 * @param params

	 * @param proj

	 * @throws GdalException

	 * @throws IOException

	 */

	public GdalWriter(	DataServerWriter dataWriter,

			String outFileName,

			Integer nBands,

			AffineTransform at,

			Integer outSizeX,

			Integer outSizeY,

			Integer dataType,

			Params params,

			IProjection proj) throws GdalException, IOException {

		this(dataWriter, outFileName, nBands, at, outSizeX, outSizeY, dataType, params, proj, new Boolean(true));

	}

	/**

	 * Constructor para salvar datos servidos por el cliente

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

	 * @param outFileName

	 * @param nBands

	 * @param at

	 * @param outFilename      	Fichero de salida

	 * @param outSizeX		  	Tama?o de salida en X

	 * @param outSizeY			Tama?o de salida en Y

	 * @param dataType			Tipo de dato

	 * @param params

	 * @param proj

	 * @param geo				Flag que dice si se salva con georreferenciaci?n o sin ella

	 * @throws GdalException

	 * @throws IOException

	 */

	public GdalWriter(	DataServerWriter dataWriter,

			String outFileName,

			Integer nBands,

			AffineTransform at,

			Integer outSizeX,

			Integer outSizeY,

			Integer dataType,

			Params params,

			IProjection proj,

			Boolean geo)throws GdalException, IOException {

		this.proj = proj;

		ident = outFileName.toLowerCase().substring(outFileName.lastIndexOf(".") + 1);

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

		this.dataType = dataType.intValue();

		this.at = at;

		percent = 0;

		this.dataWriter = dataWriter;

		this.outFileName = outFileName;

		this.sizeWindowX = outSizeX.intValue();

		this.sizeWindowY = outSizeY.intValue();

		if ((sizeWindowX < 0) || (sizeWindowY < 0))

			throw new IOException("Tama?o del fichero de salida erroneo.");

		this.nBands = nBands.intValue();

		//Calculamos la georeferenciaci?n a partir del extend pasado por el cliente.

		geot = new GeoTransform();

		geot.adfgeotransform[0] = at.getTranslateX();

		geot.adfgeotransform[3] = at.getTranslateY();

		geot.adfgeotransform[1] = at.getScaleX();

		geot.adfgeotransform[5] = at.getScaleY();

		geot.adfgeotransform[2] = at.getShearX();

		geot.adfgeotransform[4] = at.getShearY();

		String outRmf = outFileName.substring(0, outFileName.lastIndexOf("."));

		if(geo.booleanValue())

			rasterUtil.saveGeoInfo(outRmf, at, new Point2D.Double(sizeWindowX, sizeWindowY));

		if(params == null)

			loadParams(ident);

		else

			if(params instanceof ParamsImpl)

				this.driverParams = (ParamsImpl)params;

		init();

	}

	/**

	 * A?ade la proyecci?n Wkt con la que salvar.

	 * @param wkt

	 * @throws GdalException

	 */

	public void setWkt(String wkt) {

		if(dstDataset != null && wkt != null && wkt.compareTo("unknown") != 0)

			try {

				dstDataset.setProjection(wkt);

			} catch (GdalException e) {

				System.err.println("Proyecci?n Wkt no asignada en GdalWriter");

				return;

			}

	}

	/**

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

	 * @param drvType        Tipo de driver

	 */

	public void setDriverType(String drvType) {

		this.driver = drvType;

	}

	/**

	 * Creaci?n del dataset de destino.

	 * @throws EcwException

	 */

	private void init() throws GdalException {

		//Controlamos que el tipo de driver sea correcto

		if (driver == null)

			throw new GdalException("Tipo de driver sin especificar.");

		boolean okdrvtype = false;

		String[] types = pInfo.getWriteDriversType();

		for (int i = 0; i < pInfo.getWriteNTypes(); i++)

			if (driver.equals(types[i]))

				okdrvtype = true;

		if (okdrvtype == false)

			throw new GdalException("El tipo de driver " + driver + " no est? soportado por GdalWriter.");

		//Obtenemos el driver y creamos el dataset del destino

		drv = GdalDataset.getDriverByName(driver);

		if (dstDataset != null) {

			dstDataset.close();

			dstDataset = null;

		}

		dstDataset = drv.create(outFileName, sizeWindowX, sizeWindowY,

				nBands, GdalDataSource.getGdalTypeFromRasterBufType(dataType), gdalParamsFromRasterParams(driverParams));

		dstDataset.setGeoTransform(geot);

		int blockSize = RasterLibrary.blockHeight;

		if(dataWriter.getBuffer() != null && dataWriter.getBuffer().isCached())

			blockSize = dataWriter.getBuffer().getBlockHeight();

		nBlocks = (sizeWindowY / blockSize);

		anchoResto = sizeWindowY - (nBlocks * blockSize);

	}

	/**

	 * @param fileName

	 * @throws GdalException

	 */

	public void anotherFile(String fileName) throws GdalException {

		dstDataset = drv.create(fileName, sizeWindowX, sizeWindowY,

				nBands, GdalDataSource.getGdalTypeFromRasterBufType(dataType), gdalParamsFromRasterParams(driverParams));

	}

	/**

	 * Convierte los par?metros obtenidos desde el objeto params a parametros

	 * comprensibles por la librer?a gdal

	 * @param p Params

	 * @return Array de par?metros

	 */

	public String[] gdalParamsFromRasterParams(Params p) {

		if (p == null)

			return null;

		ArrayList<String> paramList = new ArrayList<String>();

		ParamImpl phot = (ParamImpl)p.getParamById("photometric");