Application: gvSIG desktop » gvSIG geoprocess

package org.gvsig.geoprocess.lib.sextante;

import es.unex.sextante.additionalInfo.AdditionalInfo;

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.OutputFactory;

import es.unex.sextante.core.OutputObjectsSet;

import es.unex.sextante.core.ParametersSet;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.WrongOutputIDException;

import es.unex.sextante.exceptions.WrongParameterIDException;

import es.unex.sextante.outputs.FileOutputChannel;

import es.unex.sextante.outputs.Output;

import es.unex.sextante.outputs.OutputRasterLayer;

import es.unex.sextante.outputs.OutputTable;

import es.unex.sextante.outputs.OutputVectorLayer;

import es.unex.sextante.parameters.Parameter;

import es.unex.sextante.parameters.ParameterNumericalValue;

import es.unex.sextante.parameters.ParameterRasterLayer;

import es.unex.sextante.parameters.ParameterString;

import es.unex.sextante.parameters.ParameterVectorLayer;

import java.io.File;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.raster.api.RasterStore;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProvider;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.raster.api.RasterLayer;

import org.gvsig.geoprocess.lib.api.GeoProcessBuiler;

import org.gvsig.geoprocess.lib.api.GeoProcessLocator;

import org.gvsig.geoprocess.lib.sextante.core.DefaultOutputFactory;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class GeoProcessBuilerBase implements GeoProcessBuiler {

    private static final Logger logger = LoggerFactory.getLogger(GeoProcessBuilerBase.class);

    private class ParameterInfoBase implements ParameterInfo {

        private final Parameter param;

        public ParameterInfoBase(Parameter param) {

            this.param = param;

        }

        @Override

        public String getName() {

            return this.param.getParameterName();

        }

        @Override

        public String getTypeName() {

            return this.param.getParameterTypeName();

        }

        @Override

        public String getDescription() {

            return this.param.getParameterDescription();

        }

        @Override

        public String getTooltip() {

            return this.param.getParameterTooltip();

        }

        @Override

        public Class getParameterClass() {

            return this.param.getParameterClass();

        }

        public String getDetailedDescription() {

            try {

                AdditionalInfo x = this.param.getParameterAdditionalInfo();

                if( x == null ) {

                    return null;

                }

                return x.getTextDescription();

            } catch (Exception ex) {

                return null;

            }

        }

    }

    private class OutputAccesorBase implements OutputAccesor {

        private Output getOutput(String name) {

            OutputObjectsSet oos = algorithm.getOutputObjects();

            Output oo;

            try {

                oo = oos.getOutput(name);

            } catch (WrongOutputIDException ex) {

                throw new IllegalArgumentException(

                        MessageFormat.format(

                                "Can't access to output data ''{0}'' of the geoprocess ''{1}''.",

                                name,

                                getName()

                        )

                );

            }

            return oo;

        }

        @Override

        public Object get(String name) {

            Output oo = this.getOutput(name);

            Object value;

            if (oo instanceof OutputRasterLayer) {

                value = this.getRasterLayer(name);

            } else if (oo instanceof OutputVectorLayer) {

                value = this.getVectorLayer(name);

            } else if (oo instanceof OutputTable) {

                value = this.getFeatureStore(name);

            } else {

                value = oo.getOutputObject();

            }

            return value;

        }

        @Override

        public File getFile(String name) {

            Output oo = this.getOutput(name);

            FileOutputChannel channel = (FileOutputChannel) oo.getOutputChannel();

            File f = new File(channel.getFilename());

            return f;

        }

        @Override

        public boolean getBoolean(String name) {

            Object o = this.get(name);

            return (Boolean) o;

        }

        @Override

        public int getInt(String name) {

            Object o = this.get(name);

            return ((Number) o).intValue();

        }

        @Override

        public double getDouble(String name) {

            Object o = this.get(name);

            return ((Number) o).doubleValue();

        }

        @Override

        public String getString(String name) {

            Object o = this.get(name);

            return (String) o;

        }

        @Override

        public FeatureStore getFeatureStore(String name) {

            Output oo = this.getOutput(name);

            if (oo instanceof OutputTable) {

                TableDocumentITable table = (TableDocumentITable) oo.getOutputObject();

                table.postProcess();

                FeatureStore store = table.getFeatureStore();

                return store;

            } else if (oo instanceof OutputVectorLayer) {

                FlyrVectIVectorLayer slayer = (FlyrVectIVectorLayer) oo.getOutputObject();

                slayer.postProcess();

                FeatureStore store = slayer.getFeatureStore();

                return store;

            }

            return null;

        }

        @Override

        public FLyrVect getVectorLayer(String name) {

            try {

                FeatureStore store = this.getFeatureStore(name);

                FLyrVect layer = (FLyrVect) MapContextLocator.getMapContextManager().createLayer(

                        store.getName(),

                        store

                );

                return layer;

            } catch (LoadLayerException ex) {

                String s = MessageFormat.format(

                        "Can't get vector layer parameter ''{0}'' of the geoprocess ''{2}''",

                        name,

                        getName()

                );

                logger.warn(s);

                throw new RuntimeException(s, ex);

            }

        }

        @Override

        public RasterLayer getRasterLayer(String name) {

            try {

                RasterStore store = this.getRasterStore(name);

                RasterLayer layer = (RasterLayer) MapContextLocator.getMapContextManager().createLayer(

                        store.getName(),

                        store

                );

                return layer;

            } catch (LoadLayerException ex) {

                String s = MessageFormat.format(

                        "Can't get raster layer parameter ''{0}'' of the geoprocess ''{2}''",

                        name,

                        getName()

                );

                logger.warn(s);

                throw new RuntimeException(s, ex);

            }

        }

        @Override

        public RasterStore getRasterStore(String name) {

            Output oo = this.getOutput(name);

            // Obtenemos el fichero generado

            FileOutputChannel channel = (FileOutputChannel) oo.getOutputChannel();

            File rasterFile = new File(channel.getFilename());

            // Buscamos entre los store de fichero, el que pueda abrir el fichero raster

            String storeProviderName = null;

            FilesystemServerExplorer explorer = (FilesystemServerExplorer) DALLocator.getDataManager()

                    .getServerExplorerRegister()

                    .getFactory(FilesystemServerExplorer.NAME);

            Iterator<FilesystemServerExplorerProvider> it = explorer.getFilters();

            while (it.hasNext()) {

                FilesystemServerExplorerProvider provider = it.next();

                if (provider.accept(rasterFile)) {

                    storeProviderName = provider.getDataStoreProviderName();

                    break;

                }

            }

            if (storeProviderName == null) {

                String s = MessageFormat.format(

                        "Can't get raster store ''{0}'', type ''{1}'', of the geoprocess ''{2}''. Can't locate store for open file ''{3}''.",

                        name,

                        oo.getClass().getSimpleName(),

                        getName(),

                        rasterFile.getAbsolutePath()

                );

                logger.warn(s);

                throw new RuntimeException(s);

            }

            try {

                // Abrimos el store raster

                DataManager dataManager = DALLocator.getDataManager();

                DataStoreParameters params;

                params = dataManager.createStoreParameters(storeProviderName);

                ((FilesystemStoreParameters) params).setFile(rasterFile);

                RasterStore store = (RasterStore) dataManager.openStore(storeProviderName, params);

                return store;

            } catch (Exception ex) {

                String s = MessageFormat.format(

                        "Can't get output raster store ''{0}'', type ''{1}'', of the geoprocess ''{2}''. Can't open store for file ''{3}''.",

                        name,

                        oo.getClass().getSimpleName(),

                        getName(),

                        rasterFile.getAbsolutePath()

                );

                logger.warn(s);

                throw new RuntimeException(s, ex);

            }

        }

    }

    private GeoAlgorithm algorithm;

    private AnalysisExtent extent;

    private double cellSizeZ;

    private double cellSize;

    public GeoProcessBuilerBase() {

        this.cellSize = 1;

        this.cellSizeZ = 1;

    }

    @Override

    public String getName() {

        if (this.algorithm == null) {

            return "unknown";

        }

        return this.algorithm.getCommandLineName();

    }

    @Override

    public GeoProcessBuiler algorithm(String name) {

        SextanteGeoProcessManager manager = (SextanteGeoProcessManager) GeoProcessLocator.getGeoProcessManager();

        GeoAlgorithm alg = manager.getAlgorithms().get(name);

        if (alg == null) {

            throw new IllegalArgumentException(

                    MessageFormat.format(

                            "Can't access to geoprocess ''{0}''.",

                            name

                    )

            );

        }

        this.algorithm = alg;

        return this;

    }

    protected Parameter getParam(String name, Class expectedType, Object value) {

        Parameter param;

        try {

            param = this.algorithm.getParameters().getParameter(name);

        } catch (WrongParameterIDException ex) {

            throw new IllegalArgumentException(

                    MessageFormat.format(

                            "Can't access parameter ''{0}'' of the geoprocess ''{1}''.",

                            name,

                            this.getName()

                    ),

                    ex

            );

        }

        if (!expectedType.isInstance(param)) {

            throw new IllegalArgumentException(

                    MessageFormat.format(

                            "Incorrect type in parameter ''{0}'' of the geoprocess ''{1}'', expected a ''{2}'', and received a ''{3}''.",

                            name,

                            this.getName(),

                            param.getParameterTypeName(),

                            (value == null) ? "null" : value.getClass().getSimpleName()

                    )

            );

        }

        return param;

    }

    @Override

    public GeoProcessBuiler parameter(String name, String value) {

        Parameter param = this.getParam(name, ParameterString.class, value);

        param.setParameterValue(value);

        return this;

    }

    @Override

    public GeoProcessBuiler parameter(String name, int value) {

        Parameter param = this.getParam(name, ParameterNumericalValue.class, value);

        param.setParameterValue(value);

        return this;

    }

    @Override

    public GeoProcessBuiler parameter(String name, double value) {

        Parameter param = this.getParam(name, ParameterNumericalValue.class, value);

        param.setParameterValue(value);

        return this;

    }

    @Override

    public GeoProcessBuiler parameter(String name, FLyrVect value) {

        Parameter param = this.getParam(name, ParameterVectorLayer.class, value);

        FlyrVectIVectorLayer layer = new FlyrVectIVectorLayer();

        layer.create(value);

        param.setParameterValue(value);

        if (this.extent == null) {

            try {

                this.extent(value.getFullEnvelope());

            } catch (ReadException ex) {

                logger.warn(

                        MessageFormat.format(

                                "Can't set default extent of analysis from parameter ''{0}'' of the geoprocess ''{1}''",

                                name,

                                this.getName()

                        ),

                        ex

                );

            }

        }

        return this;

    }

    @Override

    public GeoProcessBuiler parameter(String name, RasterLayer value) {

        Parameter param = this.getParam(name, ParameterRasterLayer.class, value);

        FLyrRasterIRasterLayer layer;

        layer = new FLyrRasterIRasterLayer();

        layer.create(value);

        param.setParameterValue(value);

        if (this.extent == null) {

            try {

                this.extent(value.getFullEnvelope());

            } catch (ReadException ex) {

                logger.warn(

                        MessageFormat.format(

                                "Can't get Full Envelope ''{0}'' of the geoprocess ''{1}''",

                                name,

                                this.getName()

                        ),

                        ex

                );

            }

        }

        return this;

    }

//    @Override

//    public GeoProcessBuiler parameter(String name, TableDocument value) {

//        Parameter param = this.getParam(name, ParameterTable.class, value);

//        TableDocumentITable layer = new TableDocumentITable();

//        layer.create(value);

//        param.setParameterValue(value);

//        return this;

//    }

    @Override

    public GeoProcessBuiler extent(Envelope envelope) {

        double xlow = envelope.getLowerCorner().getX();

        double ylow = envelope.getLowerCorner().getY();

        double xup = envelope.getUpperCorner().getX();

        double yup = envelope.getUpperCorner().getY();

        AnalysisExtent extent = new AnalysisExtent();

        extent.setXRange(xlow, xup, false);

        extent.setYRange(ylow, yup, false);

        extent.setZRange(0, 0, false);

        this.extent = extent;

        this.algorithm.setAnalysisExtent(extent);

        return this;

    }

    @Override

    public GeoProcessBuiler cellSize(double cellSize) {

        this.cellSize = cellSize;

        return this;

    }

    @Override

    public GeoProcessBuiler cellSizeZ(double cellSizeZ) {

        this.cellSizeZ = cellSizeZ;

        return this;

    }

    @Override

    public GeoProcessBuiler execute() {

        if (this.algorithm == null) {

            throw new IllegalStateException("Algorithm can't be set");

        }

        if (!this.algorithm.hasCorrectParameterValues()) {

            throw new IllegalArgumentException(

                    MessageFormat.format(

                            "Some parameters of the process ''{0}'' has incorrect values",

                            this.getName()

                    )

            );

        }

        if (this.extent != null) {

            this.extent.setCellSize(this.cellSize);

            this.extent.setCellSizeZ(this.cellSizeZ);

        }

        OutputFactory outputFactory = new DefaultOutputFactory();

        try {

            this.algorithm.execute(null, outputFactory);

        } catch (GeoAlgorithmExecutionException ex) {

            logger.warn(

                    MessageFormat.format(

                            "Can't execute the process ''{0}''",

                            this.getName()

                    ),

                    ex

            );

        }

        return this;

    }

    @Override

    public OutputAccesor output() {

        return new OutputAccesorBase();

    }

    @Override

    public List<String> getAlgorithmNames() {

        SextanteGeoProcessManager manager = (SextanteGeoProcessManager) GeoProcessLocator.getGeoProcessManager();

        List<String> algorithms = new ArrayList(manager.getAlgorithms().keySet());

        return algorithms;

    }

    @Override

    public List<String> getParameterNames() {

        List<String> parameterNames = new ArrayList<String>();

        ParametersSet params = this.algorithm.getParameters();

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

            Parameter param = params.getParameter(i);

            parameterNames.add(param.getParameterName());

        }

        return parameterNames;

    }    

    @Override

    public ParameterInfo getParameterInfo(String name) {

        Parameter param;

        try {

            param = this.algorithm.getParameters().getParameter(name);

        } catch (WrongParameterIDException ex) {

            throw new IllegalArgumentException(

                    MessageFormat.format(

                            "Can't access parameter ''{0}'' of the geoprocess ''{1}''.",

                            name,

                            this.getName()

                    ),

                    ex

            );

        }

        return new ParameterInfoBase(param);

    }

}