Application: gvSIG desktop » gvSIG Linear Reference System

/* 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.awt.Dimension;

import java.awt.geom.Point2D;

import java.io.File;

import java.sql.Array;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import javax.xml.transform.Source;

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

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.exception.DataException;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryException;

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.fmap.geom.type.GeometryType;

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.service.Manager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @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();

        //LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

        //LrsSourceOfMeasures sourceOfMeasures = parameters.getSourceOfMeasures();

        FeatureAttributeDescriptor fromMeasureField = parameters.getFromMeasureField();

        FeatureAttributeDescriptor toMeasureField = parameters.getToMeasureField();

        //double measureFactor = parameters.getMeasureFactor();

        //double measureOffset = parameters.getMeasureOffset();

        //boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

        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 Map<String,List<MStructure>> featuresMap=new HashMap<String, List<MStructure>>();

            sourceFeatures.accept(new Visitor() {

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

                    Feature feature=(Feature)obj;

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

                    Geometry originalGeometry=feature.getDefaultGeometry();

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

                    }

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

                    MStructure mStructure=new MStructure();

                    mStructure.geometry=originalGeometry;

                    mStructure.fromField=LrsAlgorithmUtils.getAsDouble(objFrom,fromDataType);

                    mStructure.toField=LrsAlgorithmUtils.getAsDouble(objTo,toDataType);

                    mList.add(mStructure);

                    featuresMap.put(routeName, mList);

                }

            });

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

            int taskCount=0;

            newFeatureStore.edit(FeatureStore.MODE_FULLEDIT);

            //TODO Added to facilitate Tests. Remove afterwards

            StringBuffer resultDebug=new StringBuffer();

            LrsSourceOfMeasures sourceOfMeasures = parameters.getSourceOfMeasures();

            boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

            LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

            resultDebug.append (sourceOfMeasures.getName());

            if (!sourceOfMeasures.equals(LrsSourceOfMeasures.TWO_FIELDS)){

                if (ignoreSpatialGaps)resultDebug.append (" WITHOUT GAPS ");

                else resultDebug.append (" WITH GAPS ");

                resultDebug.append(coordinatePriority.getName());

            }

            //END of Test addition

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

                String routeName = entry.getKey();

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

                EditableFeature newFeature = newFeatureStore.createNewFeature(true);

                newFeature.set(routeFieldName, routeName);

                Geometry route = createGeometryRoute(mList);

                newFeature.setDefaultGeometry(route);

                //TODO Added to facilitate Tests. Remove afterwards

                String lineSeparator=System.getProperty("line.separator");

                resultDebug.append(lineSeparator);

                resultDebug.append("Route: "+routeName);

                resultDebug.append(lineSeparator);

                if (route instanceof MultiLine){

                    MultiLine multiLine=(MultiLine)route;

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

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

                        resultDebug.append("Line "+j+":[");

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

                            Point point=line.getVertex(i);

                            Double x=point.getX();

                            Double y=point.getY();

                            Double m=point.getCoordinateAt(point.getDimension()-1);

                            resultDebug.append("(x="+x.toString()+",y="+y.toString()+",m="+m.toString()+")");

                        }

                        resultDebug.append("]");

                        resultDebug.append(lineSeparator);

                    }

                }

                //END of Test addition

                newFeatureStore.update(newFeature);

                taskCount++;

                taskStatus.setCurValue(taskCount);

            }

            logger.debug(resultDebug.toString());

            newFeatureStore.finishEditing();

        } catch (Exception e1) {

            taskStatus.abort();

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

        }

        taskStatus.terminate();

//        FeatureSelection selection;

//        try {

//            outputFeatureStore.edit(FeatureStore.MODE_FULLEDIT);

//            selection = sourceFeatureStore.getFeatureSelection();

//            if (selection == null || selection.isEmpty()) {

//                selection = sourceFeatureStore.createFeatureSelection();

//                selection.selectAll();

//            }

//            taskStatus.message("Grouping features");

//            Map<Object, List<FeatureReference>> groupedReferences = getGroupedReferences(selection, idRouteField);

//

//            taskStatus.message("Creating routes");

//

//            Set<Object> keys = groupedReferences.keySet();

//            taskStatus.setRangeOfValues(0, keys.size());

//            int i=0;

//            for (Iterator iterator = keys.iterator(); iterator.hasNext();) {

//                taskStatus.setCurValue(i++);

//                Object key = (Object) iterator.next();

//                EditableFeature newFeature = outputFeatureStore.createNewFeature(true);

//                newFeature.set(idRouteField.getName(), key);

//

//                List<FeatureReference> references = groupedReferences.get(key);

//                Geometry route = createRoute(references, coordinatePriority, sourceOfMeasures, fromMeasureField, toMeasureField, measureFactor, measureOffset, ignoreSpatialGaps);

//                route = calibrateRoute(route);

//                newFeature.setDefaultGeometry(route);

//                outputFeatureStore.update(newFeature);

//            }

//            outputFeatureStore.finishEditing();

//            taskStatus.terminate();

//

//        } catch (DataException e) {

//            // TODO Auto-generated catch block

//            e.printStackTrace();

//        } catch (BaseException e) {

//            // TODO Auto-generated catch block

//            e.printStackTrace();

//        }

    }

    private Geometry createGeometryRoute(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        LrsSourceOfMeasures sourceOfMeasures =parameters.getSourceOfMeasures();

        Geometry geometryResult=null;

        switch (sourceOfMeasures) {

        case ONE_FIELD:

            geometryResult= calculateGeometryByOneField(mList);

            break;

        case TWO_FIELDS:

            geometryResult= calculateGeometryByTwoField(mList);

            break;

        case LENGTH:

        default:

            geometryResult= calculateGeometryByLength(mList);

            break;

        }

        geometryResult=applyOffset(geometryResult);

        return geometryResult;

    }

    private Geometry calculateGeometryByLength(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException{

        return null;

    }

    private Geometry calculateGeometryByOneField(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

        GeometryManager geomanager= GeometryLocator.getGeometryManager();

        try {

            sortMList(mList);

        } catch (Exception e) {

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

        }

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

        MutableDouble lastMValue=new MutableDouble(0);

        Double gap=Double.valueOf(0);

        Point lastPoint=null;

        for (MStructure mStructure:mList){

            Geometry geometry=mStructure.geometry;

            if(!ignoreSpatialGaps){

                gap=calculateGap(lastPoint, geometry);

                lastMValue.add(gap);

            }

            Double fromDistance=lastMValue.getValue();

            lastMValue.add(mStructure.fromField);

            Double toDistance=lastMValue.getValue();

            if (geometry instanceof Line){

                Line line=(Line) geometry;

                Line lineM=lineToMLine(line, fromDistance, toDistance);

                mGeometry.addPrimitive(lineM);

                lastPoint=lineM.getVertex(lineM.getNumVertices()-1);

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine =(MultiLine) geometry;

                Line[] lines=multilineToMlines(multiLine, fromDistance, toDistance,ignoreSpatialGaps);

                for (Line lineM:lines){

                    mGeometry.addPrimitive(lineM);

                    lastPoint=lineM.getVertex(lineM.getNumVertices()-1);

                }

            }

        }

        return mGeometry;

    }

    private Double calculateGap(Point lastPoint, Geometry geometry) throws GeometryOperationNotSupportedException, GeometryOperationException{

        Double gap=new Double(0);

        if (geometry instanceof Line){

            Line line=(Line) geometry;

            if (lastPoint!=null){

                Point firstPoint=line.getVertex(0);

                gap=firstPoint.distance(lastPoint);

            }

        }

        if (geometry instanceof MultiLine){

            MultiLine multiLine =(MultiLine) geometry;

            if (lastPoint!=null){

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

                Point firstPoint=line.getVertex(0);

                gap=firstPoint.distance(lastPoint);

            }

        }

        return gap;

    }

    private void sortMList(List<MStructure> mList) throws CreateEnvelopeException, GeometryOperationNotSupportedException, GeometryOperationException {

        LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

        GeometryManager geomanager= GeometryLocator.getGeometryManager();

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

        for (MStructure mStructure:mList){

            envelope.add(mStructure.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;

        }

        GeometryDistanceToPointComparator comaparatorMList=new GeometryDistanceToPointComparator(origin);

        MStructure[] orderedMStruct=(MStructure[])mList.toArray();

        Arrays.sort(orderedMStruct, comaparatorMList);

        mList=new ArrayList<MStructure>(Arrays.asList(orderedMStruct));

        for (MStructure mStructure:mList){

            Geometry geometry=mStructure.geometry;

            if (geometry instanceof Line){

                Line line=(Line)geometry;

                Double firstPointDistance=origin.distance(line.getVertex(0));

                Double lastPointDistance=origin.distance(line.getVertex(line.getNumVertices()-1));

                if (lastPointDistance<firstPointDistance){

                    geometry.flip();

                }

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine=(MultiLine)geometry;

                Line firstLine=(Line)multiLine.getPrimitiveAt(0);

                Line lastLine=(Line)multiLine.getPrimitiveAt(multiLine.getPrimitivesNumber()-1);

                Double firstPointDistance=origin.distance(firstLine.getVertex(0));

                Double lastPointDistance=origin.distance(lastLine.getVertex(lastLine.getNumVertices()-1));

                if (lastPointDistance<firstPointDistance){

                    geometry.flip();

                }

            }

            mStructure.geometry=geometry;

        }

    }

    private Geometry applyOffset(Geometry geometry){

        double measureFactor = parameters.getMeasureFactor();

        double measureOffset = parameters.getMeasureOffset();

        if (geometry instanceof Line){

            Line line=(Line) geometry;

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

                Point mVertex=line.getVertex(i);

                Double mValue=mVertex.getCoordinateAt(mVertex.getDimension()-1);

                Double newMValue=(mValue*measureFactor)+measureOffset;

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

                line.setVertex(i, mVertex);

            }

        }

        if (geometry instanceof MultiLine){

            MultiLine multiLine =(MultiLine) geometry;

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

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

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

                    Point mVertex=line.getVertex(j);

                    Double mValue=mVertex.getCoordinateAt(mVertex.getDimension()-1);

                    Double newMValue=(mValue*measureFactor)+measureOffset;

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

                    line.setVertex(j, mVertex);

                }

            }

        }

        return geometry;

    }

    private Geometry calculateGeometryByTwoField(List<MStructure> mList) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException{

        GeometryManager geomanager= GeometryLocator.getGeometryManager();

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

        for (MStructure mStructure:mList){

            Geometry geometry=mStructure.geometry;

            Double fromDistance=mStructure.fromField;

            Double toDistance=mStructure.toField;

            if (geometry instanceof Line){

                Line line=(Line) geometry;

                Line lineM=lineToMLine(line, fromDistance, toDistance);

                mGeometry.addPrimitive(lineM);

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine =(MultiLine) geometry;

                Line[] lines=multilineToMlines(multiLine, fromDistance, toDistance);

                for (Line lineM:lines){

                    mGeometry.addPrimitive(lineM);

                }

            }

        }

        return mGeometry;

    }

    private Line[] multilineToMlines(MultiLine multiLine,Double fromDistance, Double toDistance) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException{

        return multilineToMlines(multiLine,fromDistance, toDistance,true);

    }

    private Line[] multilineToMlines(MultiLine multiLine,Double fromDistance, Double toDistance,boolean ignoreSpatialGaps) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException{

        Line[] lines=new Line[multiLine.getPrimitivesNumber()];

        Double multiLineLength=getMultiLineLength(multiLine,ignoreSpatialGaps);

        Double mFirstPoint=fromDistance;

        Double mLastPoint=null;

        Double distance=Double.valueOf(0);

        Point lastPoint=null;

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

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

            Double lineLength=getLineLength(line);

            Double gap=Double.valueOf(0);

            if (!ignoreSpatialGaps&&lastPoint!=null){

                Point firstPoint=line.getVertex(0);

                gap=firstPoint.distance(lastPoint);

                distance+=gap;

            }

            mFirstPoint=calculateM(toDistance,fromDistance, distance, multiLineLength);

            distance+=lineLength;

            mLastPoint=calculateM(toDistance,fromDistance, distance, multiLineLength);

            lines[i]=lineToMLine(line, mFirstPoint, mLastPoint);

            lastPoint=lines[i].getVertex(line.getNumVertices()-1);

        }

        return lines;

    }

    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=calculateM(maxMValue,minMValue, inLineDistance, lineLength);

            }

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

            lineM.addVertex(mVertex);

        }

        return lineM;

    }

    private Double calculateM(Double maxValue, Double minValue, Double relativeDistance, Double totalLength){

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

        if (totalLength.equals(Double.valueOf(0) )) return Double.POSITIVE_INFINITY;

        return ((maxValue-minValue)*(relativeDistance)/(totalLength))+minValue;

    }

//    private Line lineToMLine(Line line,Point previousVertex, MutableDouble distance) throws CreateGeometryException{

//        GeometryManager geomanager= GeometryLocator.getGeometryManager();

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

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

//

//            if (previousVertex==null){

//                previousVertex=vertex;

//            }else{

//                try {

//                    distance.setValue(distance.getValue()+vertex.distance(previousVertex));

//                    previousVertex=vertex;

//                } catch (Exception e) {

//                    previousVertex=vertex;

//                    distance.setValue(Double.NaN);

//                }

//            }

//            mVertex.setCoordinateAt(mVertex.getDimension()-1, distance.getValue());

//            lineM.addVertex(mVertex);

//        }

//        return lineM;

//    }

    /**

     * @param route

     * @return

     */

    private Geometry calibrateRoute(Geometry route) {

        // TODO Auto-generated method stub

        return route;

    }

    private Map<Object, List<FeatureReference>> getGroupedReferences(FeatureSelection selection, final FeatureAttributeDescriptor idRouteField) throws BaseException {

        final Map<Object, List<FeatureReference>> refs = new HashMap<Object, List<FeatureReference>>();

        selection.accept(new Visitor() {

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

                Feature feature = (Feature) obj;

                Object id = feature.getFeature(idRouteField.getName());

                FeatureReference reference = feature.getReference();

                List<FeatureReference> references = refs.get(id);

                if (references == null) {

                    references = new ArrayList<FeatureReference>();

                }

                references.add(reference);

                refs.put(id, references);

            }

        });

        return refs;

    }

