Application: gvSIG desktop » gvSIG geoprocess

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 gvSIG Association.

 *

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.geoprocess.lib.sextante;

import java.io.File;

import java.util.HashMap;

import java.util.Iterator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

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

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

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

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

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

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

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

import es.unex.sextante.core.AnalysisExtent;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.ITaskMonitor;

import es.unex.sextante.core.OutputFactory;

import es.unex.sextante.core.OutputObjectsSet;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IRasterLayer;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.UnsupportedOutputChannelException;

import es.unex.sextante.exceptions.WrongOutputIDException;

import es.unex.sextante.gui.algorithm.GeoAlgorithmParametersPanel;

import es.unex.sextante.outputs.IOutputChannel;

import es.unex.sextante.outputs.Output;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.lang3.ArrayUtils;

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

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

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.namestranslator.NamesTranslator;

/**

 * Base implementation for Sextante based {@link GeoProcess} objects.

 *

 * @author gvSIG Team

 * @version $Id$

 */

public abstract class AbstractSextanteGeoProcess extends GeoAlgorithm implements GeoProcess {

    protected String[] attrNames = null; //targetAttrNames

    private SimpleTaskStatusDelegated status = null;

    protected GeometryManager geomManager = GeometryLocator.getGeometryManager();

    protected NamesTranslator namesTranslator = null;

    @Override

    public boolean execute(ITaskMonitor task, OutputFactory outputFactory,

            HashMap<String, String> outputMap)

            throws GeoAlgorithmExecutionException {

        status = new SimpleTaskStatusDelegated(m_Task, getGeoProcessName());

        status.add();

        boolean result = false;

        try {

            result = super.execute(task, outputFactory, outputMap);

        } finally {

            status.remove();

        }

        return result;

    }

    /**

     * This method creates a new raster layer and adds it to the set of output

     * objects of the algorithm. Use this when your algorithm generates a new

     * raster layer and you have to create it. The grid extent is taken from the

     * algorithm analysis extent (@see {@link #getAnalysisExtent()}

     *

     * @param sName The name of the layer. Has to be the same that you used to

     * define this output in the

     * @see {@link #defineCharacteristics()} method.

     * @param sDescription the long description of the output. This is the one

     * usually used to describe the layer when added to a GIS GUI

     * @param iDataType The data type. See

     * @see {@link IRasterLayer} for more info about valid values

     * @param iBands the number of bands of the new layer

     * @return a new raster layer

     * @throws UnsupportedOutputChannelException

     */

    protected IRasterLayer getNewRORasterLayer(final String sName,

            final String sDescription,

            final int iDataType,

            final int iBands) throws UnsupportedOutputChannelException {

        final IOutputChannel channel = getOutputChannel(sName);

        final IRasterLayer newLayer = ((DefaultOutputFactory) m_OutputFactory).getNewEmptyRORasterLayer(sName, iDataType,

                m_AnalysisExtent, iBands, channel, m_CRS);

        addOutputRasterLayer(sName, sDescription, iBands, channel, newLayer);

        return newLayer;

    }

    /**

     * Builds the output FeatureStore

     *

     * @param featureType

     * @return FeatureStore

     */

