Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary

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

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

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

	 * @param msg Message to show in the dialog

	 * @param parentWindow Parent window

	 */

	public void messageBoxError(String msg, Object parentWindow){

		String string = Messages.getText("accept");

		Object[] options = {string};

		JOptionPane.showOptionDialog((Component)parentWindow,

					"<html>" + Messages.getText(msg).replaceAll("\n", "<br>") + "</html>",

					Messages.getText("confirmacion"),

					JOptionPane.OK_OPTION,

					JOptionPane.ERROR_MESSAGE,

					null,

					options,

					string);

	}

	/**

	 * Muestra un dialogo de error con un texto y un bot?n de aceptar. El error es

	 * registrado en el log de gvSIG con la excepcion que se le pase por parametro

	 * @param msg Mensaje a mostrar en el dialogo.

	 * @param parentWindow Ventana desde la que se lanza el dialogo

	 * @param exception Excepcion que ha sido recogida

	 */

	public void messageBoxError(String msg, Object parentWindow, Exception exception) {

		debug(msg, parentWindow, exception);

		messageBoxError(msg, parentWindow);

	}

	/**

	 * Muestra un dialogo de error con un texto y un bot?n de aceptar. Se le pasa como ?ltimo par?metros

	 * una lista de excepciones que ser?n guardadas en el log

	 * @param msg Mensaje a mostrar en el dialogo.

	 * @param parentWindow Ventana desde la que se lanza el dialogo

	 * @param exception Excepcion que ha sido recogida

	 */

	public void messageBoxError(String msg, Object parentWindow, ArrayList<Exception> exception) {

		for (int i = 0; i < exception.size(); i++) 

			debug(msg, parentWindow, exception.get(i));

		messageBoxError(msg, parentWindow);

	}

	/**

	 * Exports a raster buffer to disk

	 * @param sFilename

	 * @param buf

	 * @param cellsize

	 * @param minX

	 * @param minY

	 * @return

	 * @throws ProviderNotRegisteredException 

	 * @throws InitializeException 

	 */

	public void exportRaster(final String sFilename, 

			Buffer buf, 

			ColorInterpretation ci,

			Extent windowExtent,

			NoData nodata,

			IProjection proj) {

		nodata.setFileName(sFilename);

		nodata.save();

		buf.setDataExtent(windowExtent.toRectangle2D());

		DataManager manager = DALLocator.getDataManager();

		String provider = "Gdal Store";

		try {

			DataServerExplorerParameters eparams = manager.createServerExplorerParameters("FilesystemExplorer");

			DataServerExplorer serverExplorer = manager.openServerExplorer(eparams.getExplorerName(), eparams);

			NewRasterStoreParameters sparams = (NewRasterStoreParameters)serverExplorer.getAddParameters(provider);

			sparams.setBuffer(buf);

			sparams.setColorInterpretation(ci.getValues());

			sparams.setProjection(proj);

			sparams.setDestination(sFilename);

			serverExplorer.add("Gdal Store", sparams, true);

		} catch (InitializeException e) {

			log.debug("Error saving the file of the process", e);

		} catch (ProviderNotRegisteredException e) {

			log.debug("Error saving the file of the process", e);

		} catch (ValidateDataParametersException e) {

			log.debug("Error saving the file of the process", e);

		} catch (DataException e) {

			log.debug("Error saving the file of the process", e);

		}

	}

	/**

	 * Exports a raster buffer to disk

	 * @param sFilename

	 * @param buf

	 * @param cellsize

	 * @param minX

	 * @param minY

	 * @return

	 * @throws ProviderNotRegisteredException 

	 * @throws InitializeException 

	 */

    public boolean exportRaster(final String sFilename, Buffer buf, double cellsize, double minX,

        double minY, NoData nodata) {

        return exportRaster(sFilename, buf, cellsize, minX, minY);

    }

    /**

     * Exports buffer to disk

     * 

     * @param sFilename

     *            Name of file to write data buffer

     * @param buf

     *            data buffer

     * @param cellsize

     *            Cell size of new raster

     * @param minX

     * @param minY

     * @param nodata

     *            No data value of new raster

     * @param proj

     *            Projection of new raster

     * @return

     */

    public boolean exportRaster(final String sFilename, Buffer buf, double cellsize, double minX,

        double minY, NoData nodata, IProjection proj) {

        boolean result = exportRaster(sFilename, buf, cellsize, minX, minY, proj);

        nodata.setFileName(sFilename);

        nodata.save();

        return result;

    }

    /**

     * Export buffer to disk

     * 

     * @param sFilename

     *            Name of raster file

     * @param buf

     *            Buffer data with new data

     * @param alphaBuffer

     *            Buffer with alpha data

     * @param cellsize

     *            Cell size of new raster

     * @param ulx

     *            X coordinate of upper left corner

     * @param uly

     *            Y coordinate of upper left corner

     * @param proj

     *            Projection of new raster

     * @return

     */

    @SuppressWarnings("deprecation")

    public boolean exportRaster(final String sFilename, Buffer buf, Buffer alphaBuffer,

        double cellsize, double ulx, double uly, IProjection proj) {

		try {

			RasterManager manager = RasterLocator.getManager();

			final DataServerWriter writerBufferServer = manager.createDataServerWriter();

			writerBufferServer.setBuffer(buf, -1);

			int nBands = buf.getBandCount();

			ColorInterpretation colorInterpretation = null;

			if(alphaBuffer != null) {

				colorInterpretation = RasterLocator.getManager().getDataStructFactory().createColorInterpretation(

						new String[] { 

								ColorInterpretation.RED_BAND, 

								ColorInterpretation.GREEN_BAND, 

								ColorInterpretation.BLUE_BAND,

								ColorInterpretation.ALPHA_BAND});

			} else {

				if(nBands == 1)

					colorInterpretation = RasterLocator.getManager().getDataStructFactory().createColorInterpretation(

							new String[] { ColorInterpretation.GRAY_BAND });

			}

			final Params params = manager.createWriterParams(sFilename);

			final AffineTransform affineTransform =

				new AffineTransform(cellsize, 0, 0,

						-cellsize, ulx, uly);

			final RasterWriter writer = manager.createWriter(

						writerBufferServer, 

						sFilename,

						nBands, 

						affineTransform, 

						buf.getWidth(),

						buf.getHeight(), 

						buf.getDataType(), 

						params, 

						proj);

			if(colorInterpretation != null)

				writer.setColorBandsInterpretation(colorInterpretation.getValues());

			writer.dataWrite();

			writer.writeClose();

		} catch (final Exception e) {

			e.printStackTrace();

			return false;

		}

		return true;

	}

    /**

     * Export buffer to disk

     * 

     * @param sFilename

     *            Name of raster file

     * @param buf

     *            Buffer data with new data

     * @param alphaBuffer

     *            Buffer with alpha data

     * @param cellsize

     *            Cell size of new raster

     * @param ulx

     *            X coordinate of upper left corner

     * @param uly

     *            Y coordinate of upper left corner

     * @return

     */

    public boolean exportRaster(final String sFilename, Buffer buf, Buffer alphaBuffer,

        double cellsize, double ulx, double uly) {

        return exportRaster(sFilename, buf, alphaBuffer, cellsize, ulx, uly, null);

    }

    /**

     * Exports raster buffer to disk

     * 

     * @param sFilename

     *            Name of raster file

     * @param buf

     *            Buffer data with new data

     * @param cellsize

     *            Cell size of new raster

     * @param ulx

     *            X coordinate of upper left corner

     * @param uly

     *            Y coordinate of upper left corner

     * @return

     */

    public boolean exportRaster(final String sFilename, Buffer buf, double cellsize, double ulx,

        double uly) {

        return exportRaster(sFilename, buf, null, cellsize, ulx, uly);

    }

    /**

     * Exports raster buffer to disk

     * 

     * @param sFilename

     *            Name of raster file

     * @param buf

     *            Buffer data with new data

     * @param cellsize

     *            Cell size of new raster

     * @param ulx

     *            X coordinate of upper left corner

     * @param uly

     *            Y coordinate of upper left corner

     * @param proj

     *            Projection of new raster

     * @return

     */

    public boolean exportRaster(final String sFilename, Buffer buf, double cellsize, double ulx,

        double uly, IProjection proj) {

        return exportRaster(sFilename, buf, null, cellsize, ulx, uly, proj);

    }

	/**

	 * Gets a list of rectangles which represents the pixel coordinates of each DataStore.

	 * This rectangle is the area that intersects with the other DataStores in the 	list.

	 * @param dataStoreList

	 * @return

	 */

	protected Rectangle2D[] getIntersectionInPxCoords(RasterDataStore[] dataStoreList) {

		Extent extentIntersect = null;

		int nRectangles = 0;

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

			if(dataStoreList[i] != null) {

				if(extentIntersect == null)

					extentIntersect = dataStoreList[i].getExtent();

				else

					extentIntersect = extentIntersect.intersection(dataStoreList[i].getExtent());

				nRectangles ++;

			}

		}

		Rectangle2D[] result = new Rectangle2D[nRectangles];

		Point2D p1 = new Point2D.Double(extentIntersect.getULX(), extentIntersect.getULY());

		Point2D p2 = new Point2D.Double(extentIntersect.getLRX(), extentIntersect.getLRY());

		int cont = 0;

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

			if(dataStoreList[i] != null) {

				Point2D init = dataStoreList[i].worldToRaster(p1);

				Point2D end = dataStoreList[i].worldToRaster(p2);

				result[cont] = new Rectangle2D.Double(

						init.getX(), 

						init.getY(), 

						Math.abs(end.getX() - init.getX()), 

						Math.abs(end.getY() - init.getY()));

				cont++;

			}

		}

		return result;

	}

	/**

	 * Checks if the point in pixel coordinates is inside the region of 

	 * interest or not. The point will be

	 * @param x 

	 * @param y

	 * @param rois

	 * @param extentResult

	 *       Bounding box of the area to which belongs the point defined in pixel coordinates (x, y)

	 * @return

	 */

	public boolean isInsideOfROI(int x, int y, List<ROI> rois, Extent extentResult) {

		if(rois == null || rois.size() == 0)

			return true;

		ROI roi = rois.get(0);

		int[] shift = getROIAnalysisShift(extentResult, roi.getStore().getExtent(), roi.getStore().getCellSize());

		for (int i = 0; i < rois.size(); i++) {

			if(rois.get(i).isInsideOfPolygon(x + shift[0], y + shift[1]))

				return true;

		}

		return false;

	}

	/**

	 * Gets the shift in pixels between the source bounding box and the result bounding box.

	 * This is useful to get if a pixel is inside a region of interest because the ROI has 

	 * associate the source. 

	 * @param extentResult

	 * @param sourceExtent

	 * @return

	 */

	private int[] getROIAnalysisShift(Extent extentResult, Extent sourceExtent, double cellsize) {

		double xDistance = Math.abs(extentResult.getULX() - sourceExtent.getULX());

		double yDistance = Math.abs(extentResult.getULY() - sourceExtent.getULY());

		return new int[]{(int)(xDistance / cellsize), (int)(yDistance / cellsize)};

	}

	/**

	 * Gets the bounding box taking into account whether there are ROIs or not

	 * @return

	 */

	public Extent getExtentResult(Extent window, List<ROI> rois, RasterDataStore store) {

		if(window != null)

			return window.intersection(store.getExtent());

		if(rois == null)

			return store.getExtent();

		else {

			Extent maxExtent = null;

			for (int i = 0; i < rois.size(); i++) {

				if(i == 0)

					maxExtent = rois.get(i).getROIExtent();

				else

					maxExtent = maxExtent.encloseBoundinBoxes(rois.get(i).getROIExtent());

			}

			return maxExtent.intersection(store.getExtent());

		}

	}

	/**

	 * Returns true if the algorithm is applied to the entire layer

	 * @param extent

	 * @param rois

	 * @param store

	 * @return

	 */

	public boolean isAnalizedEntireLayer(Extent window, List<ROI> rois, RasterDataStore store) {

		if(window == null) {

			if(rois == null || rois.size() == 0)

				return true;

		}

		return false;

	}

	/**

	 * Gets the bounding box of the source in pixel coordinates

	 * @param resultExtent

	 * @return

	 */

	public Rectangle2D getSourcePxBox(Extent resultExtent, RasterDataStore store) {

		if(resultExtent == null || resultExtent.equals(store.getExtent()))

			return new Rectangle2D.Double(0, 0, store.getWidth(), store.getHeight());

		Point2D p1 = store.worldToRaster(new Point2D.Double(resultExtent.getULX(), resultExtent.getULY()));

		Point2D p2 = store.worldToRaster(new Point2D.Double(resultExtent.getLRX(), resultExtent.getLRY()));

		return new Rectangle2D.Double(p1.getX(), p1.getY(), Math.abs(p2.getX() - p1.getX()), Math.abs(p2.getY() - p1.getY()));

	}

	/**

	 * Builds the output buffer

	 * @param sourcePxBBox

	 * @param bandCount

	 * @return

	 */

	public Buffer createOutputBuffer(int w, int h, int bandCount) {

		return createOutputBuffer(w, h, bandCount, Buffer.TYPE_DOUBLE);

	}

	public Buffer createOutputBuffer(int w, int h, int bandCount, int datatype) {

		RasterManager rManager = RasterLocator.getManager();

		BufferParam bParams = rManager.getBufferFactory().createBufferParams(

				w, 

				h, 

				bandCount, 

				datatype, 

				true);

		Buffer resultBuffer = null;

		try {

			resultBuffer = rManager.getBufferFactory().createBuffer(bParams);

		} catch (BufferCreationException e) {

			new ProcessException("Error creating the output buffer", e);

		}

		return resultBuffer;

	}

	/**

	 * Gets a data buffer from a <code>RasterDataStore</code> 

     */

    public Buffer createSourceBuffer(RasterDataStore store, Rectangle2D sourcePxBBox, boolean[] bands) throws ProcessException {

        RasterManager rManager = RasterLocator.getManager();

        RasterQuery query = rManager.createQuery();

        query.setReadOnly(true);

        int nBands = getNumberOfSelectedBands(bands);

        int count = 0;

        int[] drawableBands = new int[nBands];

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

			if(bands[i]) {

				drawableBands[count] = i;

				count ++;

			}

		}

        query.setDrawableBands(drawableBands);

        query.setAreaOfInterest(

        		new Rectangle(

        		(int)sourcePxBBox.getX(), 

        		(int)sourcePxBBox.getY(), 

        		(int)sourcePxBBox.getWidth(), 

        		(int)sourcePxBBox.getHeight()));

        try {

        	Buffer buffer = null;

        	try {

        		buffer = store.query(query);