//    private MultiLine createRoute(List<FeatureReference> references, LrsCoordinatesPriority coordinatePriority, LrsSourceOfMeasures sourceOfMeasures, FeatureAttributeDescriptor fromMeasureField,FeatureAttributeDescriptor toMeasureField, double measureFactor, double measureOffset, boolean ignoreSpatialGaps) throws CreateGeometryException, DataException, CreateEnvelopeException, GeometryOperationNotSupportedException, GeometryOperationException{

//

//        Envelope envelope = getEnvelope(references);

//        Point p = getOriginPointAccordingPriorityCoordinates(envelope, coordinatePriority);

//        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

//

//        //FIXME: cuando est? esto tendr? que ser GEOM2DM o incluso GEOM3DM

//        MultiLine route = geometryManager.createMultiLine(Geometry.SUBTYPES.GEOM2D);

//        double m = 0;

//        Point previousVertex = null;

//        List<FeatureReference> orderedReferences = getOrderedReferences(references, (Point)p.cloneGeometry());

//        for (Iterator iterator = orderedReferences.iterator(); iterator.hasNext();) {

//            FeatureReference featureReference = (FeatureReference) iterator.next();

//            Feature feature = featureReference.getFeature();

//            Geometry geometry = feature.getDefaultGeometry();

//            if (geometry instanceof Line) {

