Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary

The_process_cant_be_cancelled=Operation cannot be cancelled.

Failed_pausing_the_process=Failed to pause processing.

msg_cancel_incrementable=Cancel the computation?

title_cancel_incrementable=Confirmation

Failed_resuming_the_process=Failed to resume processing.

The_process_cant_be_paused=Operation cannot be paused.

espere=Wait

tiempo_transcurrido=Elapsed time

error_processing=Error in the process

cargar_toc=Would you like to load layer?

confirmacion=Confirmation

stats=Statistics

compress=Compression

file=File

path=Path

size=Size

time=Time

The_process_cant_be_cancelled=No se puede cancelar el proceso

Failed_pausing_the_process=No se puede pausar el proceso

msg_cancel_incrementable=?Est? seguro de que desea cancelar este proceso?

title_cancel_incrementable=Confirmaci?n

Failed_resuming_the_process=Fall\u00f3 reanudando el proceso.

The_process_cant_be_paused=No se puede pausar el proceso

espere=Espere

tiempo_transcurrido=Tiempo transcurrido

error_processing=Error en el procesado

cargar_toc=\u00bfDesea cargar la capa en el TOC?

confirmacion=Confirmaci?n

stats=Estad?sticas

compress=Compresi?n

file=Fichero

path=Ruta

size=Tama?o

time=Tiempo

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

import org.gvsig.raster.algorithm.process.DataProcess;

import org.gvsig.raster.algorithm.process.ProcessException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

/**

 * Default {@link RasterBaseAlgorithmManager} implementation.

 *

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

 * @version $Id$

 */

public class RasterBaseAlgorithmManager {

	private static RasterBaseAlgorithmManager internalInstance  = new RasterBaseAlgorithmManager();

	/**

	 * Gets an instance of this object for internal use.

	 * @return RasterBaseAlgorithmManager

	 */

	public static RasterBaseAlgorithmManager getInstance() {

		return internalInstance;

	}

	/**

	 * Returns a new instance of a process.

	 * @param processLabel

	 *        Label to identify the process

	 * @return DataProcess

	 * @throws ProcessException

	 */

	public DataProcess createRasterTask(String processLabel) throws ProcessException {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.add(RasterBaseAlgorithmLibrary.REGISTER_PROCESS_LABEL);

		try {

			DataProcess process = (DataProcess)point.create(processLabel);

			process.setName(processLabel);

			return process;

		} catch (InstantiationException e) {

			throw new ProcessException("", e);

		} catch (IllegalAccessException e) {

			throw new ProcessException("", e);

		}

	}

}

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

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

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

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

/**

 * Calculates a pixel value using a interpolation method

 * @author Nacho Brodin nachobrodin@gmail.com

 * @author Victor Olaya

 */

public class Interpolation {

	private Buffer        buffer    = null;

	private double        nodata    = 0;

	public Interpolation(Buffer buf) {

		this.buffer = buf;

		NoData nodata = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

				1, Buffer.TYPE_DOUBLE);

