Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.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;

/**

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

        	} catch (QueryException e) {

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

        	}  

        	return buffer;

        } catch (ProcessInterruptedException e) {

        }

        return null;

    } 

	/**

	 * Gets the number of the selected bands from a list of boolean values.

	 * Each element in this list represents a band and true or false if the band

	 * will be used in the task.

	 * @param bandsPCs

	 * @return

	 */

	private int getNumberOfSelectedBands(boolean[] b) {

		int bandCount = 0;

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

			if(b[i])

				bandCount++;

		}

        return bandCount;

	}

	/**

	 * Gets a value of the buffer in double format

	 * @param b

	 * @param row

	 * @param col

	 * @param band

	 * @return

	 */

	protected double getData(Buffer b, int row, int col, int band) {

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

			return (double)b.getElemByte(row, col, band);

		}

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

			return b.getElemDouble(row, col, band);

		}

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

			return (double)b.getElemFloat(row, col, band);

		}

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

			return (double)b.getElemInt(row, col, band);

		}

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

			return (double)b.getElemShort(row, col, band);

		}

		return doubleNODATA.getValue().doubleValue();

	}

}