//                Line line = (Line) geometry;

//                Point firstVertex = line.getVertex(0);

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

//                boolean ascendantOrder = isAscendantOrder(p, firstVertex, lastVertex);

//                //FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                Line tramo = geometryManager.createLine(Geometry.SUBTYPES.GEOM3D);

//                double lineLength = getLineLength(line);

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

//                    Point vertex = getNextVertex(line, ascendantOrder, i);

//

//                    switch (sourceOfMeasures) {

//                    case ONE_FIELD:

//                        m = calculateMByOneField(m, previousVertex, i, vertex, feature.getDouble(fromMeasureField.getName()), lineLength, measureFactor, measureOffset, ignoreSpatialGaps);

//                        break;

//                    case TWO_FIELDS:

//                        m = calculateMByTwoField(m, previousVertex, i, vertex, feature.getDouble(fromMeasureField.getName()), feature.getDouble(toMeasureField.getName()), lineLength, measureFactor, measureOffset);

//                        break;

//                    case LENGTH:

//                    default:

//                        m = calculateMByLength(m, previousVertex, i, vertex, ignoreSpatialGaps, measureFactor, measureOffset);

//                        break;

//                    }

//                    // FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                    Point mvertex = geometryManager.createPoint(vertex.getX(), vertex.getY(), Geometry.SUBTYPES.GEOM3D);