    protected FeatureStore buildOutPutStore(FeatureType featureType,

            int shapeType, String sextanteLayerName, String sextanteLayerLabel) {

//        Class<?>[] types = null;

//        if (featureType.getDefaultGeometryAttribute() != null) {

//            // Tiene campo GEOMETRY.

//            // Hay que quitarlo

//            attrNames = new String[featureType.size() - 1];

//            types = new Class[featureType.size() - 1];

//        } else {

//            attrNames = new String[featureType.size()];

//            types = new Class[featureType.size()];

//        }

        List<Class> types = new ArrayList();

        List<Integer> sizes = new ArrayList();

        List<String> theAttrNames = new ArrayList();

        List<FeatureAttributeDescriptor> emulateds = new ArrayList();

        @SuppressWarnings("unchecked")

        Iterator<FeatureAttributeDescriptor> it = featureType.iterator();

        while (it.hasNext()) {

            FeatureAttributeDescriptor attribute = it.next();

            if (attribute.isComputed()) {

                emulateds.add(attribute);

            } else {

                String attrName = attribute.getName();

                if (attribute.getDataType().getType() != DataTypes.GEOMETRY) {

                    theAttrNames.add(attrName);

                    types.add(attribute.getObjectClass());

                    sizes.add(attribute.getSize());

                }

            }

        }

        try {

            int[] arraySizes = sizes.stream().mapToInt(i->i).toArray();

            FlyrVectIVectorLayer output

                    = (FlyrVectIVectorLayer) getNewVectorLayer(

                            sextanteLayerLabel,

                            sextanteLayerName,

                            shapeType,

                            types.toArray(new Class[types.size()]),

                            theAttrNames.toArray(new String[theAttrNames.size()]),

                            arraySizes

                    );

            if (output != null) {

                FeatureStore store = output.getFeatureStore();

                if (!emulateds.isEmpty()) {

                    try {

                        boolean needStartEditingMode = !(store.isEditing() || store.isAppending());

                        if (needStartEditingMode) {

                            store.edit();

                        }

                        EditableFeatureType ft = store.getDefaultFeatureType().getEditable();

                        for (FeatureAttributeDescriptor emulated : emulateds) {

                            theAttrNames.add(emulated.getName());

                            ft.add(emulated.getName(), emulated.getType(), emulated.getFeatureAttributeEmulator());

                        }

                        store.update(ft);

                        if (needStartEditingMode) {

                            store.finishEditing();

                        }

                    } catch (Exception e) {

                        Sextante.addErrorToLog(e);

                    }

                }

                this.attrNames = theAttrNames.toArray(new String[theAttrNames.size()]);

                return output.getFeatureStore();

            }

        } catch (UnsupportedOutputChannelException e) {

            Sextante.addErrorToLog(e);

        } catch (GeoAlgorithmExecutionException e) {

            Sextante.addErrorToLog(e);

        }

        return null;

    }

    /**

     * Builds the output FeatureStore

     *

     * @param featureType

     * @return FeatureStore

     */

    protected FeatureStore buildOutPutStoreFromUnion(FeatureType featureType1,

            FeatureType featureType2, int shapeType, String sextanteLayerName,

            String sextanteLayerLabel) {

        return buildOutPutStoreFromUnion(featureType1, featureType2, shapeType,

                sextanteLayerName, sextanteLayerLabel, null, null);

    }

    /**

     * Builds the output FeatureStore

     *

     * @param featureType

     * @return FeatureStore

     */

