| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

package org.gvsig.raster.grid.filter.enhancement;

import org.gvsig.raster.dataset.IBuffer;

/**

 * Filtro de ecualizaci?n de histograma para tipo de datos short.

 *

 * @version 11/05/2007

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

 */

public class EcualizationShortFilter extends EqualizationFilter {

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.grid.filter.enhancement.LinearEnhancementFilter#process(int, int)

	 */

	public void process(int col, int line) {

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

			short p = raster.getElemShort(line, col, iBand);

			if(!equalizationActive(iBand)) {

				rasterResult.setElem(line, col, iBand, p);

				continue;

			}

			if (p > maxBandValue[renderBands[iBand]])

				p = (short) maxBandValue[renderBands[iBand]];

			else if (p < minBandValue[renderBands[iBand]])

				p = (short) minBandValue[renderBands[iBand]];

			int ecualizationPositive = (int)(aproximation[renderBands[iBand]][p % nClasses] * nClasses);

			int ecualizationNegative = (int)(aproximationNeg[renderBands[iBand]][nElements - (p  % nClasses)] * nClasses);

			double value = ((nElements - ecualizationNegative) + ecualizationPositive) / 2;

			rasterResult.setElem(line, col, iBand, (short)value);

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.grid.filter.enhancement.LinearEnhancementFilter#getInRasterDataType()

	 */

	public int getInRasterDataType() {

		return IBuffer.TYPE_SHORT;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.grid.filter.RasterFilter#getOutRasterDataType()

	 */

	public int getOutRasterDataType() {

		return IBuffer.TYPE_SHORT;

	}

}

	protected double[][]               aproximation       = null;

	protected int[]                    minValueToEcualize = null;

	protected int[]                    maxValueToEcualize = null;

//	protected long[][]                 lahe               = null;

//	protected long[][]                 laheNegative       = null;

		if(histogram == null)

			return;

		minValueToEcualize = (int[]) params.get("minValueToEcualize");

		maxValueToEcualize = (int[]) params.get("maxValueToEcualize");

		minValueToEcualize = new int[]{20, 20, 20};

		maxValueToEcualize = new int[]{180, 180, 180};

		//Si no se han pasado valores m?ximos o m?nimos para aplicar la ecualizaci?n se aplica

		//directamente los m?ximos y m?nimos globales.

		if(maxValueToEcualize == null) {

			maxValueToEcualize = new int[maxBandValue.length];

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

				maxValueToEcualize[i] = (int)maxBandValue[i];

		}

		if(minValueToEcualize == null) {

			minValueToEcualize = new int[minBandValue.length];

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

				minValueToEcualize[i] = (int)minBandValue[i];

		}

		double[][] probabilityDistrib = null;

		if(raster.getDataType() == IBuffer.TYPE_BYTE)

			probabilityDistrib = getProbabilityDistribution(raster.getBandCount(), 255);

		else

			probabilityDistrib = getProbabilityDistribution(raster.getBandCount(), nClasses);

		aproximation = calcApproximation(accumNormalize, probabilityDistrib);

		aproximationNeg = calcApproximation(accumNormalizeNeg, probabilityDistrib);

		nElements = (aproximation[0].length - 1);

//		lahe = lahe(accumNormalize, 255);

//		laheNegative = lahe(accumNormalizeNeg, 255);

//		nElements = (laheNegative[0].length - 1);

//	private long[][] lahe(double[][] accumNorm, int value) {

//		long[][] res = new long[accumNorm.length][accumNorm[0].length];

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

//			  for (int j = 0; j < res[i].length; j++) 

//				  res[i][j] = Math.round(accumNorm[i][j] * value);

//		return res;

//	}

	/**

	 * Obtiene una distribuci?n de probabilidad de niveles de gris.  

	 * @param bands N?mero de bandas

	 * @param nValues Valores a distribuir. Tipicamente 255

	 * @return 

	 */

	private double[][] getProbabilityDistribution(int bands, double nValues) {

		double[][] res = new double[bands][(int)nValues];

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

			for (int j = 0; j < res[i].length; j++) 

				res[i][j] += (double)((double)j / nValues);

		return res;

	}

	/**

	 * Calcula un histograma aproximado ecualizado. Busca para cada valor del histograma acumulado

	 * normalizado el valor m?s cercano que hay en la distribuci?n de probabilidades. Con estos datos

	 * crea un array donde cada valor es el nuevo nivel de gris de esa posici?n.

	 * @param accumNorm

	 * @param distrib

	 * @return

	 */

	private double[][] calcApproximation(double[][] accumNorm, double[][] distrib) {

		double[][] res = new double[accumNorm.length][accumNorm[0].length];

		resValues = new int[accumNorm.length][accumNorm[0].length];

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

			for (int j = 0; j < accumNorm[i].length; j++) {

				double[] v = searchProbability(distrib[i], accumNorm[i][j]);

				if(v != null) {

					res[i][j] = v[0];

					resValues[i][j] = (int)v[1];

				}

			}

		}

		return res;

	}

	/**

	 * En un array de distribuci?n de probabilidades busca la m?s cercana

	 * al valor pasado

	 * @param distrib Array de probabilidades

	 * @param value Valor a buscar en el array

	 * @return valor m?s cercano en el array y posici?n del mismo

	 */

	private double[] searchProbability(double[] distrib, double value) {

		double dif = Math.abs(distrib[0] - value);

		for (int i = 1; i < distrib.length; i++) {

			double newDif = Math.abs(distrib[i] - value);

			if(newDif < dif)

				dif = newDif;

			else

				return new double[]{distrib[i - 1], i - 1};

		}

		return new double[]{distrib[distrib.length - 1], distrib.length - 1};

	}

		return "radiometricos";

		return false;

			//long ecualizationPositive = lahe[renderBands[iBand]][p % histogram.getNumValues()];

			//long ecualizationNegative = laheNegative[renderBands[iBand]][nElements - (p % histogram.getNumValues())];

			if(p >= minValueToEcualize[iBand] && p <= maxValueToEcualize[iBand]) {

				int ecualizationPositive = (int)(aproximation[renderBands[iBand]][p] * 255);

				int ecualizationNegative = (int)(aproximationNeg[renderBands[iBand]][nElements - p] * 255);

				double value = ((nElements - ecualizationNegative) + ecualizationPositive) / 2;

				rasterResult.setElem(line, col, iBand, (byte)value);

			} else

				rasterResult.setElem(line, col, iBand, (byte)p);