		this.nodata = nodata.getValue().doubleValue();

	}

	private double[] getKernel(int x, int y, int band) {

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

			return getKernelByte(x, y, band);

		}

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

			return getKernelByte(x, y, band);

		}

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

			return getKernelByte(x, y, band);

		}

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

			return getKernelByte(x, y, band);

		}

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

			return getKernelByte(x, y, band);

		}

		return null;

	}

	public double getNearestNeighbour(double x, double y, int band) {

		int dy = (int)Math.round(y);

		int dx = (int)Math.round(x);

		dy = dy < buffer.getHeight() ? dy : buffer.getHeight() - 1;

		dx = dx < buffer.getWidth() ? dx : buffer.getWidth() - 1;

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

			return (double)buffer.getElemByte(dy, dx, band);

		}

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

			return (double)buffer.getElemDouble(dy, dx, band);

		}

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

			return (double)buffer.getElemFloat(dy, dx, band);

		}

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

			return (double)buffer.getElemShort(dy, dx, band);

		}

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

			return (double)buffer.getElemInt(dy, dx, band);

		}

		return nodata;

	}

	/**

	 * Calcula los valores N y Z para el m?todo bilinear y obtiene el valor del pixel como

	 * Z / N

	 * @param dx distancia en X desde el centro del pixel hasta el punto. Es un valor entre 0 y 1

	 * @param dy distancia en Y desde el centro del pixel hasta el punto. Es un valor entre 0 y 1

	 * @param kernel valor del pixel y alrededor 

	 * @return valor del pixel

	 */

	public double getBilinearValue(double x, double y, int band) {

		double[] kernel = getKernel((int)x, (int)y, band);

		double dx = x - ((int) x);

		double dy = y - ((int) y);

		double z = 0.0, n = 0.0, d;

		d = (1.0 - dx) * (1.0 - dy);

		z += d * kernel[0];

		n += d;

		d = dx * (1.0 - dy);

		z += d * kernel[1]; 

		n += d;

		d = (1.0 - dx) * dy;

		z += d * kernel[2]; 

		n += d;

		d = dx * dy;

		z += d * kernel[3]; 

		n += d;

		double b = 0;

		if(n > 0.0)

			b = (z / n);

		return b;

	}

	/**

	 * Calcula los valores N y Z para el m?todo de distancia inversa y calcula el valor del

	 * pixel como Z / N.

	 * @param dx distancia en X desde el centro del pixel hasta el punto. Es un valor entre 0 y 1

	 * @param dy distancia en Y desde el centro del pixel hasta el punto. Es un valor entre 0 y 1

	 * @param kernel valor del pixel y alrededor 

	 * @return valor del pixel

	 */

	public double getInverseDistance(double x, double y, int band) {

		double[] kernel = getKernel((int)x, (int)y, band);

		double dx = x - ((int) x);

		double dy = y - ((int) y);

		double z = 0.0, n = 0.0, d;

		d = 1.0 / Math.sqrt(dx * dx + dy * dy);

		z += d * kernel[0];

		n += d;

		d = 1.0 / Math.sqrt((1.0 - dx) * ( 1.0 - dx) + dy * dy);

		z += d * kernel[1]; 

		n += d;

		d = 1.0 / Math.sqrt(dx*dx + (1.0-dy)*(1.0-dy));

		z += d * kernel[2]; 

		n += d;

		d = 1.0 / Math.sqrt((1.0 - dx) *( 1.0 - dx) + (1.0 - dy) * (1.0 - dy));

		z += d * kernel[3]; 

		n += d;

		double b = 0;

		if(n > 0.0)

			b = (z / n);

		return b;

	}

	/**

	 * Obtiene un kernel de cuatro elemento que corresponden a los pixeles (x, y), (x + 1, y),

	 * (x, y + 1), (x + 1, y + 1). Si los pixeles x + 1 o y + 1 se salen del raster de origen

	 * se tomar? x e y. 

	 * @param x Coordenada X del pixel inicial

	 * @param y Coordenada Y del pixel inicial

	 * @param band N?mero de banda.

	 * @return Kernel solicitado en forma de array.

	 */

	private double[] getKernelByte(int x, int y, int band) {

		double[] d = new double[4];

		d[0] = (buffer.getElemByte(y, x, band) & 0xff);

		int nextX = ((x + 1) >= buffer.getWidth()) ? x : (x + 1);

		int nextY = ((y + 1) >= buffer.getHeight()) ? y : (y + 1);

		d[1] = (buffer.getElemByte(y, nextX, band) & 0xff);

		d[2] = (buffer.getElemByte(nextY, x, band) & 0xff);

		d[3] = (buffer.getElemByte(nextY, nextX, band) & 0xff);

		return d;

	}

	/**

	 * Obtiene un kernel de cuatro elemento que corresponden a los pixeles (x, y), (x + 1, y),

	 * (x, y + 1), (x + 1, y + 1). Si los pixeles x + 1 o y + 1 se salen del raster de origen

	 * se tomar? x e y. 

	 * @param x Coordenada X del pixel inicial

	 * @param y Coordenada Y del pixel inicial

	 * @param band N?mero de banda.

	 * @return Kernel solicitado en forma de array.

	 */

	@SuppressWarnings("unused")

	private double[] getKernelShort(int x, int y, int band) {

		double[] d = new double[4];

		d[0] = (buffer.getElemShort(y, x, band) & 0xffff);

		int nextX = ((x + 1) >= buffer.getWidth()) ? x : (x + 1);

		int nextY = ((y + 1) >= buffer.getHeight()) ? y : (y + 1);

		d[1] = (buffer.getElemShort(y, nextX, band) & 0xffff);

		d[2] = (buffer.getElemShort(nextY, x, band) & 0xffff);

		d[3] = (buffer.getElemShort(nextY, nextX, band) & 0xffff);

		return d;

	}

	/**

	 * Obtiene un kernel de cuatro elemento que corresponden a los pixeles (x, y), (x + 1, y),

	 * (x, y + 1), (x + 1, y + 1). Si los pixeles x + 1 o y + 1 se salen del raster de origen

	 * se tomar? x e y. 

	 * @param x Coordenada X del pixel inicial

	 * @param y Coordenada Y del pixel inicial

	 * @param band N?mero de banda.

	 * @return Kernel solicitado en forma de array.

	 */

	@SuppressWarnings("unused")

	private double[] getKernelInt(int x, int y, int band) {

		double[] d = new double[4];

		d[0] = (buffer.getElemInt(y, x, band) & 0xffffffff);

		int nextX = ((x + 1) >= buffer.getWidth()) ? x : (x + 1);

		int nextY = ((y + 1) >= buffer.getHeight()) ? y : (y + 1);

		d[1] = (buffer.getElemInt(y, nextX, band) & 0xffffffff);

		d[2] = (buffer.getElemInt(nextY, x, band) & 0xffffffff);

		d[3] = (buffer.getElemInt(nextY, nextX, band) & 0xffffffff);

		return d;

	}

	/**

	 * Obtiene un kernel de cuatro elemento que corresponden a los pixeles (x, y), (x + 1, y),

	 * (x, y + 1), (x + 1, y + 1). Si los pixeles x + 1 o y + 1 se salen del raster de origen

	 * se tomar? x e y. 

	 * @param x Coordenada X del pixel inicial

	 * @param y Coordenada Y del pixel inicial

	 * @param band N?mero de banda.

	 * @return Kernel solicitado en forma de array.

	 */

	@SuppressWarnings("unused")

	private double[] getKernelFloat(int x, int y, int band) {

		double[] d = new double[4];

		d[0] = buffer.getElemFloat(y, x, band);

		int nextX = ((x + 1) >= buffer.getWidth()) ? x : (x + 1);

		int nextY = ((y + 1) >= buffer.getHeight()) ? y : (y + 1);

		d[1] = buffer.getElemFloat(y, nextX, band);

		d[2] = buffer.getElemFloat(nextY, x, band);

		d[3] = buffer.getElemFloat(nextY, nextX, band);

		return d;

	}

	/**

	 * Obtiene un kernel de cuatro elemento que corresponden a los pixeles (x, y), (x + 1, y),

	 * (x, y + 1), (x + 1, y + 1). Si los pixeles x + 1 o y + 1 se salen del raster de origen

	 * se tomar? x e y. 

	 * @param x Coordenada X del pixel inicial

	 * @param y Coordenada Y del pixel inicial

	 * @param band N?mero de banda.

	 * @return Kernel solicitado en forma de array.

	 */

	@SuppressWarnings("unused")

	private double[] getKernelDouble(int x, int y, int band) {

		double[] d = new double[4];

		d[0] = buffer.getElemDouble(y, x, band);

		int nextX = ((x + 1) >= buffer.getWidth()) ? x : (x + 1);

		int nextY = ((y + 1) >= buffer.getHeight()) ? y : (y + 1);

		d[1] = buffer.getElemDouble(y, nextX, band);

		d[2] = buffer.getElemDouble(nextY, x, band);

		d[3] = buffer.getElemDouble(nextY, nextX, band);

		return d;

	}

}

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

