Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.principalcomponents;

import java.util.HashMap;

import java.util.List;

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

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

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

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

import org.gvsig.geoprocess.lib.sextante.AbstractSextanteGeoProcess;

import org.gvsig.geoprocess.lib.sextante.dataObjects.FLyrRasterIRasterLayer;

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

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

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

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

import org.gvsig.raster.fmap.layers.FLyrRaster;

import org.gvsig.raster.principalcomponents.algorithm.PCStatsDataStructure;

import org.gvsig.raster.principalcomponents.algorithm.PrincipalComponentsAlgorithmLibrary;

import org.gvsig.raster.principalcomponents.algorithm.PrincipalComponentsProcess;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

/**

 * ...

 */

public class PrincipalComponentsSextanteAlgorithm extends AbstractSextanteGeoProcess implements IProcessActions {

    public static final String RESULT            = "RESULT";

    public static final String LAYER             = PrincipalComponentsProcess.RASTER_STORE;

    public static final String USE_ROI           = "USE_ROI";

    private boolean            useROI            = false;

    private DataProcess        taskStats         = null;

    private DataProcess        taskPC            = null;

    public void defineCharacteristics() {

        setName(getTranslation("principalcomponents"));

        setGroup(getTranslation("multispectral"));

        try {

            m_Parameters.addInputRasterLayer(LAYER, getTranslation("Input_layer"), true);

            m_Parameters.addBoolean(USE_ROI, getTranslation("use_roi"), false);

        } catch (RepeatedParameterNameException e) {

            Sextante.addErrorToLog(e);

        }

        addOutputRasterLayer(RESULT, getTranslation("principalcomponents"));

    }

    public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

            if(existsOutPutFile(PrincipalComponentsSextanteAlgorithm.RESULT, 0)) {

                    throw new GeoAlgorithmExecutionException(getTranslation("file_exists"));

            }

            IRasterLayer input = m_Parameters.getParameterValueAsRasterLayer(LAYER);

                useROI = m_Parameters.getParameterValueAsBoolean(USE_ROI);

            FLyrRaster lyrRaster = ((FLyrRaster)input.getBaseDataObject());

            IRasterLayer output = null;

            output = getNewRORasterLayer(

                            RESULT,

                            Sextante.getText("principalcomponents_description"),

                            input.getDataType(),

                            input.getBandsCount());

            String fileName = ((FLyrRasterIRasterLayer)output).getName();

            try {

                    setProgressText(getTranslation("stadistics"));

                        taskStats = createStatisticsProcess(lyrRaster.getDataStore());

                        taskStats.execute();

                        HashMap<String, Object> params = taskStats.getResult();

                        PCStatsDataStructure stats = (PCStatsDataStructure)params.get("STATS_RESULT");

                        setProgressText(getTranslation("calc_components"));

                        taskPC = createPCAProcess(lyrRaster.getDataStore(), fileName, stats);

                        taskPC.execute();

                        params = taskPC.getResult();

                        ((FLyrRasterIRasterLayer)output).setBaseDataObject(fileName);

                } catch (ProcessInterruptedException e) {

                        Sextante.addErrorToLog(e);

                } catch (ProcessException e) {

                        Sextante.addErrorToLog(e);

                }

                if(getTaskMonitor().isCanceled())

                        return false;