//                    mvertex.setCoordinateAt(2, m);

//                    tramo.addVertex(mvertex);

//                    previousVertex = vertex;

//                    p = vertex;

//                }

//                route.addPrimitive(tramo);

//            } else if (geometry instanceof MultiLine) {

//                MultiLine multiLine = (MultiLine)geometry;

//                double multiLineLength = getMultiLineLength(multiLine);

//                MultiLine orderedMultiLine = getOrderedMultiLine(multiLine, previousVertex, coordinatePriority);

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

//                    Line line = (Line) orderedMultiLine.getPrimitiveAt(j);

//                    Point firstVertex = line.getVertex(0);

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

//                    boolean ascendantOrder = isAscendantOrder(p, firstVertex, lastVertex);

//                    //FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                    Line tramo = geometryManager.createLine(Geometry.SUBTYPES.GEOM3D);

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

//                        Point vertex = getNextVertex(line, ascendantOrder, i);

//                        switch (sourceOfMeasures) {

//                        case ONE_FIELD:

//                            m = calculateMByOneField(m, previousVertex, i, vertex, feature.getDouble(toMeasureField.getName()), multiLineLength, multiLineLength, multiLineLength, ascendantOrder);

//                            break;

//                        case TWO_FIELDS:

//                            //Este caso tal vez no se d? nunca, pero por si acaso