/**

 * Interface for operations

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public interface Operation {

	public boolean compare(double a, double b);

	public void invoke();

}

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

/**

 * Interface for operations

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public abstract class AbstractOperation implements Operation {

	public boolean compare(double a, double b) {

		return false;

	}

	public void invoke() {

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

* 

*/

package org.gvsig.raster.algorithm.process;

import java.util.HashMap;

import java.util.Hashtable;

import javax.swing.SwingUtilities;

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

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

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

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

import org.gvsig.raster.algorithm.gui.IIncrementable;

import org.gvsig.raster.algorithm.gui.IncrementableEvent;

import org.gvsig.raster.algorithm.gui.IncrementableListener;

import org.gvsig.raster.algorithm.gui.IncrementableTask;

import org.gvsig.raster.swing.basepanel.IButtonsPanel;

import org.gvsig.tools.dispose.Disposable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase base de todos los procesos raster. En ella se genstionan todas las

 * funciones comunes como incremento de la tarea, gesti�n de eventos a la tarea, 

 * par�metros de la tarea, etc ...

 * 

 * 18/12/2007

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public abstract class DataProcess extends ProcessParamsManagement implements IIncrementable, IncrementableListener, Runnable, Disposable {

	protected IncrementableTask incrementableTask = null;

	protected volatile Thread   blinker           = null;

	protected TaskEventManager  taskEventManager  = null;

	protected IProcessActions   externalActions   = null;

	protected Hashtable<String, Object>

	                            taskParams        = new Hashtable<String, Object>();

	private String              log               = "";

	private String              lastLine          = "";

	private long                time              = 0;

	private boolean             progressActive    = true;

	private IProcessActions     queueActions      = null;

	protected Logger            logger            = LoggerFactory.getLogger(DataProcess.class.toString());

	private int                 percent           = 0;

	private String              processName       = null;

	//***************************************************

	//Task control

	//***************************************************

	/**

	 * Builds the window <code>IncrementableTask</code> to show

	 * the increment of the task.

	 */

	public IncrementableTask getIncrementableTask() {

		if (incrementableTask == null) {

			incrementableTask = new IncrementableTask(this);

			incrementableTask.addIncrementableListener(this);

		}

		return incrementableTask;

	}

	/**

	 * Sets the button to cancel the task

	 */

	public void setCancelable(boolean enabled) {

		getIncrementableTask().getButtonsPanel().setEnabled(IButtonsPanel.BUTTON_CANCEL, enabled);

	}

	/**

	 * Show the increment of this task <code>IncrementableTask</code>

	 */

	public void showIncrementableWindow() {

		if (progressActive) {

			getIncrementableTask().showWindow();

			getIncrementableTask().start();

		}

	}

	/**

	 * Starts the process. It will call the run method

	 */

	public void start() {

		showIncrementableWindow();

		if(blinker == null)

			blinker = new Thread(this);

		blinker.start();

	}

	/**

	 * A specific task will load parameters using this initialization.

	 */

	public abstract void init();

	/**

	 * This call will be implemented by a specific process. It will do the actions to carry out

	 * the task

	 * @throws InterruptedException

	 */

	public abstract void process() throws ProcessInterruptedException, ProcessException;

	/**

	 * Gets the result of the process. All processes will have a parameter PROCESS that it is

	 * the own process. It is useful to get the process name or other data.

	 * 

	 * This result of the process is sent to the method "end" in <code>IProcessActions</code> when the task

	 * is thrown in a thread or is recovered by the user when the task is thrown sequentially.

	 * 

	 * @return Result of the task

	 */

	public HashMap<String, Object> getResult() {

		outputParameters.put("PROCESS", this);

		outputParameters.put(TIME, getTime());

		outputParameters.put(PROCESS_NAME, getName());

		return outputParameters;

	}

	/**

	 * Adds a output from the process in runtime

	 * @param key

	 * @param value

	 */

	protected void addOutputValue(String key, Object value) {

		outputParameters.put(key, value);

	}

	/**

	 * Sequential execution of this task

	 * @throws ProcessException 

	 */

	public void execute() throws ProcessInterruptedException, ProcessException {

		taskEventManager = RasterLocator.getManager().createRasterTask(this);

		loadGlobalParameters();

		init();

		process();

		//Sets in the output the result of the process

		SwingUtilities.invokeLater(new Runnable() {

			public void run() {

				if (externalActions != null) {

					externalActions.end(getResult());

				}

			}

		});

	}

	/**

	 * This method will be executed by the Thread. It will have the global actions for 

	 * any task and it will call to the <code>execute</code> function.

	 */

	public void run() {

		long t1 = new java.util.Date().getTime();

		try {

			execute();

		} catch (ProcessInterruptedException e) {

			if (externalActions != null)

				externalActions.interrupted();

			Thread.currentThread().interrupt();

		} catch (ProcessException e) {

			if (progressActive) {

				if (incrementableTask != null) {

					getIncrementableTask().processFinalize();

					incrementableTask = null;

				}

			}

			logger.warn(RasterLocator.getManager().getRasterUtils().getTrace(e));

			if(e.getMessage() != null && e.getMessage().compareTo("") != 0)

				messageBoxError(e.getMessage(), null);

			else

				messageBoxError("error_processing", null);

			queueActions = null;

		} catch (Exception e) {

			if (progressActive) {

				if (incrementableTask != null) {

					getIncrementableTask().processFinalize();

					incrementableTask = null;

				}

			}

			logger.warn(RasterLocator.getManager().getRasterUtils().getTrace(e));

			if(e.getMessage() != null && e.getMessage().compareTo("") != 0)

				messageBoxError(e.getMessage(), null);

			else

				messageBoxError("error_processing", null);

			queueActions = null;

		} finally {

			try {

				//Evita un NullPointerException sun.awt.X11.XWindowPeer.restoreTransientFor(XWindowPeer.java:1500) 

				Thread.sleep(500);

			} catch(Exception e) {}

			taskEventManager.removeTask();

			if (progressActive) {

				if (incrementableTask != null)

					getIncrementableTask().processFinalize();

			}

			if (queueActions != null)

				queueActions.end(this);

			time = new java.util.Date().getTime() - t1;

			blinker = null;

		}

	}

	/**

	 * When the process is launched in a thread, this method enables or disables

	 * the GUI to show the progress.

	 */

	public void setProgressActive(boolean active) {

		this.progressActive = active;

	}

	/**

	 * Gets the time that a task lasts

	 */

	public long getTime() {

		return time;

	}

	/**

	 * Gets the object to execute external actions. 

	 * A user should be register this object to receive the events

	 */

	public IProcessActions getActions() {

		return externalActions;

	}

	/**

	 * Sets the object to execute external actions. 

	 * A user should be register this object to receive the events

	 */

	public void setActions(IProcessActions actions) {

		this.externalActions = actions;

	}

	/**

	 * Gets the object to execute actions in the queue of processes

	 */

	public IProcessActions getUniqueProcessActions() {

		return queueActions;

	}

	/**

	 * Asigna el objeto para ejecutar acciones externar.

	 * @param IProcessActions

	 */

	public void setUniqueProcessActions(IProcessActions actions) {

		this.queueActions = actions;

	}

	/**

	 * Inserts a new line in the increment window

	 */

	protected void insertLineLog(String line) {

		lastLine = line;

		log = log + line + "\n";

	}

	/**

	 * Gets the last line in the increment window

	 */

	public String getLabel() {

		return lastLine;

	}

	/**

	 * Gets the log of the increment window

	 */

	public String getLog() {

		return log;

	}

	/**

	 * Un evento de cancelado es enviado a la tarea cuando actionCanceled es activado. Para

	 * ello se crear� un objeto CancelEvent y se asignar� a la tarea en ejecuci�n. Esta lo

	 * procesar� cuando pueda e interrumpir� el proceso.

	 */

	public void actionCanceled(IncrementableEvent e) {

		taskEventManager.setEvent(new CancelEvent(this));

	}

	/**

	 * Updates the percentaje of progress and manages the cancelation

	 * @param parcial

	 * @param total

	 * @throws ProcessInterruptedException

	 */

	public void updatePercent(int parcial, int total) throws ProcessInterruptedException {

		if (taskEventManager != null && taskEventManager.getEvent() != null)

			taskEventManager.manageEvent(taskEventManager.getEvent());

		if(externalActions != null)

			externalActions.updateProgress(parcial, total);

		percent = (int)((parcial * 100) / total);

	}

	public int getPercent() {

		return percent;

	}

	public void actionResumed(IncrementableEvent e) {	

	}

	public void actionSuspended(IncrementableEvent e) {

	}

	public boolean isCancelable() {

		return true;

	}

	public boolean isPausable() {

		return false;

	}

	public String getName() {

		return processName;

	}

	public void setName(String name) {

		this.processName = name;

	}

	public void dispose() {

		try {

			finalize();

		} catch (Throwable e) {

		}

	}

	@Override

	protected void finalize() throws Throwable {

		incrementableTask           = null;

		blinker                     = null;

		externalActions             = null;

		super.finalize();

	}

}

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

