Application: gvSIG desktop » gvSIG Linear Reference System

/*

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

 *

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

 * SVN Id   : $Id$

 */

package org.gvsig.lrs.lib.impl;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

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

import org.gvsig.fmap.dal.DataTypes;

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

import org.gvsig.fmap.dal.store.shp.SHPNewStoreParameters;

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.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.lrs.lib.api.exceptions.LrsCreateRouteException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public class LrsAlgorithmUtils {

    static protected FeatureStore createNewDataStore(NewFeatureStoreParameters newFeatureStoreParameters,

        FeatureAttributeDescriptor idRouteField) throws Exception {

        return createNewDataStore(newFeatureStoreParameters, idRouteField, Geometry.TYPES.MULTILINE);

    }

    static protected FeatureStore createNewDataStore(NewFeatureStoreParameters newFeatureStoreParameters,

        FeatureAttributeDescriptor idRouteField, int type) throws Exception {

        try {

            SHPNewStoreParameters shapeStoreParams = (SHPNewStoreParameters) newFeatureStoreParameters;

            File file = shapeStoreParams.getFile();

            String filePath = file.getPath().substring(0, file.getPath().lastIndexOf(File.separator));

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorerParameters serverParams =

                dataManager.createServerExplorerParameters("FilesystemExplorer");

            serverParams.setDynValue("initialpath", filePath);

            DataServerExplorer serverExplorer =

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

            EditableFeatureType featureType = (EditableFeatureType) shapeStoreParams.getDefaultFeatureType();

            featureType.add(idRouteField.getName(), idRouteField.getType(), idRouteField.getSize());

            EditableFeatureAttributeDescriptor geometryField = featureType.add("Geometry", DataTypes.GEOMETRY);

            GeometryType geometryType =

                GeometryLocator.getGeometryManager().getGeometryType(type, Geometry.SUBTYPES.GEOM2DM);

            geometryField.setGeometryType(geometryType);

            featureType.setDefaultGeometryAttributeName("Geometry");

            shapeStoreParams.setDefaultFeatureType(featureType);

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

            DataStore store = dataManager.createStore(shapeStoreParams);

            return (FeatureStore) store;

        } catch (Exception e) {

            throw new LrsCreateRouteException("Error creating new dataStore", e);

        }

    }

    static protected Double getAsDouble(Object obj, DataType dataType) {

        if (obj == null || dataType == null) {

            return null;

        }

        Double result = Double.NaN;

        if (dataType.equals(DataTypes.DOUBLE)) {

            result = (Double) obj;

        } else if (dataType.isNumeric()) {

            result = Double.valueOf(String.valueOf(obj));

        }

        return result;

    }

    static List<Point> getPointsWithM(Geometry geom, double m) throws CreateGeometryException, LocatorException {

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

        if (geom instanceof Line) {

            Line line = (Line) geom;

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

                Point currentVertex = line.getVertex(i);

                Point nextVertex = line.getVertex(i + 1);

                Point point = getPointWithMBetweenTwoMPoints(m, currentVertex, nextVertex);

                if (point != null && !points.contains(point)) {

                    points.add(point);

                }

            }

        } else if (geom instanceof MultiLine) {

            MultiLine multiLine = (MultiLine) geom;

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

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

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

                    Point point = getPointWithMBetweenTwoMPoints(m, line.getVertex(i), line.getVertex(i + 1));

                    if (point != null && !points.contains(point)) {

                        points.add(point);

                    }

                }

            }

        }

        return points;

    }

    private static boolean isInRange(double v, double r1, double r2) {

        if (r1 < r2) {

            return v >= r1 && v <= r2;

        } else if (r1 > r2) {

            return v >= r2 && v <= r1;

        } else {

            return v == r1;

        }

    }

    static MultiLine getLinesBetweenTwoM(Geometry geom, double m1, double m2) throws CreateGeometryException,

        LocatorException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        MultiLine lines = null;

        if (geom instanceof Line) {

            lines = getLinesBetweenTwoM((Line) geom, m1, m2);

        } else if (geom instanceof MultiLine) {

            lines = (MultiLine) geomManager.create(Geometry.TYPES.MULTILINE, geom.getGeometryType().getSubType());

            MultiLine multiLine = (MultiLine) geom;

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

                MultiLine auxMultiLine = getLinesBetweenTwoM(multiLine.getPrimitiveAt(i), m1, m2);

                for (int j = 0; j < auxMultiLine.getPrimitivesNumber(); j++) {

                    lines.addPrimitive(auxMultiLine.getPrimitiveAt(j));

                }

            }

        }

        return lines;

    }

    static private MultiLine getLinesBetweenTwoM(Line line, double m1, double m2) throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        MultiLine lines = (MultiLine) geomManager.create(Geometry.TYPES.MULTILINE, line.getGeometryType().getSubType());

        Line auxLine = (Line) geomManager.create(Geometry.TYPES.LINE, line.getGeometryType().getSubType());

        boolean inSegment = false;

        if (line.getNumVertices() > 0) {

            int ivertex = 0;

            Point previousVertex = null;

            while (ivertex < line.getNumVertices()) {

                if (!inSegment) { // NO ESTAMOS EN UN SEGMENTO VALIDO

                    Point vertex = line.getVertex(ivertex);

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

                    if (isInRange(m, m1, m2)) {

                        // Si la m del vertice actual entra en el rango:

                        if (previousVertex == null) {

                            // Si no hay previousVertex, este debe ser el primer

                            // vertice, entonces

                            // - a?adimos el v?rtice a la linea

                            // - marcamos que estamos en un segmento valido

                            // - nos guardamos el vertice como previousVertex

                            // - aumentamos el indice para coger el siguiente

                            // v?rtice en la pr?xima iteraci?n

                            auxLine.addVertex(vertex);

                            previousVertex = vertex;

                            inSegment = true;

                            ivertex++;

                        } else {

                            // - Calculamos qu? punto habr?a iniciado el

                            // segmento v?lido

                            double previousM = previousVertex.getCoordinateAt(previousVertex.getDimension() - 1);

                            // FIXME: Esta comprobaci?n se podr?a quitar

                            if (isInRange(m1, previousM, m) || isInRange(m2, previousM, m)) {

                                Point point = getPointWithMBetweenTwoMPoints(m1, previousVertex, vertex);

                                if (point == null) {

                                    point = getPointWithMBetweenTwoMPoints(m2, previousVertex, vertex);

                                }

                                if (point != null) {

                                    // - A?adimos el punto a la linea auxiliar

                                    // - Marcamos que estamos en un segmento v?lido

                                    // - nos guardamos el punto como previousVertex

                                    // - y NO aumentamos el indice

                                    auxLine.addVertex(point);

                                    inSegment = true;

                                    previousVertex = point;

                                } else {

                                    // Nunca deber?a pasar por aqu?

                                }

                            }

                        }

                    } else {

                        // Cabe la posibilidad de que entre un vertice y otro se

                        // entre y se salga del rango

                        if (previousVertex != null) {

                            double previousM = previousVertex.getCoordinateAt(previousVertex.getDimension() - 1);

                            if (isInRange(m1, previousM, m) && isInRange(m2, previousM, m)) {

                                Point point1 = getPointWithMBetweenTwoMPoints(m1, previousVertex, vertex);

                                Point point2 = getPointWithMBetweenTwoMPoints(m2, previousVertex, vertex);

                                auxLine.addVertex(point1);

                                auxLine.addVertex(point2);

                                lines.addPrimitive(auxLine);

                            }

                        }

                        // Si la m del v?rtice actual no entra en el rango:

                        // - nos guardamos el vertice como previousVertex

                        // - aumentamos el indice para coger el siguiente

                        // v?rtice en la pr?xima iteraci?n

                        previousVertex = vertex;

                        ivertex++;

                    }

                } else { // ESTAMOS EN UN SEGMENTO VALIDO

                    Point vertex = line.getVertex(ivertex);

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

                    if (isInRange(m, m1, m2)) {

                        // Si la m del vertice actual entra en el rango:

                        // - a?adimos el v?rtice a la linea

                        // - aumentamos el indice para coger el siguiente

                        // v?rtice en la pr?xima iteraci?n

                        auxLine.addVertex(vertex);

                        previousVertex = vertex;

                        ivertex++;

                    } else {

                        // Si la m del v?rtice actual no entra en el rango:

                        // - Calculamos el punto que habr?a finalizado el

                        // segmento v?lido entre el vertice anterior y el actual

                        Point point = getPointWithMBetweenTwoMPoints(m1, previousVertex, vertex);

                        if (point == null) {

                            point = getPointWithMBetweenTwoMPoints(m2, previousVertex, vertex);

                        }

                        if (point != null) {

                            // - A?adimos el punto a la linea auxiliar

                            // - a?adimos la linea y creamos una nueva

                            // - Marcamos que NO estamos en un segmento v?lido

                            // - nos guardamos el punto como previousVertex

                            // - y NO aumentamos el indice

                            auxLine.addVertex(point);

                            lines.addPrimitive(auxLine);

                            auxLine =

                                (Line) geomManager.create(Geometry.TYPES.LINE, line.getGeometryType().getSubType());

                            inSegment = false;

                            previousVertex = point;

                        } else {

                            // Nunca deber?a pasar por aqu?

                        }

                    }

                }

            }

        }

        if (inSegment && auxLine.getNumVertices() > 0) {

            lines.addPrimitive(auxLine);

        }

        return lines;

    }

    /*

     *

     */

    private static Point getPointWithMBetweenTwoMPoints(double m, Point p1, Point p2) throws CreateGeometryException,

        LocatorException {

        double x;

        double y;

        double m1 = p1.getCoordinateAt(p1.getDimension() - 1);

        double m2 = p2.getCoordinateAt(p2.getDimension() - 1);

        if (m1 <= m2) {

            if (m < m1 || m > m2) {

                return null;

            }

        } else {

            if (m < m2 || m > m1) {

                return null;

            }

        }

        double x1 = p1.getX();

        double x2 = p2.getX();

        double y1 = p1.getY();

        double y2 = p2.getY();

        if (x1 == x2) {

            x = x1;

        } else {

            x = ((x2 - x1) * (m - m1) / (m2 - m1)) + x1;

        }

        if (y1 == y2) {

            y = y1;

        } else {

            y = ((y2 - y1) * (m - m1) / (m2 - m1)) + y1;

        }

        Point point = (Point) GeometryLocator.getGeometryManager().create(p1.getGeometryType());

        point.setX(x);

        point.setY(y);

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

        return point;

    }

    /**

     * Returns geometry length without gaps

     * @param geometry

     * @return

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    static protected Double getGeometryLength(Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException{

        return getGeometryLength(geometry, true);

    }

    /**

     * Returns geometry length without gaps with the option to not ignore spatial gaps.

     * @param geometry

     * @param ignoreSpatialGaps

     * @return

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     */

    static protected Double getGeometryLength(Geometry geometry,

        boolean ignoreSpatialGaps)

            throws GeometryOperationNotSupportedException,

            GeometryOperationException {

        if (geometry instanceof Line) {

            Line line = (Line) geometry;

            return getLineLength(line);

        }

        if (geometry instanceof MultiLine) {

            MultiLine multiLine = (MultiLine) geometry;

            return getMultiLineLength(multiLine, ignoreSpatialGaps);

        }

        return Double.NaN;

    }

    /**

     * @param line

     * @return lenght

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    static protected double getLineLength(Line line)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        double lenght = 0;

        Point previousVertex = null;

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

            Point vertex = line.getVertex(i);

            if (previousVertex != null) {

                lenght += previousVertex.distance(vertex);

            }

            previousVertex = vertex;

        }

        return lenght;

    }

    /**

     * @param multiLine

     * @return lenght

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    static protected double getMultiLineLength(MultiLine multiLine,

        boolean ignoreSpatialGaps)

            throws GeometryOperationNotSupportedException,

            GeometryOperationException {

        double length = 0;

        Point previousVertex = null;

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

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

            if (ignoreSpatialGaps) {

                previousVertex = null;

            }

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

                Point vertex = line.getVertex(i);

                if (previousVertex != null) {

                    length += previousVertex.distance(vertex);

                }

                previousVertex = vertex;

            }

        }

        return length;

    }

    /**

     * Extracts the lines in a Line or Multiline

     * @param geometry

     * @return

     */

    static protected List<Line> extractLines(Geometry geometry){

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

        if (geometry instanceof  Line){

            lines.add((Line) geometry);

        }

        if (geometry instanceof MultiLine){

            MultiLine multiline=(MultiLine)geometry;

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

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

            }

        }

        return lines;

    }

    static protected List<Point> extractPoints(Geometry geometry){

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

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

        for (Line line: lines){

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

                points.add(line.getVertex(i));

            }

        }

        return points;

    }

    static protected Point extractFirstPoint(Geometry geometry){

        Point firstPoint=null;

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

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

            firstPoint=lines.get(0).getVertex(0);

        }

        return firstPoint;

    }

    static protected boolean equalPoints(Point point1, Point point2){

        if ( point1.getX()==point2.getX() && point1.getY()==point2.getY()){

            return true;

        }

        return false;

    }

    static protected Geometry insertVertex(Geometry geometry, Point vertex, int index){

        if (geometry instanceof Line){

            Line line=(Line)geometry;

            line.insertVertex(index, vertex);

        }

        if (geometry instanceof MultiLine){

            List<Line> lines=extractLines(geometry);

            for(Line line:lines){

                if (index<=line.getNumVertices()){

                    line.insertVertex(index, vertex);

                    return geometry;

                }else{

                    index-=line.getNumVertices();

                }

            }

        }

        return geometry;

    }

    /**

     * Reduced versi?n of straight line through two points equation to calculate M's

     *

     * @param totalLength

     * @param minValue

     * @param maxValue

     * @param relativeDistance

     * @return

     */

    static protected double calculateM(Double totalLength, Double minValue, Double maxValue, Double relativeDistance) {

        return LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(0, totalLength, minValue, maxValue, relativeDistance);

    }

    /**

     * Straight line through two points equation.

     *

     * @param x1

     * @param x2

     * @param y1

     * @param y2

     * @param x

     * @return

     */

    static protected double straightLineThroughTwoPointsEquation(double x1, double x2, double y1, double y2, double x) {

        if (x2 - x1 == 0.0) {

            return Double.POSITIVE_INFINITY;

        }

        return ((y2 - y1) * (x - x1) / (x2 - x1)) + y1;

    }

}

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

     */