Application: gvSIG desktop » gvSIG Linear Reference System

/*

 * Copyright 2015 DiSiD Technologies S.L.L. All rights reserved.

 *

 * Project  : DiSiD org.gvsig.lrs.swing.impl

 * SVN Id   : $Id$

 */

package org.gvsig.lrs.swing.impl;

import java.awt.Color;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JComponent;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.aggregate.MultiLine;

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.layers.FLayer;

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

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

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.lrs.lib.api.LrsAlgorithmParams;

import org.gvsig.lrs.lib.api.LrsAlgorithmsLocator;

import org.gvsig.lrs.lib.api.LrsAlgorithmsManager;

import org.gvsig.lrs.lib.api.LrsEditRouteCalibrationAlgorithmParams;

import org.gvsig.lrs.lib.api.exceptions.LrsGettingParametersException;

import org.gvsig.lrs.lib.api.exceptions.LrsNeededParameterException;

import org.gvsig.lrs.swing.api.JLrsAlgorithmParams;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.ActionListenerSupport;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

public class JLrsEditRouteCalibrationController extends

    JLrsEditRouteCalibrationParamsView implements JLrsAlgorithmParams {

    /**

     *

     */

    private static final long serialVersionUID = 7762321351616631999L;

    private static final Logger logger = LoggerFactory

        .getLogger(JLrsEditRouteCalibrationController.class);

    private boolean canceled;

    private boolean hasWarnings;

    private List<String> warnings;

    private ActionListenerSupport listeners =

        ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

    private FLayer layer;

    private FeatureAttributeDescriptor fieldIdRoute;

    private FeatureSet selectedFeatures;

    private Feature editedFeature;

    private Double editedFeatureMax;

    private Double editedFeatureMin;

    private MapContext mapContext;

    GraphicLayer graphics;

    private int idMarkerSymbol;

    private int idLineSymbol;

    public static final String EDIT_ROUTECALIBRATION_GRAPHICS_ID = "EditRouteCalibration";

    /**

     * @param layer

     * @throws LrsNeededParameterException

     * @throws LrsGettingParametersException

     *

     */

    public JLrsEditRouteCalibrationController(FLayer layer, MapContext mapContext, FeatureAttributeDescriptor fieldIdRoute,

        LrsAlgorithmParams params) throws LrsNeededParameterException, LrsGettingParametersException {

        super();

        this.layer = layer;

        this.fieldIdRoute=fieldIdRoute;

        this.mapContext = mapContext;

        initializeGraphics(mapContext);

        initComponents();

        translate();

        setParams(params);

    }

    /**

     * @param mapContext

     */

    private void initializeGraphics(MapContext mapContext) {

        this.graphics = mapContext.getGraphicsLayer();

        SymbolManager symbolManager = MapContextLocator.getSymbolManager();

        ISymbol markerSymbol = symbolManager.createSymbol(Geometry.TYPES.POINT, Color.RED);

        ISymbol lineSymbol = symbolManager.createSymbol(Geometry.TYPES.CURVE, Color.YELLOW);

        this.idLineSymbol = this.graphics.addSymbol(lineSymbol);

        this.idMarkerSymbol = this.graphics.addSymbol(markerSymbol);

    }

    public void addActionListener(ActionListener listener) {

        listeners.addActionListener(listener);

    }

    public void removeActionListener(ActionListener listener) {

        listeners.removeActionListener(listener);

    }

    private void translate() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        lblIdRouteField

            .setText(i18nManager.getTranslation(lblIdRouteField.getText()));

        lblMaximum.setText(i18nManager.getTranslation(lblMaximum.getText()));

        lblMinimum.setText(i18nManager.getTranslation(lblMinimum.getText()));

        btnInvert.setText(i18nManager.getTranslation(btnInvert.getText()));

        btnApply.setText(i18nManager.getTranslation(btnApply.getText()));

        btnAccept.setText(i18nManager.getTranslation(btnAccept.getText()));

        btnCancel.setText(i18nManager.getTranslation(btnCancel.getText()));

    }

    /**

    *

    */

    public void setLocate(Locale locale) {

        Locale l = super.getLocale();

        if (!l.equals(locale)) {

            translate();

        }

        super.setLocale(locale);

    }

    /**

     * Validates it is an editable curve layer with at least 1 non-geometric

     * field

     * if it is not correct throws an exception

     *

     * @throws LrsNeededParameterException

     * @throws ReadException

     */

    public static void validateLayer(FLayer layer)

        throws LrsNeededParameterException {

        logger.debug("Validating layer for Edit Route");

        if (layer == null) {

            logger.error("A layer is needed");

            throw new LrsNeededParameterException("a_layer_is_needed", null);

        }

        if (!layer.isEditing()) {

            logger.error("An editing layer is needed");

            throw new LrsNeededParameterException("an_editing_layer_is_needed",

                null);

        }

        if (!JLrsUtils.isMlayerWithNonGeomField(layer)) {

            logger.error("Impossible to find the layers needed");

            throw new LrsNeededParameterException(

                "impossible_to_find_needed_layer", null);

        }

    }

    /**

     * Checks if the selectedIdRoute is contained in the layer

     *

     * @throws LrsNeededParameterException

     * @throws ReadException

     */

    public static void validateSelectedIdRoute(FLayer layer, FeatureAttributeDescriptor selectedIdRoute)

        throws LrsNeededParameterException {

        logger.debug("Validating selected id route for Edit Route");

        if (selectedIdRoute == null) {

            logger.error("A selectedIdRoute is needed");

            throw new LrsNeededParameterException("a_selectedIdRoute_is_needed", null);

        }

        if (!isCorrectIdRoute(layer,selectedIdRoute)) {

            logger.error("Selected id route is not contained in editing layer");

            throw new LrsNeededParameterException(

                "route_not_contained", null);

        }

    }

    public void validateSelectedFeatures() throws LrsGettingParametersException{

        //TODO added to Test

        if (selectedFeatures!=null) return;

        final List<String> routeNames=new ArrayList<String>();

        try {

            selectedFeatures.accept(new Visitor() {

                public void visit(Object obj) throws VisitCanceledException, BaseException {

                    if(obj instanceof Feature){

                        Feature feature=(Feature)obj;

                        if (feature.get(fieldIdRoute.getName()) instanceof String){

                            String routeName=(String)feature.get(fieldIdRoute.getName());

                            if (routeNames.contains(routeName)){

                                logger.error("Duplicate route name found");

                                throw new LrsGettingParametersException("Duplicate route name found",null);

                            }else{

                                routeNames.add(routeName);

                            }

                        }

                    }

                }

            });

        } catch (BaseException e1) {

            logger.error("Impossible to validate selected features",e1);

            throw new LrsGettingParametersException("Impossible to validate selected features", e1);

        }

    }

    /**

     * @throws LrsNeededParameterException

     * @throws LrsGettingParametersException

     */

    private void initComponents() throws LrsNeededParameterException, LrsGettingParametersException {

        validateLayer(layer);

        validateSelectedIdRoute(layer, fieldIdRoute);

        selectedFeatures=getSelectedFeatures(layer);

        validateSelectedFeatures();

        String selectedRouteName=initCmbRoute();

        routeChanged(selectedRouteName);

        this.btnApply.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = false;

                doApply();

            }

        });

        this.btnInvert.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = false;

                doInvert();

            }

        });

        this.btnAccept.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = false;

                validateData();

                doClose();

                listeners.fireActionEvent(new ActionEvent(

                    JLrsEditRouteCalibrationController.this, 0,

                    "accept"));

            }

        });

        this.btnCancel.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = true;

                doClose();

                listeners.fireActionEvent(new ActionEvent(

                    JLrsEditRouteCalibrationController.this, 0,

                    "cancel"));

            }

        });

        this.tblLayerInfo.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

            public void valueChanged(ListSelectionEvent e) {

                GeometryManager geomManager = GeometryLocator.getGeometryManager();

                graphics.removeGraphics(EDIT_ROUTECALIBRATION_GRAPHICS_ID);

                showEditingRoute();

                int[] selectedRows = tblLayerInfo.getSelectedRows();

                for (int i = 0; i < selectedRows.length; i++) {

                    Point point = null;

                    try {

                        point = (Point) geomManager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2D);

                        point.setX((Double)tblLayerInfo.getValueAt(selectedRows[i], 2));

                        point.setY((Double)tblLayerInfo.getValueAt(selectedRows[i], 3));

                    } catch (CreateGeometryException e1) {

                        logger.warn("Can't create a point", e);

                    }

                    if(point != null){

                        graphics.addGraphic(

                            EDIT_ROUTECALIBRATION_GRAPHICS_ID,

                            point,

                            idMarkerSymbol);

                    }

                }

                mapContext.invalidate();

            }

        });

        setVisibleAceptCancel(false);

        canceled = false;

    }

    private void reloadMaxMin(EditRouteCalibrationTableModel tableModel){

        this.txtMaximum.getDocument().addDocumentListener(new DocumentListener() {

            public void changedUpdate(DocumentEvent e) {

                enableApply(e);

            }

            public void removeUpdate(DocumentEvent e) {

                enableApply(e);

            }

            public void insertUpdate(DocumentEvent e) {

                enableApply(e);

            }

            public void enableApply(DocumentEvent e) {

                try {

                    e.getType();

                    Double max = Double.valueOf(txtMaximum.getText());

                    Double min = Double.valueOf(txtMinimum.getText());

                } catch (Exception ex) {

                    btnApply.setEnabled(false);

                    return;

                }

                btnApply.setEnabled(true);

            }

          });

        this.txtMinimum.getDocument().addDocumentListener(new DocumentListener() {

            public void changedUpdate(DocumentEvent e) {

                enableApply(e);

            }

            public void removeUpdate(DocumentEvent e) {

                enableApply(e);

            }

            public void insertUpdate(DocumentEvent e) {

                enableApply(e);

            }

            public void enableApply(DocumentEvent e) {

                try{

                    Double max = Double.valueOf(txtMaximum.getText());

                    Double min = Double.valueOf(txtMinimum.getText());

                }catch(Exception ex){

                    btnApply.setEnabled(false);

                    return;

                }

                btnApply.setEnabled(true);

            }

          });

        editedFeatureMax=tableModel.getMaxValue();

        editedFeatureMin=tableModel.getMinValue();

        this.txtMaximum.setText(editedFeatureMax.toString());

        this.txtMinimum.setText(editedFeatureMin.toString());

    }

    private void doInvert(){

        String max = txtMaximum.getText();

        String min = txtMinimum.getText();

        txtMaximum.setText(min);

        txtMinimum.setText(max);

    }

    private void doApply(){

        reloadTableModel();

        EditRouteCalibrationTableModel tableModel=(EditRouteCalibrationTableModel)tblLayerInfo.getModel();

        Object[][] data=tableModel.getData();

        Double newMax= Double.valueOf(txtMaximum.getText());

        Double newMin= Double.valueOf(txtMinimum.getText());

        Double oldMin=editedFeatureMin;

        Double oldMax=editedFeatureMax;

        if (data!=null&&data.length>1){

            for (int i=0;data.length-1>=i;i++){

                Double mCoordinate =(Double)data[i][EditRouteCalibrationTableModel.COLUMN_MCOORDINATE];

                Double newMCoordinate=calculateNewM(oldMax, oldMin, newMax, newMin, mCoordinate);

                data[i][EditRouteCalibrationTableModel.COLUMN_MCOORDINATE]=newMCoordinate;

            }

        }

        tableModel.setData(data);

        this.tblLayerInfo.setModel(tableModel);

        this.tblLayerInfo.invalidate();

        this.tblLayerInfo.repaint();

    }

    private double calculateNewM(double oldMax, double oldMin, double newMax, double newMin, double mCoordinate){

        double result;

        if (oldMax==oldMin){

            return Double.POSITIVE_INFINITY;

        }

        result=((newMax-newMin)*(mCoordinate-oldMin)/(oldMax-oldMin))+newMin;

        return result;

    }

    private void cellUpdated(int row){

        EditRouteCalibrationTableModel tableModel=(EditRouteCalibrationTableModel)tblLayerInfo.getModel();

        Object[][] data=tableModel.getData();

        Double newValue=tableModel.getValueUpdated();

        data[row][EditRouteCalibrationTableModel.COLUMN_MCOORDINATE]=newValue;

        tableModel.setData(data);

        this.tblLayerInfo.setModel(tableModel);

        this.tblLayerInfo.invalidate();

        this.tblLayerInfo.repaint();

    }

    private String initCmbRoute() {

        final List<String> routeNames=new ArrayList<String>();

        try {

            selectedFeatures.accept(new Visitor() {

                public void visit(Object obj) throws VisitCanceledException, BaseException {

                    if(obj instanceof Feature){

                        Feature feature=(Feature)obj;

                        if (feature.get(fieldIdRoute.getName()) instanceof String){

                            String routeName=(String)feature.get(fieldIdRoute.getName());

                            if (!routeNames.contains(routeName)){

                                routeNames.add(routeName);

                            }

                        }

                    }

                }

            });

        } catch (BaseException e1) {

            logger.error("Impossible to obtain route names to fill ComboBox",e1);

        }

        String[] routeNamesArray=routeNames.toArray(new String[0]);

        ComboBoxModel<String> routeModel =

            new DefaultComboBoxModel<String>(routeNamesArray);

        cmbRoute.setModel(routeModel);

        cmbRoute.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent event) {

                if (event.getStateChange() == ItemEvent.SELECTED) {

                    String item = (String) event.getItem();

                    routeChanged((String)item);

                }

            }

        });

        return (String)cmbRoute.getSelectedItem();

    }

    private void routeChanged(String selectedRouteName) {

        final String routeName = selectedRouteName;

        DisposableIterator it = null;

        editedFeature = null;

        try {

            it = selectedFeatures.fastIterator();

            while (it.hasNext() && editedFeature == null) {

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

                if (feature.get(fieldIdRoute.getName()) instanceof String

                    && routeName.equals((String) feature.get(fieldIdRoute.getName()))) {

                    editedFeature = feature.getCopy();

                }

            }

        } catch (DataException e) {

            logger.error("Error getting table info", e);

        } finally {

            if (it != null) {

                it.dispose();

            }

        }

        reloadTableModel();

        reloadMaxMin((EditRouteCalibrationTableModel) tblLayerInfo.getModel());

        graphics.removeGraphics(EDIT_ROUTECALIBRATION_GRAPHICS_ID);

        showEditingRoute();

        mapContext.invalidate();

    }

    /**

     *

     */

    private void showEditingRoute() {

        if (editedFeature != null) {

            graphics.addGraphic(EDIT_ROUTECALIBRATION_GRAPHICS_ID, editedFeature.getDefaultGeometry(), idLineSymbol);

        }

    }

    private void reloadTableModel(){

        EditRouteCalibrationTableModel tableModel;

        tableModel =null;

        try {

            if (editedFeature!=null){

                tableModel = new EditRouteCalibrationTableModel(editedFeature,fieldIdRoute);

                tableModel.addTableModelListener(new TableModelListener() {

                    public void tableChanged(TableModelEvent e) {

                        cellUpdated(e.getFirstRow());

                    }

                });

            }

        } catch (BaseException e) {

            logger.error("Error getting table info",e);

        }

        tblLayerInfo.setModel(tableModel);

        this.tblLayerInfo.invalidate();

    }

    private void doClose() {

        graphics.removeGraphics(EDIT_ROUTECALIBRATION_GRAPHICS_ID);

        mapContext.invalidate();

        this.setVisible(false);

    }

    public void close(){

        this.doClose();

    }

    private void validateData(){

        hasWarnings=true;

        EditRouteCalibrationTableModel tableModel=(EditRouteCalibrationTableModel)tblLayerInfo.getModel();

        Object[][] data=tableModel.getData();

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        warnings=new ArrayList<String>();

        if (data==null){

            warnings.add(i18nManager.getTranslation("warn_Not_data_found_in_table"));

            return;

        }

        if (data.length<2){

            warnings.add(i18nManager.getTranslation("warn_Not_enough_data_found_in_table"));

        }

        for (int i=0;data.length-1>=i;i++){

            Double mCoordinate=(Double)data[i][EditRouteCalibrationTableModel.COLUMN_MCOORDINATE];

            if(mCoordinate.compareTo(new Double(0))<0){

                warnings.add(MessageFormat.format(i18nManager.getTranslation("warn_Negative_value_at_row"), i+1));

            }

            if(i>0 && i+1<data.length-1){

                Double preMCoordinate=(Double)data[i-1][EditRouteCalibrationTableModel.COLUMN_MCOORDINATE];

                Double postMCoordinate=(Double)data[i+1][EditRouteCalibrationTableModel.COLUMN_MCOORDINATE];

                boolean orderedUpwardsPre=mCoordinate.compareTo(preMCoordinate)>=0;

                boolean orderedUpwardsPost=postMCoordinate.compareTo(mCoordinate)>=0;

                //if both,pre and post, are ordered upwards or downwards, it is correct

                if(orderedUpwardsPre!=orderedUpwardsPost){

                    warnings.add(MessageFormat.format(i18nManager.getTranslation("warn_Out_of_sequence_value_at_row"), i+1));

                }

            }

            for (int j=i+1;data.length-2>=j;j++){

                Double auxMCoordinate=(Double)data[j][EditRouteCalibrationTableModel.COLUMN_MCOORDINATE];

                if(mCoordinate.equals(auxMCoordinate)){

                    warnings.add(MessageFormat.format(i18nManager.getTranslation("warn_Repeated_value_at_row"), i+1,j+1));

                }

            }

        }

        if(warnings.size()==0){

            hasWarnings=false;

        }

    }

    public boolean hasWarnings(){

        return this.hasWarnings;

    }

    public List<String> getWarnings(){

        return this.warnings;

    }

    public boolean isCanceled() {

        return this.canceled;

    }

    public void setVisibleAceptCancel(boolean visible) {

        this.btnAccept.setVisible(visible);

        this.btnCancel.setVisible(visible);

    }

    public boolean getVisibleAceptCancel() {

        return this.btnAccept.isVisible();

    }

    public JComponent asJComponent() {

        return this;

    }

    public LrsAlgorithmParams getParams()

        throws LrsGettingParametersException, LrsNeededParameterException {

        LrsAlgorithmsManager manager =

            LrsAlgorithmsLocator.getLrsAlgorithmsManager();

        LrsEditRouteCalibrationAlgorithmParams params =

            manager.createLrsEditRouteCalibrationAlgorithmParams();

            // Recorrer todo del interfaz y rellenar los parametros

        params.setIdRouteField(fieldIdRoute);

        params.setSelectedRouteName((String)cmbRoute.getSelectedItem());

        EditRouteCalibrationTableModel tableModel=(EditRouteCalibrationTableModel)tblLayerInfo.getModel();

        Object[][] data=tableModel.getData();

        Geometry cloned=editedFeature.getDefaultGeometry().cloneGeometry();

        int rowNumber=0;

        if (cloned.getGeometryType().isTypeOf(Geometry.TYPES.LINE)){

            Line line=(Line) cloned;

            for (int i=0;i<line.getNumVertices();i++){

                Double newMvalue=(Double)data[rowNumber][4];

                line.setCoordinateAt(i, line.getDimension()-1, newMvalue);

                rowNumber++;

            }

        }

        if (cloned.getGeometryType().isTypeOf(Geometry.TYPES.MULTILINE)){

            MultiLine multiline=(MultiLine) cloned;

            for (int i=0;i<multiline.getPrimitivesNumber();i++){

                Line line=(Line)multiline.getPrimitiveAt(i);

                for (int j=0;j<line.getNumVertices();j++){

                    Double newMvalue=(Double)data[rowNumber][4];

                    line.setCoordinateAt(j, line.getDimension()-1, newMvalue);

                    rowNumber++;

                }

            }

        }

        params.setModifiedGeometry(cloned);

        return params;

    }

    public void setParams(LrsAlgorithmParams params) {

        if (params == null) {

            clear();

            return;

        }

        // Rellena los campos con los valores de params

        LrsEditRouteCalibrationAlgorithmParams parameters =

            (LrsEditRouteCalibrationAlgorithmParams) params;

        if (parameters.getSelectedRouteName()!=null){

            this.cmbRoute.setSelectedItem(parameters.getSelectedRouteName());

        }

        if (parameters.getIdRouteField()!=null &&

            parameters.getIdRouteField() instanceof FeatureAttributeDescriptor){

            this.fieldIdRoute=parameters.getIdRouteField();

        }

        if (parameters.getModifiedGeometry()!=null &&

            parameters.getModifiedGeometry() instanceof Feature){

            this.editedFeature=(Feature)parameters.getModifiedGeometry();

        }

    }

    public void clear() {

        if (cmbRoute!=null){

            this.cmbRoute.setSelectedItem(0);

        }

    }

    /**

     * Returns true if selectedIdRoute is contained in layer

     * @param layer

     * @param selectedIdRoute

     * @return

     */

    private static boolean isCorrectIdRoute(FLayer layer, FeatureAttributeDescriptor selectedIdRoute){

     // Validates is FLyrVect

        FLyrVect lyrVect = null;

        if (layer instanceof FLyrVect) {

            lyrVect = (FLyrVect) layer;

        } else

            return false;

        try {

            if (lyrVect != null) {

                    FeatureStore featureStore = lyrVect.getFeatureStore();

                    try {

                        FeatureType type = featureStore.getDefaultFeatureType();

                        FeatureAttributeDescriptor[] attributeDescriptors =

                            type.getAttributeDescriptors();

                        for (int i = 0; i < attributeDescriptors.length; i++) {

                            FeatureAttributeDescriptor featureAttributeDescriptor =

                                attributeDescriptors[i];

                            if(featureAttributeDescriptor.equals(selectedIdRoute)){

                                logger.debug("SelectedIdRoute founded in layer");

                                return true;

                            }

                        }

                    } catch (DataException e1) {

                        logger.warn(new StringBuilder()

                            .append(

                                "Error getting default feature type from layer ")

                            .append(lyrVect.getName()).toString(), e1);

                    }

            }

        } catch (Exception e) {

            logger.error("Can't get linear vector layers", e);

        }

        return false;

    }

    private static FeatureSet getSelectedFeatures(FLayer layer) {

        FLyrVect lyrVect = null;

        if (layer instanceof FLyrVect) {

            lyrVect = (FLyrVect) layer;

        } else

            return null;

        FeatureStore featureStore=lyrVect.getFeatureStore();

        if(featureStore!=null){

            try {

                FeatureSelection selectedFeatures= featureStore.getFeatureSelection();

                if (selectedFeatures!=null && !selectedFeatures.isEmpty()){

                    return selectedFeatures;

                }else{

                    //If there is not selected features, all features are used

                    return featureStore.getFeatureSet();

                }

            } catch (DataException e) {

                logger.warn("Can't get selected features", e);

            }

        }

        return null;

    }

}