/**

 * Acciones que puede ejecutar un proceso sobre un objeto externo. Un proceso

 * debe ser independiente de objetos que sean dependientes de su funcionalidad. Es

 * decir, cualquier extensi?n debe poder usar un proceso y este ejecutar metodos

 * de la funcionalidad. Esto se hace ha trav?s de este interfaz.

 * 

 * @version 26/09/2007

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

 *

 */

public interface IProcessActions {

	/**

	 * El proceso comunica que ha sido interrumpido

	 *

	 */

	public void interrupted();

	/**

	 * Acciones de finalizaci?n del proceso

	 */

	public void end(Object param);

	/**

	 * A process can report the progress of the task

	 * @param current

	 * @param total

	 */

	public void updateProgress(int current, int total);

}

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

/**

 * This exception is thrown when a problem inside a raster process

 * is detected. 

 * 

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

 */

public class ProcessException extends Exception {

	private static final long serialVersionUID = 666908550965442025L;

	public ProcessException(String msg, Throwable e) {

		super(msg, e);

	}

	public ProcessException(String msg){

		super(msg);

	}

}

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

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

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

import org.gvsig.raster.algorithm.gui.IIncrementable;

import org.gvsig.raster.algorithm.gui.IncrementableListener;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

/**

 * Base class for all geoprocesses. This class contains all utilities to register

 * and get parameters in a geoprocess instance

 * 

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public abstract class ProcessParamsManagement extends ProcessUtils implements IIncrementable, IncrementableListener, Runnable, Disposable {

	//***********************

	//Global input parameters

	//***********************

	/**

	 * Input parameter: If is defined then the ROIs will be used

	 */

	public static String                ROI_EPSG                           = "ROI_EPSG";

	/**

	 * Input parameter: Force to this bounding box. If is defined, then ROI_EPSG is not taken into account

	 */

	public static String                WINDOW                             = "WINDOW";

	/**

	 * Input parameter: Force to this width in pixels in the output buffer

	 */

	public static String                OUTPUT_WIDTH                       = "OUTPUT_WIDTH";

	/**

	 * Input parameter: Force to this height in pixels in the output buffer

	 */

	public static String                OUTPUT_HEIGHT                      = "OUTPUT_HEIGHT";

	/**

	 * Input parameter: The output of this algorithm is for previews. It usually implies that the buffer will be

	 * send as output parameter, the buffer will be RGB and the input buffer will be to read and write

	 */

	public static String                PREVIEW                            = "PREVIEW";

	//************************

	//Global output parameters

	//***********************

	/**

	 * Output parameter: The getResult sets the correct value in the output.

	 */

	public static String                TIME                               = "TIME";

	/**

	 * Output parameter: The getResult sets the correct value in the output.

	 */

	public static String                PROCESS                            = "PROCESS";

	/**

	 * Output parameter: The getResult sets the correct value in the output.

	 */

	public static String                PROCESS_NAME                       = "PROCESS_NAME";

	public static final String          REGISTER_INPUT_PARAMETERS_LABEL    = "RasterProcessInputParam";

	public static final String          REGISTER_OUTPUT_PARAMETERS_LABEL   = "RasterProcessOutputParam";

	private Extent                      outputWindow                       = null;

	private int                         outputWidth                        = 0;

	private int                         outputHeight                       = 0;

	private String                      roiEPSG                            = null;

	private boolean                     preview                            = false;

	private boolean                     globalParametersLoaded             = false;

	protected Hashtable<String, Object> inputParameters                    = new Hashtable<String, Object>();

	protected HashMap<String, Object>   outputParameters                   = new HashMap<String, Object>();

	/**

	 *  Registers input parameters of a raster process

	 */

	public static void registerInputParameter(String parameterLabel, Class<?> parameterClass, String processLabel) {

		registerParameter(processLabel, parameterLabel, parameterClass, REGISTER_INPUT_PARAMETERS_LABEL);

	}

	/**

	 *  Registers output parameters of a raster process

	 */

	public static void registerOutputParameter(String parameterLabel, Class<?> parameterClass, String processLabel) {

		registerParameter(processLabel, parameterLabel, parameterClass, REGISTER_OUTPUT_PARAMETERS_LABEL);

	}

	/**

	 * Registers a parameter for a raster process

	 */

	private static void registerParameter(String processLabel, String parameterLabel, Class<?> parameterClass, String type) {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.add(type + "_" + processLabel);

		point.append(parameterLabel, "", parameterClass);

		registerGlobalInputParameters(parameterLabel, parameterClass, processLabel);

		registerGlobalOutputParameters(parameterLabel, parameterClass, processLabel);

	}

	public static void registerGlobalInputParameters(String parameterLabel, Class<?> parameterClass, String processLabel) {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.add(REGISTER_INPUT_PARAMETERS_LABEL + "_" + processLabel);

		if(!point.has(ROI_EPSG))

			point.append(ROI_EPSG, "", String.class);

		if(!point.has(WINDOW))

			point.append(WINDOW, "", Extent.class);

		if(!point.has(OUTPUT_HEIGHT))

			point.append(OUTPUT_HEIGHT, "", Integer.class);

		if(!point.has(OUTPUT_WIDTH))

			point.append(OUTPUT_WIDTH, "", Integer.class);

		if(!point.has(PREVIEW))

			point.append(PREVIEW, "", Boolean.class);

	}

	public static void registerGlobalOutputParameters(String parameterLabel, Class<?> parameterClass, String processLabel) {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.add(REGISTER_OUTPUT_PARAMETERS_LABEL + "_" + processLabel);

		if(!point.has(TIME))

			point.append(TIME, "", Long.class);

		if(!point.has(PROCESS))

			point.append(PROCESS, "", DataProcess.class);

		if(!point.has(PROCESS_NAME))

			point.append(PROCESS_NAME, "", String.class);

	}

	/**

	 * Gets the key list of the input parameters

	 * @param processLabel

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public List<String> getRasterTaskInputParameters(String processLabel) {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.add(REGISTER_INPUT_PARAMETERS_LABEL + "_" + processLabel);

		return point.getNames();

	}

	/**

	 * Gets the key list of the output parameters

	 * @param processLabel

	 * @return

	 */

	@SuppressWarnings("unchecked")

	public List<String> getRasterTaskOutputParameters(String processLabel) {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.add(REGISTER_OUTPUT_PARAMETERS_LABEL + "_" + processLabel);

		return point.getNames();

	}

	/**

	 * Gets the class of a parameter in a process.

	 * @param processLabel

	 * @param parameterName

	 * @return

	 */

	public Class<?> getParameterTypeByProcess(String processLabel, String parameterName) {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.get(REGISTER_INPUT_PARAMETERS_LABEL + "_" + processLabel);

		return point.get(parameterName).getExtension();

	}

	/**

	 * Gets a list with the class of all parameters. 

	 * @param processLabel

	 * @param parameterName

	 * @return

	 */

	public List<Class<?>> getParameterClassList(String processLabel, String parameterName) {

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		ExtensionPoint point = extensionPoints.get(REGISTER_INPUT_PARAMETERS_LABEL + "_" + processLabel);

		List<Class<?>> classList = new ArrayList<Class<?>>();

		Iterator<?> it = point.iterator();

		while(it.hasNext()) {

			Object obj = it.next();

			classList.add((Class<?>)obj);

		}

		return classList;

	}

	@Override

	protected void finalize() throws Throwable {

		if(inputParameters != null) {

			inputParameters.clear();

			inputParameters = null;

		}

		super.finalize();

	}

	/**

	 * Add a parameter to this task at runtime. The 

	 * parameter should have been registered before add

	 * @param name key

	 * @param param object to this task

	 */

	public void addParam(String key, Object param) {

		if (param != null)

			inputParameters.put(key, param);

		else

			inputParameters.remove(key);

	}

	/**

	 * Remove a parameter to this task at runtime.

	 * @param name key

	 */

	public void removeParam(String key) {

		inputParameters.remove(key);

	}

	/**

	 * Gets a parameter from its key

	 * @param name key

	 * @return parameter

	 */

	public Object getParam(String key) {

		loadGlobalParameters();

		return inputParameters.get(key);

	}

	/**

	 * Gets a <code>String</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public String getStringParam(String key) {

		loadGlobalParameters();

		Object value = inputParameters.get(key);

		return (value != null && value instanceof String) ? (String)value : null;

	}

	/**

	 * Gets a <code>Byte</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public byte getByteParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof Byte) ? ((Byte)value).byteValue() : 0;

	}

	/**

	 * Gets a <code>Float</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public float getFloatParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof Float) ? ((Float)value).floatValue() : 0F;

	}

	/**

	 * Gets a <code>double</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public double getDoubleParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof Double) ? ((Double)value).doubleValue() : 0D;

	}

	/**

	 * Gets a <code>int</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public int getIntParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof Integer) ? ((Integer)value).intValue() : 0;

	}

	/**

	 * Gets a <code>Boolean</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public boolean getBooleanParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof Boolean) ? ((Boolean)value).booleanValue() : false;

	}

	/**

	 * Gets a <code>int[]</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public int[] getIntArrayParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof int[]) ? ((int[])value) : null;

	}

	/**

	 * Gets a <code>double[]</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public double[] getDoubleArrayParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof double[]) ? ((double[])value) : null;

	}

	/**

	 * Gets a <code>Extent</code> parameter from its key

	 * @param key

	 * @return parameter

	 */

	public Extent getExtentParam(String name) {

		loadGlobalParameters();

		Object value = inputParameters.get(name);

		return (value != null && value instanceof Extent) ? ((Extent)value) : null;

	}

	/**

	 * Gets the default EPSG for the regions of interest. If this parameter is null

	 * @return

	 */

	protected String getROIEPSG() {

		return roiEPSG;

	}

	/**

	 * Gets the bounding box defined by the user to the process

	 * @return

	 */

	protected Extent getOutputWindow() {

		return outputWindow;

	}

	/**

	 * Gets the width in pixels of the output

	 * @return

	 */

	protected int getOutputWidth() {

		return outputWidth;

	}

	/**

	 * Gets the height in pixels of the output

	 * @return

	 */

	protected int getOutputHeight() {

		return outputHeight;

	}

	/**

	 * Returns true if the output will be rescaled

	 * @return

	 */

	protected boolean isOutputRescaled() {

		return (outputWidth != 0 || outputHeight != 0);

	}

	/**

	 * Returns true if the output of this algorithm is for previews. It usually implies that the buffer will be

	 * send as output parameter, the buffer will be RGB and the input buffer will be to read and write.

	 * @return

	 */

	protected boolean isForPreviews() {

		return preview;

	}

	/**

	 * Loads global parameters defined in this class

	 */

	protected void loadGlobalParameters() {

		if(globalParametersLoaded)

			return;

		globalParametersLoaded = true;

		roiEPSG = getStringParam(ROI_EPSG);

		outputWindow = getParam(WINDOW) != null ? (Extent)getParam(WINDOW) : null;

		outputWidth = getIntParam(OUTPUT_WIDTH);

		outputHeight = getIntParam(OUTPUT_HEIGHT);

		preview = getBooleanParam(PREVIEW);

	}

}

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

import java.awt.Component;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.List;

import javax.swing.JOptionPane;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.i18n.Messages;

import org.gvsig.raster.roi.ROI;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase base de todos los procesos raster. En ella se genstionan todas las

 * funciones comunes como incremento de la tarea, gesti?n de eventos a la tarea, 

 * par?metros de la tarea, etc ...

 * 

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public abstract class ProcessUtils {

	private Logger          log          = LoggerFactory.getLogger(ProcessUtils.class);

	protected NoData        doubleNODATA = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(1, Buffer.TYPE_DOUBLE);

	/**

	 * Registra un mensaje de error en el log de gvSIG

	 * @param msg Mensaje a guardar en el log

	 * @param parent Objeto que hizo disparar el mensaje

	 * @param exception Excepcion que ha sido recogida

	 */

	public void debug(String msg, Object parent, Exception exception) {

		if(parent != null)

		    LoggerFactory

            .getLogger(parent.getClass()).debug(Messages.getText(msg), exception);

	}

	/**

	 * Shows a error dialog with a text and a accept button