Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.principalcomponents.algorithm;

import java.awt.geom.Point2D;

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    ROI_EPSG           = "ROI_EPSG";

        public static final String    EXTENT             = "EXTENT";

        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 String                roiEPSG            = 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(ROI_EPSG, 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);

                roiEPSG = getStringParam(ROI_EPSG);

        }

        /**

         * Gets the bounding box of the source in pixel coordinates

         * @param ext

         * @return

         */

        private Rectangle2D getSourcePxBox(Extent ext) {

                if(rois == null)

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

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

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

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

        }

        public void process() throws ProcessInterruptedException, ProcessException {

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

                try {

                        if (store == null)

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

                        if(roiEPSG != null) {

                                try {

                                        rois = store.getRois(roiEPSG);

                                } 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(null, rois, store);

                        Rectangle2D sourcePxBBox = getSourcePxBox(extentResult);

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

                        addOutputValue(FILENAME, filename);

                        addOutputValue(GRAPHIC_DATA, filename);

                } catch (PrincipalComponentsException e) {

                        if (incrementableTask != null)

                                incrementableTask.processFinalize();

                        messageBoxError("...", 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("...");

        }

}