    protected FeatureStore buildOutPutStoreFromUnion(FeatureType featureType1,

            FeatureType featureType2, int shapeType, String sextanteLayerName,

            String sextanteLayerLabel, String newField, Class<?> newFieldType) {

        NamesTranslator myNamesTranslator = getNamesTranslator();

        int sizeAux = 0;

        if (newField != null && newFieldType != null) {

            sizeAux = 1;

        }

        Class<?>[] types = null;

        // Tiene campo GEOMETRY. Hay que quitarlo

        if (featureType1.getDefaultGeometryAttribute() != null) {

            attrNames

                    = new String[featureType1.size() + featureType2.size() - 2

                    + sizeAux];

            types

                    = new Class[featureType1.size() + featureType2.size() - 2

                    + sizeAux];

        } else {

            attrNames

                    = new String[featureType1.size() + featureType2.size() + sizeAux];

            types

                    = new Class[featureType1.size() + featureType2.size() + sizeAux];

        }

        int i = 0;

        @SuppressWarnings("unchecked")

        Iterator<FeatureAttributeDescriptor> it = featureType1.iterator();

        myNamesTranslator.clear();

        List<Integer> sizes = new ArrayList();

        while (it.hasNext()) {

            FeatureAttributeDescriptor attribute

                    = (FeatureAttributeDescriptor) it.next();

            if (attribute.getDataType().getType() != DataTypes.GEOMETRY) {

                attrNames[i] = attribute.getName();

                myNamesTranslator.addSource(attribute.getName());

                types[i] = attribute.getObjectClass();

                int size = attribute.getSize();

                if (attribute.getObjectClass().equals(BigDecimal.class)) {

                    size = attribute.getPrecision();

                }

                sizes.add(size);

                i++;

            }

        }

        @SuppressWarnings("unchecked")

        Iterator<FeatureAttributeDescriptor> it2 = featureType2.iterator();

        while (it2.hasNext()) {

            FeatureAttributeDescriptor attribute = it2.next();

            if (attribute.getDataType().getType() != DataTypes.GEOMETRY) {

                String attrName

                        = checkAttrName(attribute.getName(), featureType1.size() - 1);

                attrNames[i] = attrName;

                myNamesTranslator.addSource(attribute.getName());

                types[i] = attribute.getObjectClass();

                int size = attribute.getSize();

                if (attribute.getObjectClass().equals(BigDecimal.class)) {

                    size = attribute.getPrecision();

                }

                sizes.add(size);

                i++;

            }

        }

        if (newField != null && newFieldType != null) {

            attrNames[attrNames.length - 1] = newField;

            myNamesTranslator.addSource(newField);

            types[types.length - 1] = newFieldType;

            sizes.add(0);

        }

        int[] arrayOfSizes = sizes.stream().mapToInt(ii->ii).toArray();

        try {

            IVectorLayer output

                    = getNewVectorLayer(sextanteLayerLabel, sextanteLayerName,

                            shapeType, types, myNamesTranslator.getTranslatedNamesAsArray(), arrayOfSizes);

            if (output != null) {

                return ((FlyrVectIVectorLayer) output).getFeatureStore();

            }

        } catch (UnsupportedOutputChannelException e) {

            Sextante.addErrorToLog(e);

        } catch (GeoAlgorithmExecutionException e) {

            Sextante.addErrorToLog(e);

        }

        return null;

    }

    /**

     * Changes the attribute name if this name is in the list.

     *

     * @param name

     * @return

     */

    protected String checkAttrName(String name, int size) {

        return checkAttrName(name, size, attrNames);

    }

    /**

     * Gets the shape type of the selected feature store

     *

     * @param FeatureStore source

     * @return shape type

     * @throws ReadException

     */

    protected int getShapeType(FeatureStore storeLayer1) throws ReadException {

        FeatureType featureType;

        try {

            featureType = storeLayer1.getDefaultFeatureType();

        } catch (DataException e) {

            throw new ReadException(storeLayer1.getName(), e);

        }

        int indexGeom = featureType.getDefaultGeometryAttributeIndex();

        return featureType.getAttributeDescriptor(indexGeom).getGeomType()

                .getType();

    }

    /**

     * Returns true if it is a point layer

     *

     * @param store

     * @return

     * @throws ReadException

     */

    protected boolean isPoint(FeatureStore store) throws ReadException {

        return (getShapeType(store) == Geometry.TYPES.POINT || getShapeType(store) == Geometry.TYPES.MULTIPOINT);

    }

    /**

     * Returns true if it is a polygon layer

     *

     * @param store

     * @return

     * @throws ReadException

     */

