Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.tasseledcap;

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.tasseledcap.algorithm.TasseledCapAlgorithmLibrary;

import org.gvsig.raster.tasseledcap.algorithm.TasseledCapProcess;

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 TasseledCapSextanteAlgorithm extends AbstractSextanteGeoProcess implements IProcessActions {

    public static final String RESULT            = "RESULT";

    public static final String LAYER             = TasseledCapProcess.RASTER_STORE;

    public static final String USE_ROI           = "USE_ROI";

    public static final String TYPE              = "TYPE";

    public static String[]     LANDSAT_TYPES     = new String[]{"Landsat MS" , "Landsat TM",  "Landsat ETM"};

    private boolean            useROI            = false;

    private DataProcess        taskStats         = null;

    private DataProcess        taskPC            = null;

    private int                type              = 0;

    public void defineCharacteristics() {

        setName(getTranslation("tasseledcap"));

        setGroup(getTranslation("multispectral"));

        try {

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

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

            m_Parameters.addSelection(TYPE, getTranslation("type"), LANDSAT_TYPES);

        } catch (RepeatedParameterNameException e) {

            Sextante.addErrorToLog(e);

        }

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

    }

    public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

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

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

            }

            IRasterLayer input = m_Parameters.getParameterValueAsRasterLayer(LAYER);

                useROI = m_Parameters.getParameterValueAsBoolean(USE_ROI);

                String value = m_Parameters.getParameterValueAsString(TYPE);

                type = 0;

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

                        if(LANDSAT_TYPES[j].equals(value))

                                type = j;

                }

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

            IRasterLayer output = null;

            output = getNewRORasterLayer(

                            RESULT, 

                            Sextante.getText("tasseledcap_description"), 

                            input.getDataType(), 

                            input.getBandsCount());

            String fileName = ((FLyrRasterIRasterLayer)output).getFileName(); //getOutPutFile(RESULT);

            try {

                        setProgressText(getTranslation("calculating"));

                        taskPC = createTasseledCapProcess(lyrRaster.getDataStore(), fileName, type);

                        taskPC.execute();

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

                } catch (ProcessInterruptedException e) {

                        Sextante.addErrorToLog(e);

                } catch (ProcessException e) {

                        Sextante.addErrorToLog(e);

                } 

                if(getTaskMonitor().isCanceled())

                        return false;

        return true;

    }

    private DataProcess createTasseledCapProcess(RasterDataStore inputStore, String fileName, int type) throws ProcessException {

            DataProcess taskPC = RasterBaseAlgorithmLibrary.getManager().createRasterTask(TasseledCapAlgorithmLibrary.TASSELEDCAP_PROCESS_LABEL);

            taskPC.setActions(this);

            List<String> params = taskPC.getRasterTaskInputParameters(TasseledCapAlgorithmLibrary.TASSELEDCAP_PROCESS_LABEL);

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

                    String paramName = params.get(i);

                    Class<?> paramType = taskPC.getParameterTypeByProcess(TasseledCapAlgorithmLibrary.TASSELEDCAP_PROCESS_LABEL, paramName);

                    if(paramType == RasterDataStore.class) {

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

                    }

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

                            boolean[] bands = new boolean[type == 0 ? 4 : 6];

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

                                        bands[j] = true;

                                }

                            taskPC.addParam(paramName, bands);

                        }

                        if(paramType == Integer.class) {

                                taskPC.addParam(paramName, type);

                        }

                        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;

    }*/

}