        return true;

    }

    /**

     * Creates a process to calculate statistics

     * @param inputStore

     * @return

     * @throws ProcessException

     */

    private DataProcess createStatisticsProcess(RasterDataStore inputStore) throws ProcessException {

            DataProcess taskStats = RasterBaseAlgorithmLibrary.getManager().createRasterTask(PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

            taskStats.setActions(this);

            List<String> params = taskStats.getRasterTaskInputParameters(PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL);

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

                    String paramName = params.get(i);

                    Class<?> paramType = taskStats.getParameterTypeByProcess(PrincipalComponentsAlgorithmLibrary.PC_STATS_PROCESS_LABEL, paramName);

                    if(paramType == RasterDataStore.class) {

                            taskStats.addParam(paramName, (RasterDataStore)inputStore);

                    }

                    if(paramName.equals("BANDS")) {

                            boolean[] bands = new boolean[inputStore.getBandCount()];

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

                                        bands[j] = true;

                                }

                            taskStats.addParam(paramName, bands);

                    }

                    if(paramName.equals("ROI_EPSG") && useROI) {

                            taskStats.addParam(paramName, "EPSG:4326");

                    }

                    if(paramName.equals("WINDOW")) {

                            AnalysisExtent ext = getAnalysisExtent();

                            Extent bbox = RasterLocator.getManager().getDataStructFactory().createExtent(

                                            ext.getXMin(), ext.getYMax(), ext.getXMax(), ext.getYMin());

                            Extent inputBbox = inputStore.getExtent();

                            if(bbox.getULX() != inputBbox.getULX() ||

                                    bbox.getULY() != inputBbox.getULY() ||

                                    bbox.getLRX() != inputBbox.getLRX() ||

                                    bbox.getLRY() != inputBbox.getLRY()) {

                                    taskStats.addParam(paramName, bbox);

                            }

                    }

            }

            return taskStats;

    }

    private DataProcess createPCAProcess(RasterDataStore inputStore, String fileName, PCStatsDataStructure stats) throws ProcessException {

            DataProcess taskPC = RasterBaseAlgorithmLibrary.getManager().createRasterTask(PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

            taskPC.setActions(this);

            List<String> params = taskPC.getRasterTaskInputParameters(PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL);

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

                    String paramName = params.get(i);

                    Class<?> paramType = taskPC.getParameterTypeByProcess(PrincipalComponentsAlgorithmLibrary.PC_PROCESS_LABEL, paramName);

                    if(paramType == RasterDataStore.class) {

                            taskPC.addParam(paramName, (RasterDataStore)inputStore);

                    }

                        if(paramType == Boolean[].class) {

                            boolean[] bands = new boolean[inputStore.getBandCount()];

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

                                        bands[j] = true;

                                }

                            taskPC.addParam(paramName, bands);

                        }

                        if(paramType == PCStatsDataStructure.class) {

                                taskPC.addParam(paramName, stats);

                        }

                        if(paramName.equals("PATH")) {

                                taskPC.addParam(paramName, fileName);

                        }

                        if(paramName.equals("ROI_EPSG") && useROI) {

                                taskPC.addParam(paramName, "EPSG:4326");

                    }

                        if(paramName.equals("WINDOW")) {

                            AnalysisExtent ext = getAnalysisExtent();

                            Extent bbox = RasterLocator.getManager().getDataStructFactory().createExtent(

                                            ext.getXMin(), ext.getYMax(), ext.getXMax(), ext.getYMin());

                            Extent inputBbox = inputStore.getExtent();

                            if(bbox.getULX() != inputBbox.getULX() ||

                                    bbox.getULY() != inputBbox.getULY() ||

                                    bbox.getLRX() != inputBbox.getLRX() ||

                                    bbox.getLRY() != inputBbox.getLRY()) {

                                    taskPC.addParam(paramName, bbox);

                            }

                    }

            }

            return taskPC;

    }

        public void interrupted() {

        }

        public void end(Object param) {

        }

        public void updateProgress(int current, int total) {

                boolean cancelled = setProgress(current, total);

                if(!cancelled) {

                        if(taskStats != null)

                                taskStats.actionCanceled(null);

                        if(taskPC != null)

                                taskPC.actionCanceled(null);

                }

        }

    /*

     * TODO: Customized panels

    @Override

    public Class<? extends GeoAlgorithmParametersPanel> getCustomParametersPanelClass() {

        return PrincipalComponentsParametersPanel.class;

    }*/

}