Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.principalcomponents.algorithm.PrincipalComponentsAlgorithmLibrary

layers_dont_intersect=Las capas no intersectan

roi_not_inside=La zona de estudio no esta contenida en la extensi?n de las capas

calc_stats="Calculando estad?sticas para PCA"

error_covarianza_optimize="Error en el covarianceOptimize() : C?lculo de la matriz varianza covarianza de las bandas de un Grid."

preparing_buffers=Preparando buffers

writting_in_buffer=Escribiendo en buffer de salida

processing_pc=Procesando Componentes Principales

principal_components=Componentes Principales

layers_dont_intersect=Layers do not intersect

roi_not_inside=The region of interest are not inside the extension of the layers

calc_stats="Calculating statistics to PCA"

error_covarianza_optimize="Error in covarianceOptimize."

preparing_buffers=Preparing buffers

writting_in_buffer=Writing in the output buffer

processing_pc=Processing Principal Components

principal_components=Principal Components

package org.gvsig.raster.principalcomponents.algorithm;

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

/**

 * This exception is thrown if happen problems processing data with this algorithm.

 */

public class PrincipalComponentsException extends ProcessException {

	private static final long serialVersionUID = -3022090543908771484L;

	public PrincipalComponentsException(String msg){

		super(msg);

	}

	public PrincipalComponentsException(String msg, Throwable e){

		super(msg, e);

	}

}

package org.gvsig.raster.principalcomponents.algorithm;

import java.awt.geom.Rectangle2D;

import java.util.List;

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

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

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

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

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

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

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

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

import org.gvsig.i18n.Messages;

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

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

import org.gvsig.raster.roi.ROI;

import Jama.Matrix;

/**

 * PCA Process 

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

 */

public class PrincipalComponentsProcess extends DataProcess {

	public static String          RASTER_STORE       = "RASTER_STORE";

	public static String          PATH               = "PATH";

	public static String          FILENAME           = "FILENAME";

	public static final String    BUFFERS            = "BUFFERS";

	public static final String    SELECTEDPCS        = "SELECTEDPCS";

	public static final String    PCSTATISTICS       = "PCSTATISTICS";

	public static final String    GRAPHIC_DATA       = "GRAPHIC_DATA";

	public static final String    BANDS              = "BANDS";

	private RasterDataStore       store              = null;

	private String                filename           = null;

	private PCStatsDataStructure  pcStatistics       = null;

	private List<ROI>             rois               = null;

	private Extent                extentResult       = null;

	private boolean[]             selectedPCs        = null;

	private boolean[]             bands              = null;

	private int[]                 selectedBands      = null;

	private NoData                nodata             = null;