//                            m = calculateMByTwoField(m, previousVertex, i, vertex, feature.getDouble(fromMeasureField.getName()), feature.getDouble(toMeasureField.getName()), multiLineLength, measureFactor, measureOffset);

//                            break;

//                        case LENGTH:

//                        default:

//                            m = calculateMByLength(m, previousVertex, i, vertex, ignoreSpatialGaps, measureFactor, measureOffset);

//                            break;

//                        }

//

//                        // FIXME: cuando est? disponible esto deber? ser GEOM2DM (?o incluso GEOM3DM?)

//                        Point mvertex = geometryManager.createPoint(vertex.getX(), vertex.getY(), Geometry.SUBTYPES.GEOM3D);

//                        mvertex.setCoordinateAt(2, m);

//                        tramo.addVertex(mvertex);

//                        previousVertex = vertex;

//                        p = vertex;

//                    }

//                    route.addPrimitive(tramo);

//                }

//            }

//        }

//

//        return route;

//    }

    /**

     * @param multiLine

     * @param previousVertex

     * @param coordinatePriority2

     * @return

     * @throws CreateGeometryException

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    private MultiLine getOrderedMultiLine(MultiLine multiLine, Point previousVertex, LrsCoordinatesPriority coordinatePriority) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        MultiLine orderedMultiLine = geometryManager.createMultiLine(multiLine.getGeometryType().getSubType());

        Point p = null;

        if(previousVertex!=null){

            previousVertex.cloneGeometry();

        } else {

            Envelope envelope = multiLine.getEnvelope();

            p = getOriginPointAccordingPriorityCoordinates(envelope, coordinatePriority);

        }

        Point newPoint = (Point) p.cloneGeometry();

        Integer nearestPrimitive = null;

        double nearestDistance = Double.POSITIVE_INFINITY;

        List<Integer> addedPrimitives = new ArrayList<Integer>();

        boolean changed = true;

        while (changed) {

            changed = false;

            nearestDistance = Double.POSITIVE_INFINITY;

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

                if(!addedPrimitives.contains(i)){

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

                    Point firstVertex = line.getVertex(0);

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

                    double distanceFirstVertex = p.distance(firstVertex);

                    double distanceLastVertex = p.distance(lastVertex);

                    double distance = Math.min(distanceFirstVertex, distanceLastVertex);

                    if (distance < nearestDistance) {

                        if(distanceFirstVertex<distanceLastVertex){

                            newPoint = lastVertex;

                        } else {

                        }

                        nearestPrimitive = i;

                        nearestDistance = distance;

                        changed = true;

                    }

                }

            }

            if (changed) {

                addedPrimitives.add(nearestPrimitive);

                p = (Point) newPoint.cloneGeometry();

            }

        }

        p = (Point) previousVertex.cloneGeometry();

        for (Iterator iterator = addedPrimitives.iterator(); iterator.hasNext();) {

            Integer integer = (Integer) iterator.next();

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

            Line auxLine;

            if(isAscendantOrder(p, line.getVertex(0), line.getVertex(line.getNumVertices()-1))){

                auxLine = (Line) line.cloneGeometry();

            } else {

                auxLine = geometryManager.createLine(line.getGeometryType().getSubType());

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

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

                }

            }

            orderedMultiLine.addPrimitive(auxLine);

        }

        return orderedMultiLine;

    }

    private Point getOriginPointAccordingPriorityCoordinates(Envelope envelope, LrsCoordinatesPriority coordinatePriority) throws CreateGeometryException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        Point p;

        switch (coordinatePriority) {

        case DOWN_LEFT:

            p = geometryManager.createPoint(envelope.getMinimum(0), envelope.getMaximum(1), Geometry.SUBTYPES.GEOM2D);

            break;

        case UP_RIGHT:

            p = geometryManager.createPoint(envelope.getMinimum(0), envelope.getMinimum(1), Geometry.SUBTYPES.GEOM2D);

            break;

        case DOWN_RIGHT:

            p = geometryManager.createPoint(envelope.getMaximum(0), envelope.getMaximum(1), Geometry.SUBTYPES.GEOM2D);

            break;

        case UP_LEFT:

        default:

            p = geometryManager.createPoint(envelope.getMaximum(0), envelope.getMinimum(1), Geometry.SUBTYPES.GEOM2D);

            break;

        }

        return p;

    }

    /**

     * @param line

     * @return lenght

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    private 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

     */

    private double getMultiLineLength(MultiLine multiLine,boolean ignoreSpatialGaps) throws GeometryOperationNotSupportedException, GeometryOperationException{

        double lenght = 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){

                    lenght+=previousVertex.distance(vertex);

                }

                previousVertex = vertex;

            }

        }

        return lenght;

    }

    private double calculateM(double m, Point previousVertex, int i, Point vertex, Double from, Double to, boolean ignoreSpatialGaps, double measureFactor, double measureOffset)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

            if (previousVertex != null && !ignoreSpatialGaps) {

                m += (previousVertex.distance(vertex)*measureFactor)+measureOffset;

            }

        } else {

            if(previousVertex!=null){

                m += (previousVertex.distance(vertex)*measureFactor)+measureOffset;

            }

        }

        return m;

    }

    private double calculateMByLength(double m, Point previousVertex, int i, Point vertex, boolean ignoreSpatialGaps, double measureFactor, double measureOffset)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

            if (previousVertex != null && !ignoreSpatialGaps) {

                m += (previousVertex.distance(vertex)*measureFactor)+measureOffset;

            }

        } else {

            if(previousVertex!=null){

                m += (previousVertex.distance(vertex)*measureFactor)+measureOffset;

            }

        }

        return m;

    }

    private double calculateMByOneField(double m, Point previousVertex, int i, Point vertex, Double length, double totalGeometricLength, double measureFactor, double measureOffset, boolean ignoreSpatialGaps)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

            if (previousVertex != null && !ignoreSpatialGaps) {

                m += (previousVertex.distance(vertex)*length/totalGeometricLength*measureFactor)+measureOffset;

            }

        } else {

            if(previousVertex!=null){

                m += (previousVertex.distance(vertex)*length/totalGeometricLength*measureFactor)+measureOffset;

            }

        }

        return m;

    }

    private double calculateMByTwoField(double m, Point previousVertex, int i, Point vertex, Double from, Double to, double totalGeometricLength, double measureFactor, double measureOffset)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

            m = from;

        } else {

            if(previousVertex!=null){

                m += (previousVertex.distance(vertex)*(to-from)/totalGeometricLength*measureFactor)+measureOffset;

            }

        }

        return m;

    }

    private Point getNextVertex(Line line, boolean ascendantOrder, int i) {

        Point vertex = null;

        if(ascendantOrder){

            vertex = line.getVertex(i);

        } else {

            vertex = line.getVertex(line.getNumVertices()-i);

        }

        return vertex;

    }

    private boolean isAscendantOrder(Point p, Point firstVertex, Point lastVertex)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        double distanceFirstVertex = p.distance(firstVertex);

        double distanceLastVertex = p.distance(lastVertex);

        boolean ascendantOrder = (distanceFirstVertex<=distanceLastVertex);

        return ascendantOrder;

    }

    private List<FeatureReference> getOrderedReferences(List<FeatureReference> references, Point point)

        throws CreateEnvelopeException, DataException, CreateGeometryException, GeometryOperationNotSupportedException,

        GeometryOperationException {

        Point p = (Point) point.cloneGeometry();

        List<FeatureReference> orderedReferences = new ArrayList<FeatureReference>();

        FeatureReference nearestFeatureReference = null;

        double nearestDistance = Double.POSITIVE_INFINITY;

        boolean changed = true;

        Point newPoint = (Point) p.cloneGeometry();

        while (changed) {

            changed = false;

            nearestDistance = Double.POSITIVE_INFINITY;

            for (Iterator iterator = references.iterator(); iterator.hasNext();) {

                FeatureReference featureReference = (FeatureReference) iterator.next();

                if (!orderedReferences.contains(featureReference)) {

                    Geometry geometry = featureReference.getFeature().getDefaultGeometry();

                    if (geometry instanceof Line) {

                        Line line = (Line) geometry;

                        Point firstVertex = line.getVertex(0);

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

                        double distanceFirstVertex = p.distance(firstVertex);

                        double distanceLastVertex = p.distance(lastVertex);

                        double distance = Math.min(distanceFirstVertex, distanceLastVertex);

                        if (distance < nearestDistance) {

                            if(distanceFirstVertex<distanceLastVertex){

                                newPoint = lastVertex;

                            }

                            nearestFeatureReference = featureReference;

                            nearestDistance = distance;

                            changed = true;

                        }

                    } else if (geometry instanceof MultiLine) {

                        MultiLine multiLine = (MultiLine) geometry;

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

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

                            Point firstVertex = line.getVertex(0);

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

                            double distanceFirstVertex = p.distance(firstVertex);

                            double distanceLastVertex = p.distance(lastVertex);

                            double distance = Math.min(distanceFirstVertex, distanceLastVertex);

                            if (distance < nearestDistance) {

                                if(distanceFirstVertex<distanceLastVertex){

                                    newPoint = lastVertex;

                                }

                                nearestFeatureReference = featureReference;

                                nearestDistance = distance;

                                changed = true;

                                break;

                            }

                        }

                    }

                }

            }

            if (changed) {

                orderedReferences.add(nearestFeatureReference);

                p = (Point) newPoint.cloneGeometry();

            }

        }

        return orderedReferences;

    }

    private Envelope getEnvelope(List<FeatureReference> references) throws CreateEnvelopeException, DataException{

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

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

        for (Iterator iterator = references.iterator(); iterator.hasNext();) {

            FeatureReference featureReference = (FeatureReference) iterator.next();

            Geometry geometry = featureReference.getFeature().getDefaultGeometry();

            envelope.add(geometry.getEnvelope());

        }

        return envelope;

    }

    /* (non-Javadoc)

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

     */

    public void setParams(LrsAlgorithmParams params) throws IllegalArgumentException {

        if(!(params instanceof LrsCreateRouteAlgorithmParams)){

            throw new IllegalArgumentException("params should be LrsCreateRouteAlgorithmParams type.");

        }

        // TODO Auto-generated method stub

    }

    class MStructure implements Comparable<MStructure>{

        Geometry geometry;

        Double fromField;

        Double toField;

        public int compareTo(MStructure o) {

            // TODO Auto-generated method stub

            return 0;

        }

    }

    class GeometryDistanceToPointComparator implements Comparator<MStructure> {

        private Point referencePoint;

        public GeometryDistanceToPointComparator(Point referencePoint) {

            this.referencePoint = referencePoint;

        }

        public int compare(MStructure mStruct1, MStructure mStruct2) {

            Double distance1=nearestPointDistance(mStruct1.geometry);

            Double distance2=nearestPointDistance(mStruct2.geometry);

            return distance1.compareTo(distance2);

        }

        private Double nearestPointDistance(Geometry geometry){

            if (geometry instanceof Line){

                return nearestPointDistanceToLine((Line)geometry);

            }

            if (geometry instanceof MultiLine){

                MultiLine multiLine=(MultiLine)geometry;

                Line firstLine=(Line)multiLine.getPrimitiveAt(0);

                Line lastLine=(Line)multiLine.getPrimitiveAt(multiLine.getPrimitivesNumber()-1);

                Double distanceFirstPoint;

                Double distanceLastPoint;

                try {

                    distanceFirstPoint = referencePoint.distance(firstLine.getVertex(0));

                } catch (Exception e) {

                    distanceFirstPoint=Double.MAX_VALUE;

                }

                try {

                    distanceLastPoint=referencePoint.distance(lastLine.getVertex(lastLine.getNumVertices()-1));

                } catch (Exception e) {

                    distanceLastPoint=Double.MAX_VALUE;

                }

                if (distanceFirstPoint<distanceLastPoint) return distanceFirstPoint;

                else return distanceLastPoint;

            }

            return Double.MAX_VALUE;

        }

        private Double nearestPointDistanceToLine(Line line){

            Double distanceFirstPoint;

            Double distanceLastPoint;

            try {

                distanceFirstPoint = referencePoint.distance(line.getVertex(0));

            } catch (Exception e) {

                distanceFirstPoint=Double.MAX_VALUE;

            }

            try {

                distanceLastPoint=referencePoint.distance(line.getVertex(line.getNumVertices()-1));

            } catch (Exception e) {

                distanceLastPoint=Double.MAX_VALUE;

            }

            if (distanceFirstPoint<distanceLastPoint) return distanceFirstPoint;

            else return distanceLastPoint;

        }

    }

}