Application: gvSIG desktop » gvSIG Linear Reference System

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.lrs.lib</artifactId>

    <version>1.0.3</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.lrs.lib.impl</artifactId>

  <version>1.0.3</version>

  <name>org.gvsig.lrs.lib.impl</name>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.lrs.lib.api</artifactId>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.dal.api</artifactId>

    </dependency>

    <dependency>

     <groupId>org.gvsig</groupId>

     <artifactId>org.gvsig.fmap.dal.file.shp</artifactId>

    </dependency>

  </dependencies>

</project>

org.gvsig.lrs.lib.impl.DefaultLrsAlgorithmsLibrary

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.lrs.lib.impl;

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

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

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

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

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

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

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

/**

 * @author dmartinez

 *

 */

public class DefaultLrsEditRouteCalibrationSelectIdRouteAlgorithmParams implements LrsEditRouteCalibrationSelectIdRouteAlgorithmParams {

    private FeatureAttributeDescriptor idRouteField;

    private final String NAME = "LrsEditRouteCalibrationSelectIdRouteAlgorithm";

    private final String DESCRIPTION = "Algorithm to select id route to edit calibration with linear reference system.";

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmParams#getName()

     */

    public String getName() {

        return NAME;

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmParams#getDescription()

     */

    public String getDescription() {

        return DESCRIPTION;

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsCreateRouteAlgorithmParams#getIdRouteField()

     */

    public FeatureAttributeDescriptor getIdRouteField() {

        return idRouteField;

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsCreateRouteAlgorithmParams#setIdRouteField(org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor)

     */

    public void setIdRouteField(FeatureAttributeDescriptor idRouteField) {

        this.idRouteField = idRouteField;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.lrs.lib.impl;

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

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

import org.gvsig.fmap.geom.type.GeometryTypeNotValidException;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

/**

 * @author fdiaz

 *

 */

public class DefaultLrsAlgorithmsManager implements LrsAlgorithmsManager {

    /* (non-Javadoc)

     * @see org.gvsig.tools.service.Manager#createServiceParameters(java.lang.String)

     */

    public DynObject createServiceParameters(String serviceName) throws ServiceException {

        // TODO Auto-generated method stub

        return null;

    }

    /* (non-Javadoc)

     * @see org.gvsig.tools.service.Manager#getService(org.gvsig.tools.dynobject.DynObject)

     */

    public Service getService(DynObject parameters) throws ServiceException {

        // TODO Auto-generated method stub

        return null;

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmsManager#createLrsAlgorithm(org.gvsig.lrs.lib.api.LrsAlgorithmParams)

     */

    public LrsAlgorithm createLrsAlgorithm(LrsAlgorithmParams params) {

        if(params instanceof LrsCreateRouteAlgorithmParams){

            return new LrsCreateRouteAlgorithm((LrsCreateRouteAlgorithmParams)params);

        }

        if(params instanceof LrsCalibrateRouteAlgorithmParams){

            return new LrsCalibrateRouteAlgorithm((LrsCalibrateRouteAlgorithmParams)params);

        }

        if(params instanceof LrsGenerateDynamicSegmentationAlgorithmParams){

            return new LrsGenerateDynamicSegmentationAlgorithm((LrsGenerateDynamicSegmentationAlgorithmParams)params);

        }

        return null;

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmsManager#createLrsCreateRouteAlgorithmParams()

     */

    public LrsCreateRouteAlgorithmParams createLrsCreateRouteAlgorithmParams() {

        return new DefaultLrsCreateRouteAlgorithmParams();

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmsManager#createLrsCalibrateRouteAlgorithmParams()

     */

    public LrsCalibrateRouteAlgorithmParams createLrsCalibrateRouteAlgorithmParams() {

        return new DefaultLrsCalibrateRouteAlgorithmParams();

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmsManager#createLrsEditRouteCalibrationAlgorithmParams()

     */

    public LrsEditRouteCalibrationAlgorithmParams createLrsEditRouteCalibrationAlgorithmParams() {

        return new DefaultLrsEditRouteCalibrationAlgorithmParams();

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmsManager#createLrsEditRouteCalibrationSelectIdRouteAlgorithmParams()

     */

    public LrsEditRouteCalibrationSelectIdRouteAlgorithmParams createLrsEditRouteCalibrationSelectIdRouteAlgorithmParams() {

        return new DefaultLrsEditRouteCalibrationSelectIdRouteAlgorithmParams();

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmsManager#createLrsShowMeasuresAlgorithmParams()

     */

    public LrsShowMeasuresAlgorithmParams createLrsShowMeasuresAlgorithmParams() {

        return new DefaultLrsShowMeasuresAlgorithmParams();

    }

    /* (non-Javadoc)

     * @see org.gvsig.lrs.lib.api.LrsAlgorithmsManager#createLrsGenerateDynamicSegmentationAlgorithmParams()

     */

    public LrsGenerateDynamicSegmentationAlgorithmParams createLrsGenerateDynamicSegmentationAlgorithmParams() {

        return new DefaultLrsGenerateDynamicSegmentationAlgorithmParams();

    }

    public void createNewShape(FeatureType sourceFeatureType,

        int outputLayerType, String outputLayerPath, IProjection projection) throws ValidateDataParametersException, DataException, GeometryTypeNotSupportedException, GeometryTypeNotValidException {

        DataManager dataManager = DALLocator.getDataManager();

        DataServerExplorerParameters eparams =

            dataManager.createServerExplorerParameters("FilesystemExplorer");

        eparams.setDynValue("initialpath", "/data");

        DataServerExplorer serverExplorer =

            dataManager.openServerExplorer(eparams.getExplorerName(), eparams);

        NewFeatureStoreParameters sparams =

            (NewFeatureStoreParameters) serverExplorer

                .getAddParameters("Shape");

        EditableFeatureType newEditableFeatureType =

            (EditableFeatureType) sparams.getDefaultFeatureType();

        // Iterate over feature type. Don't add geometry fields.

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

            String fieldName =

                sourceFeatureType.getAttributeDescriptor(i).getName();

            int fieldType =

                sourceFeatureType.getAttributeDescriptor(i).getType();

            if (fieldType != DataTypes.GEOMETRY) {

                newEditableFeatureType.add(fieldName, fieldType);

            }

        }

        // Add new geometry field with new geometry type

        FeatureAttributeDescriptor geometryAttribute =

            (FeatureAttributeDescriptor) sourceFeatureType

                .get(sourceFeatureType.getDefaultGeometryAttributeName());

        EditableFeatureAttributeDescriptor newGeometryAttribute =

            newEditableFeatureType.add(geometryAttribute.getName(),

                geometryAttribute.getType(), geometryAttribute.getSize());

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        GeometryType sourceLayerGeomType =

            sourceFeatureType.getDefaultGeometryAttribute().getGeomType();

        GeometryType outputLayerGeomType =

            geoManager.getGeometryType(outputLayerType,

                sourceLayerGeomType.getSubType());

        newGeometryAttribute.setGeometryType(outputLayerGeomType);

        newGeometryAttribute.setPrecision(geometryAttribute.getPrecision());

        newGeometryAttribute.setDefaultValue(geometryAttribute

            .getDefaultValue());

        newEditableFeatureType

            .setDefaultGeometryAttributeName(geometryAttribute.getName());

        if(!StringUtils.endsWithIgnoreCase(outputLayerPath, ".shp")){

            outputLayerPath = new StringBuilder().append(outputLayerPath).append(".shp").toString();

        }

        sparams.setDynValue("geometryType", null);

        sparams.setDynValue("shpfile", outputLayerPath);

        sparams.setDynValue("CRS", projection);

        sparams.setDynValue("useNullGeometry", false);

        sparams.setDefaultFeatureType(newEditableFeatureType);

        sparams.validate();

        serverExplorer.add("Shape", sparams, true);

    }

    public FeatureStore getFeatureStore(String outputLayerPath,

        IProjection projection) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException{

        DataManager dataManager = DALLocator.getDataManager();

        DataStoreParameters dataStoreParams =

            dataManager.createStoreParameters("Shape");

        dataStoreParams.setDynValue("shpfile", outputLayerPath);

        dataStoreParams.setDynValue("CRS", projection);

        dataStoreParams.setDynValue("useNullGeometry", false);

        dataStoreParams.validate();

        return (FeatureStore) dataManager.openStore("Shape", dataStoreParams);

    }

    public MeasuresCalculator createMeasuresCalculator(Geometry geometry, boolean ignoreSpatialGaps) {

        return new DefaultMeasuresCalculator(geometry, ignoreSpatialGaps);

    }

    @Override

    public Point getMPointFromGeometry(Geometry geom, double m) throws CreateGeometryException, LocatorException {

        List<Point> points = LrsAlgorithmUtils.getPointsWithM( geom,  m);

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

            return points.get(0);

        }

        return null;

    }

    /**

     * Given a point without m in a M-Geometry, returns the point with the m-value

     * @param geom

     * @param pointNoM

     * @return

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     * @throws CreateGeometryException

     */

    @Override

    public Point getMPointFromGeometry(Geometry geom, Point pointNoM) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException{

        final Double PRECISION = new Double(1.0e-5);

        final int MDIMENSION = geom.getDimension() - 1;

        List<Line> lines = LrsAlgorithmUtils.extractLines(geom);

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

            Line line = lines.get(i);

            if (line.isWithinDistance(pointNoM, PRECISION)) {

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

                    Point vertex = line.getVertex(j);

                    Point nextVertex;

                    if (j + 1 < line.getNumVertices()) {

                        nextVertex = line.getVertex(j + 1);

                    } else {

                        nextVertex = null;

                    }

                    //The point and the first vertex are the same

                    if (LrsAlgorithmUtils.equalPoints(vertex, pointNoM) || vertex.distance(pointNoM) <= PRECISION) {

                        Double m=vertex.getCoordinateAt(MDIMENSION);

                        GeometryManager geomanager = GeometryLocator.getGeometryManager();

                        Point mPoint = (Point) geomanager

                                .create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2DM);

                        mPoint.setX(pointNoM.getX());

                        mPoint.setY(pointNoM.getY());

                        mPoint.setCoordinateAt(MDIMENSION, m);

                        return mPoint;

                    }else{

                        if (nextVertex != null

                            && !LrsAlgorithmUtils.equalPoints(nextVertex, pointNoM)

                            && vertex.distance(pointNoM) > PRECISION

                            && nextVertex.distance(pointNoM) > PRECISION) {

                            GeometryManager geomanager = GeometryLocator.getGeometryManager();

                            Line segment = (Line) geomanager

                                    .create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

                            segment.addVertex(vertex);

                            segment.addVertex(nextVertex);

                            if (segment.isWithinDistance(pointNoM, PRECISION)) {

                                double distanceFirstVertex = 0;

                                double distanceNextVertex = nextVertex.distance(vertex);

                                double distanceToFixedPoint = vertex.distance(pointNoM);

                                Double m = LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(

                                    distanceFirstVertex,

                                    distanceNextVertex,

                                    vertex.getCoordinateAt(MDIMENSION),

                                    nextVertex.getCoordinateAt(MDIMENSION),

                                    distanceToFixedPoint);

                                Point mPoint = (Point) geomanager

                                        .create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2DM);

                                mPoint.setX(pointNoM.getX());

                                mPoint.setY(pointNoM.getY());

                                mPoint.setCoordinateAt(MDIMENSION, m);

                                return mPoint;

                            }

                        }

                    }

                }

            }

        }

        return null;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.lrs.lib.impl;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map.Entry;

import java.util.SortedMap;

import java.util.TreeMap;

import org.apache.commons.lang3.mutable.MutableInt;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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.NewFeatureStoreParameters;

import org.gvsig.fmap.geom.Geometry;

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

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.CreateEnvelopeException;

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 * @author fdiaz

 *

 */

public class LrsCreateRouteAlgorithm implements LrsAlgorithm {

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

    private LrsCreateRouteAlgorithmParams parameters;

    /**

     *

     */

    public LrsCreateRouteAlgorithm(LrsCreateRouteAlgorithmParams parameters) {

        this.parameters = parameters;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.tools.service.Service#getManager()

     */

    public Manager getManager() {

        return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.lrs.lib.api.LrsAlgorithm#getParams()

     */

    public LrsAlgorithmParams getParams() {

        return this.parameters;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.lrs.lib.api.LrsAlgorithm#execute(org.gvsig.tools.task.

     * SimpleTaskStatus)

     */

    public void execute(SimpleTaskStatus taskStatus) throws LrsException {

        NewFeatureStoreParameters newFeatureStoreParameters = parameters.getNewFeatureStoreParameters();

        FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        FeatureAttributeDescriptor idRouteField = parameters.getIdRouteField();

        FeatureAttributeDescriptor fromMeasureField = parameters.getFromMeasureField();

        FeatureAttributeDescriptor toMeasureField = parameters.getToMeasureField();

        logger.info(parameters.toString());

        taskStatus.setTitle(parameters.getName());

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        taskStatus.message(i18nManager.getTranslation("grouping_features"));

        try {

            final String routeFieldName = idRouteField.getName();

            final String fromFieldName;

            final DataType fromDataType;

            final DataType toDataType;

            if (fromMeasureField != null) {

                fromFieldName = fromMeasureField.getName();

                fromDataType = fromMeasureField.getDataType();

            } else {

                fromFieldName = null;

                fromDataType = null;

            }

            final String toFieldName;

            if (toMeasureField != null) {

                toFieldName = toMeasureField.getName();

                toDataType = toMeasureField.getDataType();

            } else {

                toFieldName = null;

                toDataType = null;

            }

            FeatureStore newFeatureStore =

                LrsAlgorithmUtils.createNewDataStore(newFeatureStoreParameters, idRouteField);

            FeatureSet sourceFeatures;

            if (sourceFeatureStore.getFeatureSelection().getSize() > 0) {

                sourceFeatures = sourceFeatureStore.getFeatureSelection();

            } else {

                sourceFeatures = sourceFeatureStore.getFeatureSet();

            }

            final SortedMap<String, List<MSegment>> featuresMap = new TreeMap<String, List<MSegment>>();

            final MutableInt contId = new MutableInt(0);

            sourceFeatures.accept(new Visitor() {

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

                    Feature feature = (Feature) obj;

                    String routeName = (String) feature.get(routeFieldName);

                    Object objFrom = null;

                    Object objTo = null;

                    if (fromFieldName != null) {

                        objFrom = feature.get(fromFieldName);

                    }

                    if (toFieldName != null) {

                        objTo = feature.get(toFieldName);

                    }

                    if (!featuresMap.containsKey(routeName)) {

                        featuresMap.put(routeName, new ArrayList<MSegment>());

                    }

                    List<MSegment> mList = featuresMap.get(routeName);

                    MSegment mSegment = new MSegment();

                    mSegment.geometry = feature.getDefaultGeometry().cloneGeometry();

                    mSegment.fromValue = LrsAlgorithmUtils.getAsDouble(objFrom, fromDataType);

                    mSegment.toValue = LrsAlgorithmUtils.getAsDouble(objTo, toDataType);

                    mSegment.id = contId.getValue();

                    contId.increment();

                    mList.add(mSegment);

                    featuresMap.put(routeName, mList);

                }

            });

            taskStatus.setRangeOfValues(0, featuresMap.size());

            int taskCount = 0;

            newFeatureStore.edit(FeatureStore.MODE_FULLEDIT);

            for (Entry<String, List<MSegment>> entry : featuresMap.entrySet()) {

                String routeName = entry.getKey();

                List<MSegment> mList = entry.getValue();

                EditableFeature newFeature = newFeatureStore.createNewFeature(true);

                newFeature.set(routeFieldName, routeName);

                Geometry route = createGeometryRoute(mList);

                newFeature.setDefaultGeometry(route);

                newFeatureStore.update(newFeature);

                taskCount++;

                taskStatus.setCurValue(taskCount);

            }

            newFeatureStore.finishEditing();

        } catch (Exception e1) {

            taskStatus.abort();

            throw new LrsCreateRouteException("Error creating routes", e1);

        }

        taskStatus.terminate();

    }

    private Geometry createGeometryRoute(List<MSegment> mList) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException, CreateEnvelopeException {

        LrsSourceOfMeasures sourceOfMeasures = parameters.getSourceOfMeasures();

        Geometry geometryResult = null;

        simplifyMultilines(mList);

        switch (sourceOfMeasures) {

        case ONE_FIELD:

            geometryResult = calculateGeometryByOneField(mList);

            break;

        case TWO_FIELDS:

            geometryResult = calculateGeometryByTwoField(mList);

            break;

        case LENGTH:

        default:

            geometryResult = calculateGeometryByLength(mList);

            break;

        }

        geometryResult = applyOffsetAndFactor(geometryResult);

        return geometryResult;

    }

    private Geometry calculateGeometryByLength(List<MSegment> mList) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException, CreateEnvelopeException {

        boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

        for (MSegment mSegment : mList) {

            mSegment.fromValue = LrsAlgorithmUtils.getGeometryLength(mSegment.geometry, ignoreSpatialGaps);

        }

        return calculateGeometryByOneField(mList);

    }

    private Geometry calculateGeometryByOneField(List<MSegment> mList) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException, CreateEnvelopeException {

        boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

        GeometryManager gmanager = GeometryLocator.getGeometryManager();

        try {

            mList = sortMList(mList);

        } catch (Exception e) {

            logger.warn("Geometries couldn't be ordered");

        }

        MultiLine auxMultiLine = (MultiLine) gmanager.create(Geometry.TYPES.MULTILINE, Geometry.SUBTYPES.GEOM2DM);

        Point previousPoint = null;

        double previousM = 0.0;

        for (MSegment mSegment : mList) {

            Geometry geom = mSegment.geometry;

            Double geometryLength = mSegment.getLength(ignoreSpatialGaps);

            if (geom instanceof Line) {

                Line line = (Line) geom;

                Line auxLine = (Line) gmanager.create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

                double distance = 0.0;

                double firstM = previousM;

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

                    Point vertex = line.getVertex(i);

                    Point point = (Point) gmanager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2DM);

                    point.setX(vertex.getX());

                    point.setY(vertex.getY());

                    if (i == 0 && previousPoint != null) {

                        boolean gap = false;

                        if (areInSame2DLocation(previousPoint, vertex)) {

                            // Buscamos si ha sido una bifurcaci?n

                            Point fork = getPossibleFork(auxMultiLine, vertex);

                            if(fork!=null){

                                previousPoint = fork;

                                // OJO, aqu? previousPoint pasa a ser 2DM

                            }

                        } else {

                            // En caso de salto, calculamos el previousPoint

                            // buscando el v?rtice m?s cercano

                            previousPoint = getClosestVertex(auxMultiLine, vertex);

                            // OJO, aqu? previousPoint pasa a ser 2DM

                            gap = true;

                        }

                        previousM = previousPoint.getCoordinateAt(previousPoint.getDimension() - 1);

                        if (i == 0) {

                            firstM = previousM;

                        }

                        if (gap && !ignoreSpatialGaps) {

                            Point previousVertex = getPreviousVertexToPoint(auxMultiLine, previousPoint);

                            if(areInSame2DLocation(previousPoint,previousVertex)){

                                Point nextVertex = getNextVertexToPoint(auxMultiLine, previousPoint);

                                double distanceToNextPoint = nextVertex.distance(previousPoint);

                                previousM = LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, distanceToNextPoint,

                                    previousM, nextVertex.getCoordinateAt(previousVertex.getDimension() - 1),

                                        previousPoint.distance(point));

                            } else {

                                double distanceToPreviousPoint = previousVertex.distance(previousPoint);

                                previousM = LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, distanceToPreviousPoint,

                                        previousVertex.getCoordinateAt(previousVertex.getDimension() - 1), previousM,

                                        distanceToPreviousPoint + previousPoint.distance(point));

                            }

                            firstM = previousM;

                        }

                    }

                    if (i != 0) {

                        distance += previousPoint.distance(vertex);

                    }

                    double m =

                        LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, geometryLength, firstM, firstM + mSegment.fromValue,

                            distance);

                    point.setCoordinateAt(point.getDimension() - 1, m);

                    auxLine.addVertex(point);

                    previousM = m;

                    previousPoint = vertex;

                }

                auxMultiLine.addPrimitive(auxLine);

            } else if (geom instanceof MultiLine) {

                MultiLine multiline = (MultiLine) geom;

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

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

                    Line auxLine = (Line) gmanager.create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

                    double distance = 0.0;

                    double firstM = previousM;

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

                        Point vertex = line.getVertex(j);

                        Point point = (Point) gmanager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2DM);

                        point.setX(vertex.getX());

                        point.setY(vertex.getY());

                        if (j == 0 && previousPoint != null) {

                            boolean gap = false;

                            if (areInSame2DLocation(previousPoint, vertex)) {

                                // Buscamos si ha sido una bifurcaci?n

                                previousPoint = getPossibleFork(auxMultiLine, vertex);

                                // OJO, aqu? previousPoint pasa a ser 2DM

                            } else {

                                // En caso de salto, calculamos el previousPoint

                                // buscando el v?rtice m?s cercano

                                previousPoint = getClosestVertex(auxMultiLine, vertex);

                                // OJO, aqu? previousPoint pasa a ser 2DM

                                gap = true;

                            }

                            previousM = previousPoint.getCoordinateAt(previousPoint.getDimension() - 1);

                            if (j == 0) {

                                firstM = previousM;

                            }

                            if (gap && !ignoreSpatialGaps) {

                                Point previousVertex = getPreviousVertexToPoint(auxMultiLine, previousPoint);

                                previousVertex.getCoordinateAt(previousVertex.getDimension() - 1);

                                previousM =

                                    LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, previousVertex.distance(previousPoint),

                                        previousVertex.getCoordinateAt(previousVertex.getDimension() - 1), previousM,

                                        previousVertex.distance(previousPoint) + previousPoint.distance(point));

                                firstM = previousM;

                            }

                        }

                        if (j != 0) {

                            distance += previousPoint.distance(vertex);

                        }

                        double m =

                            LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, geometryLength, firstM, firstM + mSegment.fromValue,

                                distance);

                        point.setCoordinateAt(point.getDimension() - 1, m);

                        auxLine.addVertex(point);

                        previousM = m;

                        previousPoint = vertex;

                    }

                    multiline.addPrimitive(auxLine);

                }

            } else {

                // NO deber?a entrar por aqu?

                logger.warn("A not LINE nor MULTILINE geometry found in CreateRoute process");

            }

        }

        return compactMultiLine(auxMultiLine);

    }

    /**

     * Joins consecutive adjacent lines into the multiLine that are not involved in a fork

     *

     * @param auxMultiLine

     * @return

     * @throws CreateGeometryException

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    private MultiLine compactMultiLine(MultiLine multiLine) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        MultiLine result =  (MultiLine) geomManager.create(multiLine.getGeometryType());

        int primitivesNumber = multiLine.getPrimitivesNumber();

        List<Line> lines = new ArrayList<Line>(primitivesNumber);

        for(int i = 0; i < primitivesNumber; i++){

            lines.add((Line)multiLine.getPrimitiveAt(i).cloneGeometry());

        }

        if (lines.size() > 0) {

            Line line = lines.get(0);

            while (lines.size() > 1) {

                Point lastVertex = line.getVertex(line.getNumVertices() - 1);

                lines.remove(0);

                // Borramos la primera linea de la lista ==> lines.get(0) es la siguiente

                Line line2 = lines.get(0);

                // Si el ultimo punto de la primera

                if (lastVertex.equals(line2.getVertex(0)) && !bifurcation(lastVertex, lines)) {

                    for(int i = 1; i<line2.getNumVertices(); i++){

                        line.addVertex(line2.getVertex(i));

                    }

                } else {

                    result.addPrimitive(line);

                    line = line2;

                }

            }

            result.addPrimitive(line);

        }

        return result;

    }

    /**

     * Checks if a bifurcation occurs at one point.

     *

     * @param point

     * @param lines

     * @return

     */

    private boolean bifurcation(Point point, List<org.gvsig.fmap.geom.primitive.Line> lines) {

        // Saltamos la primera linea

        for(int i = 1; i<lines.size(); i++){

            if(point.equals(lines.get(i).getVertex(0))){

                return true;

            }

        }

        return false;

    }

    /**

     * Returns the previous vertex to a point.

     *

     * @param auxMultiLine

     * @param previousPoint

     * @return

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     * @throws CreateGeometryException

     */

    private Point getPreviousVertexToPoint(MultiLine multiLine, Point point) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

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

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

            if (line.intersects(point)) {

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

                    if (point.equals(line.getVertex(j + 1))) {

                        return line.getVertex(j);

                    }

                    Line auxLine = (Line) geomManager.create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

                    auxLine.addVertex(line.getVertex(j));

                    auxLine.addVertex(line.getVertex(j + 1));

                    if (auxLine.intersects(point)) {

                        return line.getVertex(j);

                    }

                }

            }

        }

        return null;

    }

    /**

     * Returns the next vertex to a point.

     *

     * @param auxMultiLine

     * @param previousPoint

     * @return

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     * @throws CreateGeometryException

     */

    private Point getNextVertexToPoint(MultiLine multiLine, Point point) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

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

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

            if (line.intersects(point)) {

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

                    if (point.equals(line.getVertex(j))) {

                        return line.getVertex(j+1);

                    }

                    Line auxLine = (Line) geomManager.create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

                    auxLine.addVertex(line.getVertex(j));

                    auxLine.addVertex(line.getVertex(j + 1));

                    if (auxLine.intersects(point)) {

                        return line.getVertex(j+1);

                    }

                }

            }

        }

        return null;

    }

    /**

     * Checks if a bifurcation occurs at one point and return the vertex with maximum M

     *

     * @param multiLine

     * @param vertex

     * @return

     */

    private Point getPossibleFork(MultiLine multiLine, Point point) {

        List<Point> vertices = new ArrayList<Point>();

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

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

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

                Point vertex = line.getVertex(j);

                if (areInSame2DLocation(vertex, point)) {

                    vertices.add(vertex);

                }

            }

        }

        if (vertices.size() > 0) {

            Double maxM = Double.NEGATIVE_INFINITY;

            Point forked = null;

            for (Iterator<Point> iterator = vertices.iterator(); iterator.hasNext();) {

                Point vertex = (Point) iterator.next();

                double m = vertex.getCoordinateAt(vertex.getDimension() - 1);

                if (m > maxM) {

                    maxM = m;

                    forked = vertex;

                }

            }

            return forked;

        }

        return null;

    }

    /**

     * Compares x & y coordinates of a point.

     *

     * @param p1

     * @param p2

     * @return

     */

    private boolean areInSame2DLocation(Point p1, Point p2) {

        return ((p1.getX() == p2.getX()) && (p1.getY() == p2.getY()));

    }

    /**

     * Returns the vertex of the multiline closest to a point

     *

     * @param mGeometry

     * @param vertex

     * @return

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     * @throws CreateEnvelopeException

     */

    private Point getClosestVertex(MultiLine multiLine, Point point) throws CreateEnvelopeException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        Point result = null;

        double minDistance = Double.POSITIVE_INFINITY;

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

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

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

                Point vertex = line.getVertex(j);

                double distance = point.distance(vertex);

                if (distance <= minDistance) {

                    minDistance = distance;

                    result = vertex;

                }

            }

        }

        return result;

    }

    /**

     * Returns a multiline calculate by two field method

     *

     * @param mList

     * @return

     * @throws CreateGeometryException

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    private MultiLine calculateGeometryByTwoField(List<MSegment> mList) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomanager = GeometryLocator.getGeometryManager();

        MultiLine mGeometry = (MultiLine) geomanager.create(Geometry.TYPES.MULTILINE, Geometry.SUBTYPES.GEOM2DM);

        for (MSegment mSegment : mList) {

            Geometry geometry = mSegment.geometry;

            List<Line> geometryLines = extractLines(geometry);

            Double geometryLength = LrsAlgorithmUtils.getGeometryLength(geometry);

            Double geometryMFirstPoint = mSegment.fromValue;

            Double geometryMLastPoint = mSegment.toValue;

            Double distance = Double.valueOf(0);

            for (Line line : geometryLines) {

                Double lineLength = getLineLength(line);

                Double mFirstPoint = LrsAlgorithmUtils.calculateM(geometryLength, geometryMFirstPoint, geometryMLastPoint, distance);

                distance += lineLength;

                Double mLastPoint = LrsAlgorithmUtils.calculateM(geometryLength, geometryMFirstPoint, geometryMLastPoint, distance);

                Line mLine = lineToMLine(line, mFirstPoint, mLastPoint);

                mGeometry.addPrimitive(mLine);

            }

        }

        return mGeometry;

    }

    /**

     * Converts a Line2D in a Line2DM filled it with proportional calculated M's

     *

     * @param line

     * @param minMValue

     * @param maxMValue

     * @return

     * @throws CreateGeometryException

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    private Line lineToMLine(Line line, Double minMValue, Double maxMValue) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomanager = GeometryLocator.getGeometryManager();

        Double lineLength = getLineLength(line);

        Line lineM = (Line) geomanager.create(Geometry.TYPES.LINE, Geometry.SUBTYPES.GEOM2DM);

        Double inLineDistance = Double.valueOf(0);

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

            Point vertex = line.getVertex(i);

            Point mVertex = (Point) geomanager.create(Geometry.TYPES.POINT, Geometry.SUBTYPES.GEOM2DM);

            mVertex.setX(vertex.getX());

            mVertex.setY(vertex.getY());

            Double mValue;

            if (i == 0)

                mValue = minMValue;

            else if (i == line.getNumVertices() - 1)

                mValue = maxMValue;

            else {

                Point previousVertex = line.getVertex(i - 1);

                inLineDistance += vertex.distance(previousVertex);

                mValue = LrsAlgorithmUtils.calculateM(lineLength, minMValue, maxMValue, inLineDistance);

            }

            mVertex.setCoordinateAt(mVertex.getDimension() - 1, mValue);

            lineM.addVertex(mVertex);

        }

        return lineM;

    }

    /**

     * Simplify the multilines in mList calling simplifyMultiline method

     *

     * @param mList

     * @throws CreateGeometryException

     * @throws LocatorException

     */

    private void simplifyMultilines(List<MSegment> mList) throws CreateGeometryException, LocatorException {

        for (MSegment mSegment : mList) {

            mSegment.geometry = simplifyMultiline(mSegment.geometry);

        }

    }

    /**

     * Simplify a Multiline ordering and joining her lines if can.

     *

     * @param geometry

     * @return

     * @throws CreateGeometryException

     * @throws LocatorException

     */

    private Geometry simplifyMultiline(Geometry geometry) throws CreateGeometryException, LocatorException {

        if (geometry instanceof MultiLine) {

            MultiLine multiline = (MultiLine) geometry;

            if (multiline.getPrimitivesNumber() == 1) {

                return multiline.getPrimitiveAt(0);

            } else {

                List<Line> simplifiedLines = new ArrayList<Line>();

                List<Line> complexLines = new ArrayList<Line>();

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

                    complexLines.add((Line) multiline.getPrimitiveAt(i));

                }

                Line line = null;

                while (complexLines.size() > 0) {

                    line = complexLines.remove(0);

                    int i = 0;

                    while (i < complexLines.size()) {

                        Line auxLine = complexLines.get(i);

                        Line unitedLine = unionAdjacentLines(line, auxLine);

                        if (unitedLine != null) {

                            line = unitedLine;

                            complexLines.remove(i);

                            i = 0;

                        } else {

                            i++;

                        }

                    }

                    simplifiedLines.add(line);

                }

                if (simplifiedLines.size() == 1) {

                    geometry = simplifiedLines.get(0);

                } else {

                    MultiLine simplifiedMultiLine =

                        (MultiLine) GeometryLocator.getGeometryManager().create(multiline.getGeometryType());

                    for (Line simpleLine : simplifiedLines) {

                        simplifiedMultiLine.addPrimitive(simpleLine);

                    }

                    return simplifiedMultiLine;

                }

            }

        }

        return geometry;

    }

    /**

     * Join two adjacent lines flipping it if necessary

     *

     * @param line1

     * @param line2

     * @return

     */

    private Line unionAdjacentLines(Line line1, Line line2) {

        if (line1 == null || line2 == null) {

            return null;

        }

        Line resultLine;

        try {

            resultLine = (Line) GeometryLocator.getGeometryManager().create(line1.getGeometryType());

        } catch (Exception e) {

            return null;

        }

        Point firstPointL1 = line1.getVertex(0);

        Point lastPointL1 = line1.getVertex(line1.getNumVertices() - 1);

        Point firstPointL2 = line2.getVertex(0);

        Point lastPointL2 = line2.getVertex(line2.getNumVertices() - 1);

        if (lastPointL1.equals(firstPointL2)) {

            resultLine = (Line) line1.cloneGeometry();

            for (int i = 1; i < line2.getNumVertices(); i++) {

                resultLine.addVertex((Point) line2.getVertex(i).cloneGeometry());

            }

            return resultLine;

        }

        if (lastPointL2.equals(firstPointL1)) {

            resultLine = (Line) line2.cloneGeometry();

            for (int i = 1; i < line1.getNumVertices(); i++) {

                resultLine.addVertex((Point) line1.getVertex(i).cloneGeometry());

            }

            return resultLine;

        }

        if (firstPointL1.equals(firstPointL2)) {

            for (int i = line1.getNumVertices() - 1; i >= 0; i--) {

                resultLine.addVertex((Point) line1.getVertex(i).cloneGeometry());

            }

            for (int i = 1; i < line2.getNumVertices(); i++) {

                resultLine.addVertex((Point) line2.getVertex(i).cloneGeometry());

            }

            return resultLine;

        }

        if (lastPointL1.equals(lastPointL2)) {

            resultLine = (Line) line1.cloneGeometry();

            for (int i = line2.getNumVertices() - 2; i >= 0; i--) {

                resultLine.addVertex((Point) line2.getVertex(i).cloneGeometry());

            }

            return resultLine;

        }

        return null;

    }

    /**

     * Sorts mList

     *

     * @param mList

     * @return

     * @throws CreateEnvelopeException

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    private List<MSegment> sortMList(List<MSegment> mList) throws CreateEnvelopeException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

        GeometryManager geomanager = GeometryLocator.getGeometryManager();

        Envelope envelope = geomanager.createEnvelope(Geometry.SUBTYPES.GEOM2D);

        for (MSegment mSegment : mList) {

            envelope.add(mSegment.geometry.getEnvelope());

        }

        Point origin = envelope.getLowerCorner();

        switch (coordinatePriority) {

        case DOWN_LEFT:

            break;

        case DOWN_RIGHT:

            Double maxX = envelope.getMaximum(DIMENSIONS.X);

            origin.setX(maxX);

            break;

        case UP_LEFT:

            Double maxY = envelope.getMaximum(DIMENSIONS.Y);

            origin.setY(maxY);

            break;

        case UP_RIGHT:

            origin = envelope.getUpperCorner();

            break;

        default:

            break;

        }

        List<Stretch> stretches = createStretches(mList, origin);

        stretches = sortStretches(stretches, origin);

        return extractSegmentsFromStretches(stretches);

    }

    /**

     * Extracts segment from stretches and returns a list of segment.

     *

     * @param stretches

     * @return

     */

    private List<MSegment> extractSegmentsFromStretches(List<Stretch> stretches) {

        List<MSegment> result = new ArrayList<MSegment>();

        for (Stretch stretch : stretches) {

            for (int i = 0; i < stretch.getSegmentNumber(); i++) {

                result.add(stretch.getSegment(i));

            }

        }

        return result;

    }

    /**

     * Sort the stretches

     *

     * @param stretches

     * @param origin

     * @return

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    private List<Stretch> sortStretches(List<Stretch> stretches, Point origin)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        List<Stretch> result = new ArrayList<Stretch>();

        Point originPoint = origin;

        while (result.size() < stretches.size()) {

            // Buscamos tramos que sean adyacentes al origin

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

                addUnvisitedAdjacentStretches(stretches, result, originPoint);

            }

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

                result.add(getNearestUnvisitedStretch(stretches, originPoint, result));

            }

            boolean addedAdjacentStretches = true;

            while (addedAdjacentStretches) {

                addedAdjacentStretches = false;

                int visitedNumber = result.size();

                for (int i = 0; i < visitedNumber; i++) {

                    Stretch visited = result.get(i);

                    addUnvisitedAdjacentStretches(stretches, result, visited.getFinalPoint());

                }

                addedAdjacentStretches = (visitedNumber < result.size());

            }

            int visitedNumber = result.size();

            Stretch nearest = null;

            for (int i = visitedNumber - 1; i >= 0; i--) {

                if(nearest!=null){

                    break;

                }

                Stretch visited = result.get(i);

                for (int j=0; j<visited.getSegmentNumber(); j++) {

                    if(nearest!=null){

                        break;

                    }

                    MSegment segment = visited.getSegment(j);

                    Geometry geom = segment.geometry;

                    if(geom instanceof Line){

                        Line line = (Line)geom;

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

                            nearest = getNearestUnvisitedStretch(stretches, line.getVertex(k), result);

                            if (nearest != null) {

                                result.add(nearest);

                                break;

                            }

                        }

                    } else { //geom is multiline

                        MultiLine multiline = (MultiLine)geom;

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

                            if(nearest!=null){

                                break;

                            }

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

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

                                nearest = getNearestUnvisitedStretch(stretches, line.getVertex(k), result);

                                if (nearest != null) {

                                    result.add(nearest);

                                    break;

                                }

                            }

                        }

                    }

                }

            }

        }

        return result;

    }

    /**

     * Adds unvisited adjacent stretches to the visited list

     *

     * @param stretches

     * @param visited

     * @param originPoint

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    private void addUnvisitedAdjacentStretches(List<Stretch> stretches, List<Stretch> visited, Point originPoint)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        for (Stretch stretch : stretches) {

            if (!visited.contains(stretch)) {

                if (areInSame2DLocation(stretch.getInitialPoint(), originPoint)) {

                    visited.add(stretch);

                } else if (areInSame2DLocation(stretch.getFinalPoint(), originPoint)) {

                    visited.add(stretch.flip());

                }

            }

        }

    }

    /**

     * Returns the unvisited stretch nearest to a point

     *

     * @param stretches

     * @param origin

     * @param visited

     * @return

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    private Stretch getNearestUnvisitedStretch(List<Stretch> stretches, Point origin, List<Stretch> visited)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        double minDistance = Double.POSITIVE_INFINITY;

        Stretch nearest = null;

        boolean needFlip = false;

        for (Stretch stretch : stretches) {

            if (!visited.contains(stretch)) {

                Double initialDistance = origin.distance(stretch.getInitialPoint());

                if (initialDistance < minDistance) {

                    minDistance = initialDistance;

                    nearest = stretch;

                    needFlip = false;

                }

                Double finalDistance = origin.distance(stretch.getFinalPoint());

                if (finalDistance < minDistance) {

                    minDistance = finalDistance;

                    nearest = stretch;

                    needFlip = true;

                }

            }

        }

        if (needFlip && nearest != null) {

            nearest.flip();

        }

        return nearest;

    }

    /**

     * Creates stretches from mList and returns a list of stretches

     *

     * @param mList

     * @param origin

     * @return

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    private List<Stretch> createStretches(List<MSegment> mList, Point origin)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        List<MSegment> addedMSegment = new ArrayList<LrsCreateRouteAlgorithm.MSegment>();

        List<Stretch> stretches = new ArrayList<Stretch>();

        while (addedMSegment.size() < mList.size()) {

            for (MSegment mSegment : mList) {

                if (!addedMSegment.contains(mSegment)) {

                    Stretch stretch = new Stretch();

                    stretches.add(stretch);

                    stretch.addSegment(mSegment);

                    addedMSegment.add(mSegment);

                    List<MSegment> initialNextSegments =

                        mSegment.searchNextSegments(stretch.getInitialPoint(), mList);

                    do {

                        if (initialNextSegments.size() == 1) {

                            MSegment previousSegment = initialNextSegments.get(0);

                            if (!addedMSegment.contains(previousSegment)) {

                                if (!previousSegment.getFinalPoint().equals(stretch.getInitialPoint())) {

                                    previousSegment.flip();

                                }

                                stretch.addSegment(0, previousSegment);

                                addedMSegment.add(previousSegment);

                                initialNextSegments =

                                    previousSegment.searchNextSegments(stretch.getInitialPoint(), mList);

                            } else {

                                break;

                            }

                        } else {

                            break;

                        }

                    } while (initialNextSegments.size() == 1);

                    List<MSegment> finalNextSegments =

                        mSegment.searchNextSegments(stretch.getFinalPoint(), mList);

                    do {

                        if (finalNextSegments.size() == 1) {