	public static void registerParameters() {

		registerInputParameter(RASTER_STORE, RasterDataStore.class, PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

		registerInputParameter(PCSTATISTICS, PCStatsDataStructure.class, PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

		registerInputParameter(PATH, String.class, PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

		registerInputParameter(SELECTEDPCS, Boolean[].class, PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

		registerInputParameter(BANDS, Boolean[].class, PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

		registerOutputParameter(FILENAME, String.class, PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

		registerOutputParameter(GRAPHIC_DATA, Double[].class, PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

	}

	public void init() {

		store = getParam(RASTER_STORE) != null ? (RasterDataStore)getParam(RASTER_STORE) : null;

		filename = getStringParam(PATH);

		selectedPCs = (boolean[]) getParam(SELECTEDPCS);

		bands = (boolean[]) getParam(BANDS);

		pcStatistics = (PCStatsDataStructure) getParam(PCSTATISTICS);

	}

	public void process() throws ProcessInterruptedException, ProcessException {

		insertLineLog(Messages.getText("processing_pc"));

		try {

			if (store == null)

				throw new PrincipalComponentsException(Messages.getText("need_a_input"));

			if(getROIEPSG() != null) {

				try {

					rois = store.getRois(getROIEPSG());

				} catch (ROIException e2) {

					logger.error(Messages.getText("error_getting_rois"), e2);

				}

			}

			try {

				store = ((RasterDataStore)store).cloneDataStore();

			} catch (CloneException e) {

				new PrincipalComponentsException("Error cloning the input DataStore", e);

			}

			extentResult = getExtentResult(getOutputWindow(), rois, store);

			Rectangle2D sourcePxBBox = getSourcePxBox(extentResult, store);

			double cellSize = store.getCellSize();

			nodata = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(1, Buffer.TYPE_DOUBLE);

			double nodataValue = nodata.getValue().doubleValue();

			int numberOfOutputBands = getNumberOfOutputBands(selectedPCs);

			Buffer outputBuffer = createOutputBuffer((int)sourcePxBBox.getWidth(), (int)sourcePxBBox.getHeight(), numberOfOutputBands);

			Buffer sourceBuffer = createSourceBuffer(store, sourcePxBBox, bands);

			// Matriz Autovectores

			// Colocamos la matriz en el orden correcto:

			/*

			 * b3 b2 b1 c1 c2 c3 | | | | Cambio de orden de columnas de la matriz

			 * transpuesta ___ \ / V c1 c2 c3 b1 b2 b3

			 */

			Matrix autovect = changeColumns((pcStatistics.getAutoVectorsMatrix().transpose()));

			insertLineLog(Messages.getText("writting_in_buffer"));

			for (int i = 0; i < sourceBuffer.getHeight(); i++) {

				for (int j = 0; j < sourceBuffer.getWidth(); j++) {

					if (isInsideOfROI(j, i, rois, extentResult)) {

						for (int iComponent = 0; iComponent < sourceBuffer.getBandCount(); iComponent++) {

							if(selectedPCs[iComponent]) {

								double valor = 0;

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

									valor += getData(sourceBuffer, i, j, iBand) * autovect.get(iBand, iComponent);

								}

								int indexBandResult = indexBandResult(selectedPCs, iComponent);

								outputBuffer.setElem(i, j, indexBandResult, (double) valor);

							}

						}

					} else {

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

							outputBuffer.setElem(i, j, iBand, nodataValue);

						}

					}

				}

				updatePercent((int)(i * 100 / sourcePxBBox.getHeight()), 100);

			}

            super.exportRaster(filename, outputBuffer, cellSize, extentResult.getULX(),

                extentResult.getULY(), nodata, store.getProjection());

			addOutputValue(FILENAME, filename);

			addOutputValue(GRAPHIC_DATA, filename);

		} catch (PrincipalComponentsException e) {

			if (incrementableTask != null)

				incrementableTask.processFinalize();

			messageBoxError("principal_components", null, e);

		}

	}

	/**

	 * Gets the number of the selected bands

	 * @param bandsPCs

	 * @return

	 */

	private int getNumberOfOutputBands(boolean[] b) {

		int bandCount = 0;

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

			if(b[i])

				bandCount++;

		}

        return bandCount;

	}

	/**

	 * Gets the band index of the result buffer 

	 * @param bandsPCs

	 * @param indexIn

	 * @return

	 */

	private int indexBandResult(boolean[] bandsPCs, int indexIn) {

		if(selectedBands == null) {

			selectedBands = new int[bandsPCs.length];

			int indexOut = 0;

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

				if(bandsPCs[i]) {

					selectedBands[i] = indexOut;

					indexOut++;

				} else

					selectedBands[i] = -1;

			}

		}

		return selectedBands[indexIn];

	}

	public double getScaleFactor(Buffer buffer, int sizePreview) {

		double x = 0, y = 0;

		x = 200.0 / buffer.getWidth();

		y = 200.0 / buffer.getHeight();

		if (x > y) {

			return y;

		} else {

			return x;

		}

	}

	private Matrix changeColumns(Matrix m) {

		Matrix result = new Matrix(m.getRowDimension(), m.getColumnDimension());

		int k = m.getColumnDimension() - 1;

		for (int i = 0; i < m.getRowDimension(); i++) {

			for (int j = 0; j < m.getColumnDimension(); j++) {

				result.set(i, j, m.get(k - i, j));

			}

		}

		return result;

	}

	public String getTitle() {

		return Messages.getText("...");

	}

}

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

import Jama.Matrix;

/**

 * Represents statistics needed to generate a transformated raster by PCA method

 * @author seriznue

 */

public class PCStatsDataStructure {

	private Matrix 			autoVectorsMatrix 	= null;

	private Matrix 			coVarMatrix 		= null;

	private double			autovalues[]		= null;

	private double[][]      maxminmean			= null;

	/**

	 * Constructor.

	 * 

	 * @param autoVectorsMatrix Matrix of autovectors.

	 * @param autovalues Array of eigenvalues.

	 * @param coVarMatrix Matrix of Covariance.

	 */

	public PCStatsDataStructure(Matrix autoVectorsMatrix, double[] autovalues, Matrix coVarMatrix) {

		this.autoVectorsMatrix = autoVectorsMatrix;

		this.autovalues = autovalues;

		this.coVarMatrix = coVarMatrix;

	}

	public Matrix getAutoVectorsMatrix() {

		return autoVectorsMatrix;

	}

	public void setAutoVectorsMatrix(Matrix autoVectorsMatrix) {

		this.autoVectorsMatrix = autoVectorsMatrix;

	}

	public double[][] getMaxMinMean() {

		return maxminmean;

	}

	public void setMaxMinMean(double[][] maxminmean) {

		this.maxminmean = maxminmean;

	}

	public Matrix getCoVarMatrix() {

		return coVarMatrix;

	}

	public void setCoVarMatrix(Matrix coVarMatrix) {

		this.coVarMatrix = coVarMatrix;

	}

	public double[] getAutovalues() {

		return autovalues;

	}

	public void setAutovalors(double[] autovalors) {

		this.autovalues = autovalors;

	}

}

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

import java.awt.geom.Rectangle2D;

import java.util.List;

import org.cresques.Messages;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.raster.roi.ROI;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import Jama.EigenvalueDecomposition;

import Jama.Matrix;

/**

 * This Process computes a <code>PCStatsDataStructure</code> Object from bands of two images in a study zone.

 * <code>PCStatsDataStructure</code> is a object that contains the needed statistics to Principal Components decomposition

 * of images.

 * 

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

 * 

 */

public class PCAStatisticsProcess extends DataProcess {

    public static final String 	 LAYER_ZONA_ESTUDIO 			= "LAYER_ZONA_ESTUDIO";

    public static String         BANDS 							= "BANDS";

    public static String         PATH 							= "PATH";

    public static String         ROI_EPSG                       = "ROI_EPSG";

    public static String         WINDOW                         = "WINDOW";

	public static String         RASTER_STORE                   = "RASTER_STORE";

	public static String         STATS_RESULT                   = "STATS_RESULT";

    private boolean[] 			 bands 							= null;

    private RasterDataStore      store 							= null;

    private Buffer               buffer 						= null;

    private Buffer               roiBuffer 						= null;

    private boolean              roiBufferCalculated            = false;

	private double				 autovalors[]					= null;

	private Matrix 				 coVarMatrix					= null;

	private Matrix 				 autoVectorMatrix				= null;

	private double 				 coVar[][] 						= null;

	private static Logger 		 logger    		   				= LoggerFactory.getLogger(PCAStatisticsProcess.class.getName());

    private double[][] 			 maxminmean						= null;

    private	Extent 				 extentResult					= null; 

    private String               path                           = null;

    private List<ROI>            rois                           = null;

    private boolean[]            statsByBandCalculated          = null;

	public static void registerParameters() {

		registerInputParameter(RASTER_STORE, RasterDataStore.class, PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

		registerInputParameter(BANDS, Boolean[].class, PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

		registerInputParameter(PATH, String.class, PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

		registerOutputParameter(STATS_RESULT, PCStatsDataStructure.class, PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

		registerOutputParameter(PATH, String.class, PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

		registerOutputParameter(BANDS, Boolean[].class, PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

		registerOutputParameter(ROI_EPSG, String.class, PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

	}

	@Override

	public void init() {

		store = (RasterDataStore)getParam(RASTER_STORE);

		bands = (boolean[])getParam(BANDS);

		path = getStringParam(PATH);

	}

	public double[] getAutoValors() {

		return  autovalors;

	}

	/**

	 * @return Autovectors Matrix

	 */

	public Matrix getAutoVectorMatrix() {

		return autoVectorMatrix;

	}

	/**

	 * @return Varianze-covarianze Matrix

	 */

	public Matrix getcoVarMatrix() {

		return coVarMatrix;

	}

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

		if(roiBufferCalculated)

			return (roiBuffer.getElemByte(y, x, 0) == 1);

		if(roiBuffer == null)

			roiBuffer = createOutputBuffer(buffer.getWidth(), buffer.getHeight(), 1, Buffer.TYPE_BYTE);

		boolean a = super.isInsideOfROI(x, y, rois, extentResult);

		roiBuffer.setElem(y, x, 0, a ? (byte)1: (byte)0);

		return a;

	}

	/**

	 * Calculate the Varianze-covarianze Matrix from bands of a Grid

	 * @throws InterruptedException 

	 * @throws ProcessInterruptedException 

	 */

	private double[][] covarianceOptimize() throws InterruptedException, ProcessInterruptedException {

        //NoData

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

        double nodata = nd.getValue().doubleValue();

		double dSum = 0;

		int iValues = 0;

		double[][] coV = new double[buffer.getBandCount()][buffer.getBandCount()];

		double valorBandai = 0, valorBandaj = 0;

		maxminmean = new double[buffer.getBandCount()][4];

		statsByBandCalculated = new boolean[buffer.getBandCount()];

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

			statsByBandCalculated[i] = false;

		}

		loadDataStoreStatistics();

		int percent = 0;

		int maxCounter = 0;

		for (int i = buffer.getBandCount(); i >= 0; i--) {

			maxCounter += i;

		}

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

			double meanBufferToOperatei = getMeanValue(i, buffer);

			for (int j = i; j < buffer.getBandCount(); j++) {

				iValues = 0;

				dSum = 0;

				double meanBufferToOperatej = getMeanValue(j, buffer);

				for (int row = 0; row < buffer.getHeight(); row++) {

					for (int col = 0; col < buffer.getWidth(); col++) {

						if(isInsideOfROI(col, row, rois, extentResult)) {

							valorBandai = getData(buffer, row, col, i) - meanBufferToOperatei;

							valorBandaj = getData(buffer, row, col, j) - meanBufferToOperatej;

							dSum += valorBandai * valorBandaj;

							iValues++;

						}

					}

					updatePercent(percent, maxCounter);

				}

				roiBufferCalculated = true;

				// Asigno el valor a la matriz 

				if (iValues > 1)

					coV[i][j] = dSum / (double)(iValues);	

				else

					coV[i][j] = nodata;

				percent ++;

				updatePercent(percent, maxCounter);

			}

		}

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

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

				if(j < i)

					coV[i][j] = coV[j][i];

			}

		}

		return coV;

	}

//	 * Devuelve la media de los valores de los pixeles de un buffer incluidos en la zona de estudio

	/**

	 * Get the mean of values of pixels from a buffer in a study zone

	 * @param bufferToOperate

	 * @return

	 */

	private double getMeanValue(int band, Buffer bufferToOperate) {

		if(statsByBandCalculated[band])

			return maxminmean[band][2];

		double mean = 0;

		double variance = 0;

		double min = Double.MAX_VALUE;

		double max = Double.MIN_VALUE;

		int valuesCounter = 0;

		for (int j = 0; j < bufferToOperate.getHeight(); j++) {

			for (int i = 0; i < bufferToOperate.getWidth(); i++) {

				if (isInsideOfROI(i, j, rois, extentResult)) {

					double value = getData(bufferToOperate, j, i, band);

					if(value < min) {

						min = value;

					}

					if(value > max) {

						max = value;

					}

					mean += value;

					variance += value * value;

					valuesCounter++;

				}

			}

		}

		roiBufferCalculated = true;

		mean = (mean / valuesCounter);

		variance = variance / (double) valuesCounter - mean * mean;

		maxminmean[band][0] = max;

		maxminmean[band][1] = min;

		maxminmean[band][2] = mean;

		maxminmean[band][3] = variance;

		statsByBandCalculated[band] = true;

		return mean;

	}

	private void loadDataStoreStatistics() {

		if(isAnalizedEntireLayer(getOutputWindow(), rois, store) && store.getStatistics().isCalculated()) {

			double[] max = store.getStatistics().getMax();

			double[] min = store.getStatistics().getMin();

			double[] mean = store.getStatistics().getMean();

			double[] variance = store.getStatistics().getVariance();

			int iBand = 0;

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

				if(bands[i]) {

					maxminmean[iBand][0] = max[i];

					maxminmean[iBand][1] = min[i];

					maxminmean[iBand][2] = mean[i];

					maxminmean[iBand][3] = variance[i];

					statsByBandCalculated[iBand] = true;

					iBand ++;

				}

			}

		}

	}

	@Override

	public void process() throws ProcessInterruptedException, ProcessException {

		insertLineLog(Messages.getText("preparing_buffers"));

		if(getROIEPSG() != null) {

			try {

				rois = store.getRois(getROIEPSG());

			} catch (ROIException e2) {

				logger.error(Messages.getText("error_getting_rois"), e2);

			}

		}

		try {

			store = store.cloneDataStore();

		} catch (CloneException e1) {

			throw new ProcessException("Error cloning the sources", e1);

		}

		//Calculo de datos de entrada

		extentResult = getExtentResult(getOutputWindow(), rois, store);

		Rectangle2D sourcePxBBox = getSourcePxBox(extentResult, store);

		buffer = createSourceBuffer(store, sourcePxBBox, bands);

		insertLineLog(Messages.getText("calc_stats"));

		try {

			coVar = covarianceOptimize();

		} catch (InterruptedException e) {

			logger.error(Messages.getText("error_covarianza_optimize"), e);

		}

		// Calculo de autovectores:

		coVarMatrix = new Matrix(coVar);

		EigenvalueDecomposition eigenvalueDecomp = new EigenvalueDecomposition(coVarMatrix); 

		//Autovectores

		autoVectorMatrix = eigenvalueDecomp.getV();

		// Autovalores

		autovalors = eigenvalueDecomp.getRealEigenvalues();	

		PCStatsDataStructure resultStatistics = new PCStatsDataStructure(autoVectorMatrix, autovalors, coVarMatrix);

		resultStatistics.setMaxMinMean(maxminmean);

		roiBuffer.dispose();

		//Object[] dataROI = new Object[]{vectROI, (int)shift[0].getX(), (int)shift[0].getY()};	

		addOutputValue(STATS_RESULT, resultStatistics);

		addOutputValue(PATH, path);

		addOutputValue(BANDS, bands);

		addOutputValue(ROI_EPSG, getROIEPSG());

		try {

			store.close();

		} catch (CloseException e) {

			throw new ProcessException("Error closing the sources", e);

		}

	}

	public String getTitle() {

		return null;

	}

}

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

import Jama.Matrix;

/**

 * Represents statistics needed to generate a transformated raster by PCA method

 * @author seriznue

 */

public class PCStatistics {

	private Matrix 			autoVectorsMatrix 	= null;

	private Matrix 			coVarMatrix 		= null;

	private double			autovalues[]		= null;

	/**

	 * Constructor.

	 * 

	 * @param autoVectorsMatrix Matrix of autovectors.

	 * @param autovalues Array of eigenvalues.

	 * @param coVarMatrix Matrix of Covariance.

	 */

	public PCStatistics(Matrix autoVectorsMatrix, double[] autovalues, Matrix coVarMatrix) {

		this.autoVectorsMatrix = autoVectorsMatrix;

		this.autovalues = autovalues;

		this.coVarMatrix = coVarMatrix;

	}

	public Matrix getAutoVectorsMatrix() {

		return autoVectorsMatrix;

	}

	public void setAutoVectorsMatrix(Matrix autoVectorsMatrix) {

		this.autoVectorsMatrix = autoVectorsMatrix;

	}

	public Matrix getCoVarMatrix() {

		return coVarMatrix;

	}

	public void setCoVarMatrix(Matrix coVarMatrix) {

		this.coVarMatrix = coVarMatrix;

	}

	public double[] getAutovalues() {

		return autovalues;

	}

	public void setAutovalors(double[] autovalors) {

		this.autovalues = autovalors;

	}

}

package org.gvsig.raster.principalcomponents.algorithm;

import org.gvsig.i18n.Messages;

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 * Initialization of PrincipalComponentsAlgorithmLibrary library.

 */

public class PrincipalComponentsAlgorithmLibrary extends AbstractLibrary {

	public static final String         PC_PROCESS_LABEL         = "PrincipalComponentsProcess";

	public static final String         PC_STATS_PROCESS_LABEL   = "StatsPrincipalComponentsProcess";

    @Override

    protected void doInitialize() throws LibraryException {

        // Nothing to do

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

    	//Registers the process and its parameters

    	RasterBaseAlgorithmLibrary.register(PC_STATS_PROCESS_LABEL, PCAStatisticsProcess.class);

    	PCAStatisticsProcess.registerParameters();

    	RasterBaseAlgorithmLibrary.register(PC_PROCESS_LABEL, PrincipalComponentsProcess.class);

    	PrincipalComponentsProcess.registerParameters();

        Messages.addResourceFamily(

            "org.gvsig.raster.principalcomponents.algorithm", 

            PrincipalComponentsAlgorithmLibrary.class.getClassLoader(), 

            PrincipalComponentsAlgorithmLibrary.class.getClass().getName());

        //registerGeoProcess(new RasterReprojectAlgorithmLibrary());

        Messages.addResourceFamily("org.gvsig.raster.principalcomponents.algorithm.i18n.text",

        		PrincipalComponentsAlgorithmLibrary.class.getClassLoader(),

        		PrincipalComponentsAlgorithmLibrary.class.getClass().getName()); 

    }

}

layers_dont_intersect=Layers do not intersect

roi_not_inside=The region of interest are not inside the extension of the layers

calc_stats="Calculating statistics to PCA"

error_covarianza_optimize="Error in covarianceOptimize."

preparing_buffers=Preparing buffers

layers_dont_intersect=Las capas no intersectan

roi_not_inside=La zona de estudio no esta contenida en la extensi?n de las capas

calc_stats="Calculando estad?sticas para PCA"

error_covarianza_optimize="Error en el covarianceOptimize() : C?lculo de la matriz varianza covarianza de las bandas de un Grid."

preparing_buffers=Preparando buffers

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.raster.principalcomponents.algorithm</artifactId>

	<packaging>jar</packaging>

	<name>org.gvsig.raster.principalcomponents.algorithm</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.raster.principalcomponents</artifactId>

		<version>2.2.83</version>

	</parent>

    <dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.raster.algorithm</artifactId>

            <scope>compile</scope>

		</dependency>

		<dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.i18n</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.ui</artifactId>

            <scope>compile</scope>

        </dependency>

        		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.raster.lib.api</artifactId>

            <scope>compile</scope>

		</dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.lib.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.raster.fmap</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.api</artifactId>

            <scope>compile</scope>

        </dependency>

    <!--

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.generalpath</artifactId>

            <scope>runtime</scope>

        </dependency>

    -->

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.se</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection.cresques.impl</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.lib</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.spi</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

			<groupId>org.gvsig.legacy</groupId>

			<artifactId>jama</artifactId>

			<scope>compile</scope>

		</dependency>

	</dependencies>

</project>

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.raster.principalcomponents.swing</artifactId>

	<packaging>pom</packaging>

	<name>org.gvsig.raster.principalcomponents.swing</name>

	<parent>