    protected boolean isPolygon(FeatureStore store) throws ReadException {

        int type = getShapeType(store);

        return geomManager.isSubtype(Geometry.TYPES.SURFACE, type) || geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, type);

    }

    /**

     * Returns true if it is a line layer

     *

     * @param store

     * @return

     * @throws ReadException

     */

    protected boolean isLine(FeatureStore store) throws ReadException {

        int type = getShapeType(store);

        return geomManager.isSubtype(Geometry.TYPES.CURVE, type) || geomManager.isSubtype(Geometry.TYPES.MULTICURVE, type);

    }

    /**

     * Returns true if it is a line layer

     *

     * @param store

     * @return

     * @throws ReadException

     */

    protected boolean isUndefined(FeatureStore store) throws ReadException {

        return (getShapeType(store) == Geometry.TYPES.GEOMETRY);

    }

    public String getGeoProcessName() {

        return getName();

    }

    @Override

    protected void setProgressText(String sText) {

        super.setProgressText(sText);

        getStatus().message(sText);

    }

    @Override

    public boolean setProgress(int iStep, int iTotalNumberOfSteps) {

        boolean cancelled = super.setProgress(iStep, iTotalNumberOfSteps);

        SimpleTaskStatusDelegated status = getStatus();

        status.setRangeOfValues(0, iTotalNumberOfSteps);

        status.setCurValue(iStep);

        if (cancelled || status.isCancelled()) {

            return true;

        }

        return false;

    }

    protected SimpleTaskStatusDelegated getStatus() {

        return status;

    }

    @Override

    public String getCommandLineName() {

        // Override sextante command line value, as it might be the same as

        // other sextante algorithms and some information is not shown as

        // expected.

        return "gvSIG-".concat(super.getCommandLineName());

    }

    /**

     * Returns the {@link GeoProcessManager}.

     *

     * @return the {@link GeoProcessManager}

     */

    public GeoProcessManager getGeoProcessManager() {

        return GeoProcessLocator.getGeoProcessManager();

    }

    /**

     * Returns the translation for a label depending on the current locale.

     *

     * @param label to translate

     * @return text in the current locale

     */

    protected String getTranslation(String label) {

        return getGeoProcessManager().getTranslation(label);

    }

    public Class<? extends GeoAlgorithmParametersPanel> getCustomParametersPanelClass() {

        return null;

    }

    /**

     * Gets a feature query using the analysis bounding box

     *

     * @param e

     * @param store

     * @return

     * @throws CreateEnvelopeException

     * @throws DataException

     */

    public FeatureQuery getQueryFromAnalysisExtent(AnalysisExtent e, FeatureStore store) throws CreateEnvelopeException, DataException {

        Envelope analysisEnvelope = geomManager.createEnvelope(e.getXMin(), e.getYMin(), e.getXMax(), e.getYMax(), SUBTYPES.GEOM2D);

        FeatureQuery query = store.createFeatureQuery();

        Evaluator filter = SpatialEvaluatorsFactory.getInstance().intersects(

                analysisEnvelope,

                store.getDefaultFeatureType().getDefaultSRS(),

                store

        );

        query.setFilter(filter);

        return query;

    }

    /**

     * Returns true if exists the output file and false i

     *

     * @param resultLabel

     * @param type zero shape and one tif

     * @return

     */

    public boolean existsOutPutFile(String resultLabel, int type) {

        OutputObjectsSet ooSet = getOutputObjects();

        Output out;

        try {

            out = ooSet.getOutput(resultLabel);

        } catch (WrongOutputIDException e) {

            return false;

        }

        String s = out.getOutputChannel() != null ? out.getOutputChannel().getAsCommandLineParameter() : "";

        if (new File(s).exists()) {

            return true;

        }

        if (type == 0) {

            return (new File(s + ".shp").exists());

        }

        if (type == 1) {

            return (new File(s + ".tif").exists());

        }

        return false;

    }

    public String getOutPutFile(String resultLabel) {

        OutputObjectsSet ooSet = getOutputObjects();

        Output out;

        try {

            out = ooSet.getOutput(resultLabel);

        } catch (WrongOutputIDException e) {

            return null;

        }

        return out.getOutputChannel().getAsCommandLineParameter();

    }

    public ITaskMonitor getTaskMonitor() {

        return m_Task;

    }

    public void setTaskMonitor(ITaskMonitor task) {

        this.m_Task = task;

    }

    public NamesTranslator getNamesTranslator() {

        if (this.namesTranslator == null) {

            NamesTranslator dummy = NamesTranslator.createDummyTranslator();

            if( attrNames!=null ) {

                for (String attrName : attrNames) {

                    dummy.addSource(attrName);

                }

            }

            this.namesTranslator = dummy;

        }

        return this.namesTranslator;

    }

}