Application: gvSIG desktop » gvSIG geoprocess

package org.gvsig.sextante.app.algorithm.difference;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.dal.DataSet;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureSelection;

import org.gvsig.sextante.app.algorithm.base.core.ScalableUnionOperation;

import org.gvsig.sextante.app.algorithm.base.panel.AlgorithmOutputPanel;

import org.gvsig.sextante.app.extension.core.gvVectorLayer;

import es.unex.sextante.core.GeoAlgorithm;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.exceptions.UnsupportedOutputChannelException;

import es.unex.sextante.outputs.OutputVectorLayer;

public class DifferenceAlgorithm extends GeoAlgorithm {

        public static final String  RESULT    = "RESULT";

        public static final String  LAYER     = "LAYER";

        public static final String  DIF       = "DIF";

        public static final String  CHECK     = "CHECK";

        private String[]            attrNames = null;

        public void defineCharacteristics(){

                setName(Sextante.getText("Difference"));

                setGroup(Sextante.getText("gvSIG_Algorithms"));

                setGeneratesUserDefinedRasterOutput(false);

                try {

                        m_Parameters.addInputVectorLayer(LAYER, 

                                                                                                Sextante.getText( "Input_layer"), 

                                                                                                IVectorLayer.SHAPE_TYPE_WRONG, 

                                                                                                true);

                        m_Parameters.addInputVectorLayer(DIF, 

                                                                                                Sextante.getText( "Overlays_layer"), 

                                                                                                IVectorLayer.SHAPE_TYPE_WRONG, 

                                                                                                true);

                        m_Parameters.addBoolean(CHECK, Sextante.getText("Selected_geometries"), false);

                } catch (RepeatedParameterNameException e) {

                        Sextante.addErrorToLog(e);

                }

                addOutputVectorLayer(RESULT,

                                                                Sextante.getText( "Difference"),

                                                                OutputVectorLayer.SHAPE_TYPE_LINE);

                setExternalParameters((Object)new AlgorithmOutputPanel());

        }

        public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

                org.gvsig.fmap.geom.Geometry overlayGeometry = null;

                IVectorLayer dif = m_Parameters.getParameterValueAsVectorLayer(DIF);

                IVectorLayer layer = m_Parameters.getParameterValueAsVectorLayer(LAYER);

                boolean selectedGeom = m_Parameters.getParameter(CHECK).getParameterValueAsBoolean();

                try {

                        overlayGeometry = ScalableUnionOperation.joinLayerGeometries(dif);

                } catch (Exception e) {

                        Sextante.addErrorToLog(e);

                        return false;

                }

                try {

                        computesDifference(layer, overlayGeometry, layer.getShapeType(), selectedGeom);

                } catch (DataException e) {

                        Sextante.addErrorToLog(e);

                        return false;

                }

                return true;

        }

        /**

         * Builds a layer with the difference between the input layer and the templateGeometry

         * @param layer

         *        Input layer

         * @param templateGeometry

         * @param shapeType

         *        Output shape type

         * @param selectedGeom

         *        If it's true only selected geometries will be computed

         */

        private void computesDifference(IVectorLayer layer, 

                                                                org.gvsig.fmap.geom.Geometry templateGeometry, 

                                                                int shapeType, 

                                                                boolean selectedGeom) throws DataException {

                FeatureStore storeLayer = null;

                if(layer instanceof gvVectorLayer && templateGeometry != null)

                        storeLayer = ((gvVectorLayer)layer).getFeatureStore();

                else

                        return;

                DifferenceOperation operation = new DifferenceOperation(templateGeometry);

                FeatureSet features = null;

                features = storeLayer.getFeatureSet();

                FeatureType featureType = features.getDefaultFeatureType();

                FeatureStore featStore = buildOutPutStore(featureType, shapeType);

                operation.setFeatureStore(featStore, attrNames);

                DisposableIterator it = null;

                if(selectedGeom) {

                        DataSet ds = storeLayer.getSelection();

                        it = ((DefaultFeatureSelection)ds).iterator();

                } else

                        it = features.iterator();

                while( it.hasNext() ) {

                        Feature feature = (Feature)it.next();

                        List geomList = feature.getGeometries();

                        if(geomList == null) {

                                org.gvsig.fmap.geom.Geometry geom = feature.getDefaultGeometry();

                                operation.invoke(geom, feature);

                                continue;

                        }

                        Iterator<org.gvsig.fmap.geom.Geometry> itGeom = geomList.iterator();

                        boolean first = true;

                        EditableFeature editFeat = null;

                        while(itGeom.hasNext()) {

                                org.gvsig.fmap.geom.Geometry g = itGeom.next();

                                if(first) {

                                        editFeat = operation.invoke(g, feature);

                                        first = false;

                                } else

                                        operation.invoke(g, editFeat);

                        }

                }

                operation.end();

        }

        /**

         * Builds the output FeatureStore 

         * @param featureType

         * @return FeatureStore

         */

        private FeatureStore buildOutPutStore(FeatureType featureType, int shapeType) {

                Iterator it = featureType.iterator();

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

                }

                int i = 0;

                while( it.hasNext() ) {

                        FeatureAttributeDescriptor attribute = (FeatureAttributeDescriptor)it.next();

                        if(attribute.getName().compareTo("GEOMETRY") != 0) {

                                attrNames[i] = attribute.getName();

                                types[i] = attribute.getObjectClass();

                                i++;

                        }

                }

                try {

                        IVectorLayer output = getNewVectorLayer(RESULT,

                                                                                                        Sextante.getText("Clip"),

                                                                                                        shapeType, types, attrNames);

                        return ((gvVectorLayer)output).getFeatureStore();

                } catch (UnsupportedOutputChannelException e) {

                        Sextante.addErrorToLog(e);

                }

                return null;

        }

}