Application: gvSIG desktop » gvSIG Linear Reference System

org.gvsig.lrs.lib.impl.DefaultLrsAlgorithmsLibrary

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.lrs.lib.impl;

import java.util.List;

import java.util.Map;

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

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

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

/**

 * @author dmartinez

 *

 */

public class DefaultLrsEditRouteCalibrationAlgorithmParams implements LrsEditRouteCalibrationAlgorithmParams {

    private FeatureAttributeDescriptor idRouteField;

    private String selectedRouteName;

    private final String NAME = "LrsEditRouteCalibrationAlgorithm";

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

    private Map<FeatureReference, List<Double>> modifiedMCoordinates;

    /**

     *

     */

    public DefaultLrsEditRouteCalibrationAlgorithmParams() {

    }

    /* (non-Javadoc)

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

     */

    @Override

    public String getName() {

        return NAME;

    }

    /* (non-Javadoc)

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

     */

    @Override

    public String getDescription() {

        return DESCRIPTION;

    }

    @Override

    public FeatureAttributeDescriptor getIdRouteField() {

        return idRouteField;

    }

    @Override

    public void setIdRouteField(FeatureAttributeDescriptor idRouteField) {

        this.idRouteField = idRouteField;

    }

    @Override

    public String getSelectedRouteName() {

        return selectedRouteName;

    }

    @Override

    public void setSelectedRouteName(String selectedRouteName) {

        this.selectedRouteName = selectedRouteName;

    }

    @Override

    public Map<FeatureReference, List<Double>> getModifiedMCoordinates() {

        return this.modifiedMCoordinates;

    }

    @Override

    public void setModifiedMCoordinates(Map<FeatureReference, List<Double>> modifiedMCoordinates) {

        this.modifiedMCoordinates = modifiedMCoordinates;

    }

}

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

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import org.cresques.cts.IProjection;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

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;

/**

 * @author dmartinez

 *

 */

public class LrsCalibrateRouteAlgorithm implements LrsAlgorithm {

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

    private LrsCalibrateRouteAlgorithmParams parameters;

    /**

     *

     */

    public LrsCalibrateRouteAlgorithm(LrsCalibrateRouteAlgorithmParams 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#setParams(org.gvsig.lrs.lib.api.LrsAlgorithmParams)

     */

    public void setParams(LrsAlgorithmParams params) throws IllegalArgumentException {

        if(!(params instanceof LrsCreateRouteAlgorithmParams)){

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

        }

        this.parameters = (LrsCalibrateRouteAlgorithmParams) params;

    }

    /*

     * (non-Javadoc)

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

     */

    public void execute(final SimpleTaskStatus taskStatus) throws LrsException {

        NewFeatureStoreParameters newFeatureStoreParameters =

            parameters.getNewFeatureStoreParameters();

        FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        FeatureAttributeDescriptor idRouteField = parameters.getIdRouteField();

        FeatureStore calibratePointFeatureStore= parameters.getCalibratePointFeatureStore();

        FeatureAttributeDescriptor idRouteCalibratePointField =parameters.getCalibratePointIdRouteField();

        FeatureAttributeDescriptor fromMeasureField = parameters.getFromMeasureField();

        final boolean includeAll=parameters.includeAll();

        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 routeCalibratePointFieldName=idRouteCalibratePointField.getName();

            final String measureFieldName=fromMeasureField.getName();

            final Double convertedSearchRadius=calculateConvertedSearchRadius();

            FeatureStore newFeatureStore = LrsAlgorithmUtils

                .createNewDataStore(newFeatureStoreParameters, idRouteField);

            FeatureSet sourceFeatures;

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

                sourceFeatures = sourceFeatureStore.getFeatureSelection();

            } else {

                sourceFeatures = sourceFeatureStore.getFeatureSet();

            }

            final Map<String, RouteAndPoints> featuresMap =

                new HashMap<String, RouteAndPoints>();

            sourceFeatures.accept(new Visitor() {

                public void visit(Object obj)

                    throws VisitCanceledException, BaseException {

                    Feature feature = (Feature) obj;

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

                    RouteAndPoints routeAndPoints = new RouteAndPoints(feature.getDefaultGeometry());

                    featuresMap.put(routeName, routeAndPoints);

                }

            });

            FeatureSet pointFeatures=calibratePointFeatureStore.getFeatureSet();

            pointFeatures.accept(new Visitor() {

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

                    Feature feature = (Feature) obj;

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

                    Double measure= (Double) feature.get(measureFieldName);

                    Geometry geomPoint=(Point)feature.getDefaultGeometry();

                    if (geomPoint instanceof Point){

                        Point point=(Point) geomPoint;

                        Object valueObject=featuresMap.get(routeName);

                        if (valueObject != null && valueObject instanceof RouteAndPoints) {

                            RouteAndPoints routeAndPoints = (RouteAndPoints) valueObject;

                            List<Point> points = routeAndPoints.getPoints();

                            if (feature.getDefaultGeometry() instanceof Point) {

                                Geometry route = routeAndPoints.getRoute();

                                if (isValidPoint(point, route, convertedSearchRadius)) {

                                    try {

                                        Point mPoint = getInRouteMPoint(route, point, measure);

                                        points.add(mPoint);

                                    } catch (Exception e) {

                                        logger.debug("Error adding point", e);

                                    }

                                }

                            }

                        }

                    }

                }

            });

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

            int taskCount = 0;

            newFeatureStore.edit(FeatureStore.MODE_FULLEDIT);

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

                String routeName = entry.getKey();

                Object valueObject = entry.getValue();

                List<Point> points=null;

                Geometry geometry=null;

                if (valueObject!=null && valueObject instanceof RouteAndPoints){

                    RouteAndPoints routeAndPoints=(RouteAndPoints)valueObject;

                        geometry=routeAndPoints.getRoute();

                        points=routeAndPoints.getPoints();

                }

                if (!points.isEmpty()){

                    EditableFeature newFeature =

                        newFeatureStore.createNewFeature(true);

                    newFeature.set(routeFieldName, routeName);

                    Geometry calibratedRoute = calibrateRoute(geometry,points);

                    newFeature.setDefaultGeometry(calibratedRoute);

                    newFeatureStore.update(newFeature);

                } else if (includeAll) {

                    EditableFeature newFeature = newFeatureStore.createNewFeature(true);

                    newFeature.set(routeFieldName, routeName);

                    newFeature.setDefaultGeometry(geometry);

                    newFeatureStore.update(newFeature);

                }

                taskCount++;

                taskStatus.setCurValue(taskCount);

            }

            newFeatureStore.finishEditing();

        } catch (Exception e1) {

            taskStatus.abort();

            throw new LrsCalibrateRouteException("Error calibrating routes", e1);

        }

        taskStatus.terminate();

    }

    private Point getInRouteMPoint(Geometry geometry,Point point, Double measure) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException{

        GeometryManager geomanager = GeometryLocator.getGeometryManager();

        Point[] pointsInLine=(Point[])geometry.closestPoints(point);

        Point pointInLine=pointsInLine[0];

        Point mPoint = (Point) geomanager

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

        mPoint.setX(pointInLine.getX());

        mPoint.setY(pointInLine.getY());

        int mDimension=mPoint.getDimension()-1;

        mPoint.setCoordinateAt(mDimension, measure);

        return mPoint;

    }

    private Double calculateConvertedSearchRadius(){

        Double searchRadius=parameters.getSearchRadius();

        DistanceUnits measureUnits = parameters.getMeasureUnits();

        FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        try {

            IProjection projection = sourceFeatureStore.getDefaultFeatureType().getDefaultSRS();

            Double searchRadiusInMeters=searchRadius*measureUnits.getTransToMeter();

            //TODO

            //DistanceUnits projectionDistanceUnits=getProjectionDistanceUnits(projection);

            //return searchRadiusInMeters/projectionDistanceUnits.getTransToMeter();

            return searchRadiusInMeters;

        } catch (Exception e) {

            return new Double(0);

        }

    }

    private boolean isValidPoint(Point point,Geometry geometry, Double convertedSearchRadius){

        try {

            return geometry.isWithinDistance(point, convertedSearchRadius);

        } catch (Exception e) {

            return false;

        }

    }

    private Geometry calibrateRoute(Geometry geometry, List<Point> points) {

        LrsMeasureCalculationMethods calculationMethod= parameters.getMeasureCalculationMethods();

        boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

        boolean interpolateBetweenCalibrationPoints=parameters.interpolateBetweenCalibrationPoints();

        boolean extrapolateBeforeCalibrationPoints=parameters.extrapolateBeforeCalibrationPoints();

        boolean extrapolateAfterCalibrationPoints=parameters.extrapolateAfterCalibrationPoints();

        if (points.isEmpty()){

            return geometry;

        }

        MeasuresCalculator expandedRoute=new DefaultMeasuresCalculator(geometry, ignoreSpatialGaps);

        expandedRoute.addControlPoints(points);

        expandedRoute.calculate(calculationMethod,extrapolateBeforeCalibrationPoints,interpolateBetweenCalibrationPoints,extrapolateAfterCalibrationPoints);

        return expandedRoute.getResult();

    }

    private class RouteAndPoints {

        private Geometry route;

        private List<Point> points;

        /**

         *

         */

        public RouteAndPoints(Geometry route) {

            this.setRoute(route);

            this.setPoints(new ArrayList<Point>());

        }

        /**

         * @return the route

         */

        public Geometry getRoute() {

            return route;

        }

        /**

         * @param route the route to set

         */

        public void setRoute(Geometry route) {

            this.route = route;

        }

        /**

         * @return the points

         */

        public List<Point> getPoints() {

            return points;

        }

        /**

         * @param points the points to set

         */

        public void setPoints(List<Point> points) {

            this.points = points;

        }

    }

}

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

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

/**

 * @author dmartinez

 *

 */

public class DefaultLrsGenerateDynamicSegmentationAlgorithmParams implements LrsGenerateDynamicSegmentationAlgorithmParams {

    private FeatureStore sourceFeatureStore;

    private FeatureAttributeDescriptor idRouteField;

    private NewFeatureStoreParameters newFeatureStoreParameters;

    private FeatureStore valueTableFeatureStore;

    private FeatureAttributeDescriptor valueTableIdRouteField;

    private FeatureAttributeDescriptor landmarkField;

    private FeatureAttributeDescriptor finalLandmarkField;

    private FeatureAttributeDescriptor valueField;

    private final String NAME = "LrsCalibrateRouteAlgorithm";

    private final String DESCRIPTION = "Algorithm to calibrate routes with linear reference system.";

    /**

     *

     */

    public DefaultLrsGenerateDynamicSegmentationAlgorithmParams() {

    }

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

    }

    public FeatureStore getSourceFeatureStore() {

        return sourceFeatureStore;

    }

    public void setSourceFeatureStore(FeatureStore sourceFeatureStore) {

        this.sourceFeatureStore = sourceFeatureStore;

    }

    public FeatureAttributeDescriptor getIdRouteField() {

        return idRouteField;

    }

    public void setIdRouteField(FeatureAttributeDescriptor idRouteField) {

        this.idRouteField = idRouteField;

    }

    public NewFeatureStoreParameters getNewFeatureStoreParameters() {

        return newFeatureStoreParameters;

    }

    public void setNewFeatureStoreParameters(

        NewFeatureStoreParameters newFeatureStoreParameters) {

        this.newFeatureStoreParameters = newFeatureStoreParameters;

    }

    public FeatureStore getValueTableFeatureStore() {

        return valueTableFeatureStore;

    }

    public void setValueTableFeatureStore(FeatureStore valueTableFeatureStore) {

        this.valueTableFeatureStore = valueTableFeatureStore;

    }

    public FeatureAttributeDescriptor getValueTableIdRouteField() {

        return valueTableIdRouteField;

    }

    public void setValueTableIdRouteField(

        FeatureAttributeDescriptor valueTableIdRouteField) {

        this.valueTableIdRouteField = valueTableIdRouteField;

    }

    public FeatureAttributeDescriptor getLandmarkField() {

        return landmarkField;

    }

    public void setLandmarkField(FeatureAttributeDescriptor landmarkField) {

        this.landmarkField = landmarkField;

    }

    public FeatureAttributeDescriptor getFinalLandmarkField() {

        return finalLandmarkField;

    }

    public void setFinalLandmarkField(

        FeatureAttributeDescriptor finalLandmarkField) {

        this.finalLandmarkField = finalLandmarkField;

    }

    public FeatureAttributeDescriptor getValueField() {

        return valueField;

    }

    public void setValueField(FeatureAttributeDescriptor valueField) {

        this.valueField = valueField;

    }

}

package org.gvsig.lrs.lib.impl.expressionevaluator.symboltable;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTableFactory;

/**

 *

 * @author jjdelcerro

 */

public class LRSSymbolTableFactory extends AbstractSymbolTableFactory {

    private SymbolTable symbolTable;

    public LRSSymbolTableFactory() {

        super(LRSSymbolTable.NAME, true);

    }

    @Override

    public SymbolTable create(Object... args) {

        if( this.symbolTable==null ) {

            this.symbolTable = new LRSSymbolTable();

        }

        return this.symbolTable;

    }

    public static final void selfRegister() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        manager.registerSymbolTable(new LRSSymbolTableFactory());

    }

}

package org.gvsig.lrs.lib.impl.expressionevaluator.symboltable;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.lrs.lib.impl.expressionevaluator.function.lrs.STLineInterpolatePointFunction;

import org.gvsig.lrs.lib.impl.expressionevaluator.function.lrs.STLineLocatePointFunction;

/**

 *

 * @author jjdelcerro

 */

public class LRSSymbolTable extends AbstractSymbolTable {

    public static final String GROUP_LRS = "Linear reference system";

    static final String NAME = "Linear reference system";

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public LRSSymbolTable() {

        super(NAME);

//        this.addFunction(new LRSPointFromGeometryFunction());

        this.addFunction(new STLineLocatePointFunction());

        this.addFunction(new STLineInterpolatePointFunction());

    }

}

package org.gvsig.lrs.lib.impl.expressionevaluator.function.lrs;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractGeometryFunction;

import org.gvsig.fmap.geom.Geometry;

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

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

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

import org.gvsig.lrs.lib.impl.expressionevaluator.symboltable.LRSSymbolTable;

public class STLineInterpolatePointFunction extends AbstractGeometryFunction {

    public static final String FUNCTION_ST_LINEINTERPOLATEPOINT = "ST_LineInterpolatePoint";

    public STLineInterpolatePointFunction() {

        super(

                LRSSymbolTable.GROUP_LRS,

                FUNCTION_ST_LINEINTERPOLATEPOINT,

                Range.is(2),

                "Returns a point interpolated along a line at a fractional location. First argument must be a LINESTRING. Second argument is a float between 0 and 1 representing the fraction of line length where the point is to be located. The Z and M values are interpolated if present.\n" +

                "See ST_LineLocatePoint for computing the line location nearest to a Point.",

                FUNCTION_ST_LINEINTERPOLATEPOINT + "( {{ a_linestring}},  a_fraction)",

                new String[]{

                    " a_linestring - a LineString with M coordinate.",

                    " a_fraction - the fractional location",},

                "Point",

                false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return true;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) throws Exception {

        Geometry geom = this.getGeom(args, 0);

        double fraction = this.getDouble(args, 1);

        return lineInterpolatePoint(geom, fraction);

    }

    public static Point lineInterpolatePoint(Geometry geom, double fraction) throws Exception{

        double l = geom.perimeter();

        Point point;

        if (geom instanceof Line){

            point = ((Line)geom).extractPoint(fraction*l);

        } else if (geom instanceof MultiLine){

            point = ((MultiLine)geom).extractPoint(fraction*l);

        } else {

            throw new IllegalArgumentException("Need Line or MultiLine geometry.");

        }

        return point;

    }

}

package org.gvsig.lrs.lib.impl.expressionevaluator.function.lrs;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractGeometryFunction;

import org.gvsig.fmap.geom.Geometry;

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

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

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

import org.gvsig.lrs.lib.impl.expressionevaluator.symboltable.LRSSymbolTable;

public class STLineLocatePointFunction extends AbstractGeometryFunction {

    public static final String FUNCTION_ST_LINELOCATEPOINT = "ST_LineLocatePoint";

    public STLineLocatePointFunction() {

        super(

                LRSSymbolTable.GROUP_LRS,

                FUNCTION_ST_LINELOCATEPOINT,

                Range.is(2),

                "Returns a float between 0 and 1 representing the location of the closest point on a LineString to the given Point, as a fraction of 2d line length.\n"

                + "You can use the returned location to extract a Point (ST_LineInterpolatePoint) or a substring (ST_LineSubstring).\n"

                + "This is useful for approximating numbers of addresses\n",

                FUNCTION_ST_LINELOCATEPOINT + "( {{ a_linestring}},  a_point)",

                new String[]{

                    " a_linestring - a LineString with M coordinate.",

                    " a_point - a Point (with or without M coordinate) near of the LineString",},

                "Double",

                false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return true;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) throws Exception {

        Geometry geom = this.getGeom(args, 0);

        Point point =this.getPoint(args, 1);

        return lineLocatePoint(geom, point);

    }

    public static double lineLocatePoint(Geometry geom, Point point) throws Exception{

        double l = geom.perimeter();

        double locatePoint;

        if (geom instanceof Line){

            locatePoint = ((Line)geom).getPathLength(point);

        } else if (geom instanceof MultiLine){

            locatePoint = ((MultiLine)geom).getPathLength(point);

        } else {

            throw new IllegalArgumentException("Need Line or MultiLine geometry.");

        }

        double fraction = locatePoint / l;

        return fraction;

    }

}

package org.gvsig.lrs.lib.impl.expressionevaluator.function.lrs;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractGeometryFunction;

import org.gvsig.fmap.geom.Geometry;

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

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

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

import org.gvsig.lrs.lib.impl.expressionevaluator.symboltable.LRSSymbolTable;

public class LRSPointFromGeometryFunction extends AbstractGeometryFunction {

    public static final String FUNCTION_LRSPOINTFROMGEOMETRY = "LRSPointFromGeometry";

    public LRSPointFromGeometryFunction() {

        super(

                LRSSymbolTable.GROUP_LRS, 

                FUNCTION_LRSPOINTFROMGEOMETRY, 

                Range.is(2),

                "Returns ?????? TODO.\n",

                FUNCTION_LRSPOINTFROMGEOMETRY+"( {{geom}}, point_or_distance)",

                new String[]{

                    "geom - TODO.",

                    "point_or_distance - TODO",

                },

                "Point",

                false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return true;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) throws Exception {

        Geometry geom = this.getGeom(args, 0);

        Object v2 = this.getObject(args, 1);

        LrsAlgorithmsManager manager = LrsAlgorithmsLocator.getLrsAlgorithmsManager();

        Point r = null;

        if( v2 instanceof Number ) {

            double distance = this.getDouble(args, 1);

            r = manager.getMPointFromGeometry(geom, distance);

        } else {

            Point point =this.getPoint(args, 1);

            r = manager.getMPointFromGeometry(geom, point);

        }

        return r;

    }

}

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

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

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

/**

 * @author fdiaz

 *

 */

public class DefaultLrsCreateRouteAlgorithmParams implements LrsCreateRouteAlgorithmParams {

    private FeatureStore sourceFeatureStore;

    private FeatureAttributeDescriptor idRouteField;

    private NewFeatureStoreParameters newFeatureStoreParameters;

    private LrsSourceOfMeasures sourceOfMeasures;

    private FeatureAttributeDescriptor fromMeasureField;

    private FeatureAttributeDescriptor toMeasureField;

    private LrsCoordinatesPriority coordinatePriority;

    private double measureFactor = 1.0;

    private double measureOffset = 0.0;

    private boolean ignoreSpatialGaps;

    private final String NAME = "LrsCreateRouteAlgorithm";

    private final String DESCRIPTION = "Algorithm to create routes with linear reference system.";

    /**

     *

     */

    public DefaultLrsCreateRouteAlgorithmParams() {

        measureFactor = 1.0;

        measureOffset = 0.0;

    }

    /* (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#getSourceFeatureStore()

     */

    public FeatureStore getSourceFeatureStore() {

        return sourceFeatureStore;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setSourceFeatureStore(FeatureStore sourceFeatureStore) {

        this.sourceFeatureStore = sourceFeatureStore;

    }

    /*

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

    }

    /*

     * (non-Javadoc)

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

     */

    public LrsSourceOfMeasures getSourceOfMeasures() {

        return sourceOfMeasures;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setSourceOfMeasures(LrsSourceOfMeasures sourceOfMeasures) {

        this.sourceOfMeasures = sourceOfMeasures;

    }

    /*

     * (non-Javadoc)

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

     */

    public FeatureAttributeDescriptor getFromMeasureField() {

        return fromMeasureField;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setFromMeasureField(FeatureAttributeDescriptor fromMeasureField) {

        this.fromMeasureField = fromMeasureField;

    }

    /*

     * (non-Javadoc)

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

     */

    public FeatureAttributeDescriptor getToMeasureField() {

        return toMeasureField;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setToMeasureField(FeatureAttributeDescriptor toMeasureField) {

        this.toMeasureField = toMeasureField;

    }

    /*

     * (non-Javadoc)

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

     */

    public LrsCoordinatesPriority getCoordinatePriority() {

        return coordinatePriority;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setCoordinatePriority(LrsCoordinatesPriority coordinatePriority) {

        this.coordinatePriority = coordinatePriority;

    }

    /*

     * (non-Javadoc)

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

     */

    public double getMeasureFactor() {

        return measureFactor;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setMeasureFactor(double measureFactor) {

        this.measureFactor = measureFactor;

    }

    /*

     * (non-Javadoc)

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

     */

    public double getMeasureOffset() {

        return measureOffset;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setMeasureOffset(double measureOffset) {

        this.measureOffset = measureOffset;

    }

    /*

     * (non-Javadoc)

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

     */

    public boolean ignoreSpatialGaps() {

        return ignoreSpatialGaps;

    }

    /*

     * (non-Javadoc)

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

     */

    public void setIgnoreSpatialGaps(boolean ignoreSpatialGaps) {

        this.ignoreSpatialGaps = ignoreSpatialGaps;

    }

    public NewFeatureStoreParameters getNewFeatureStoreParameters() {

        return this.newFeatureStoreParameters;

    }

    public void setNewFeatureStoreParameters(

        NewFeatureStoreParameters newFeatureStoreParameters) {

        this.newFeatureStoreParameters = newFeatureStoreParameters;

    }

}

package org.gvsig.lrs.lib.impl;

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

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

class DefaultMeasuresCalculator implements MeasuresCalculator {

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

    private Geometry route;

    private List<Boolean> isFixedPoint;

    private List<Double> distances;

    private List<Double> oldMValues;

    private List<Point> vertices;

    private List<Integer> lineIndexes;

    private int MDIMENSION;

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

    @Override

    public Geometry getResult() {

        return route;

    }

    public DefaultMeasuresCalculator(Geometry geometry, boolean ignoreSpatialGaps) {

        isFixedPoint = new ArrayList<Boolean>();

        distances = new ArrayList<Double>();

        oldMValues = new ArrayList<Double>();

        vertices = new ArrayList<Point>();

        lineIndexes = new ArrayList<Integer>();

        route = geometry.cloneGeometry();

        double distance = 0;

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

        Point previousVertex = null;

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

            Line line = lines.get(i);

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

                Point vertex = line.getVertex(j);

                if (j == 0) {

                    if (previousVertex == null) {

                        //First point in geometry

                        MDIMENSION = vertex.getDimension() - 1;

                        distance = 0;

                    }

                    Integer visitedIndex = getIndexVisitedVertex(vertex);

                    if (visitedIndex != null) {

                        previousVertex = vertices.get(visitedIndex);

                        distance = distances.get(visitedIndex);

                    } else {

                        if (previousVertex != null) {

                            try {

                                if (!LrsAlgorithmUtils.equalPoints(vertex, previousVertex)) {

                                    Integer nearestVertexPos = getIndexNearestVisitedVertex(vertex);

                                    if (ignoreSpatialGaps) {

                                        distance = distances.get(nearestVertexPos);

                                    } else {

                                        Point nearestVertex = vertices.get(nearestVertexPos);

                                        distance = distances.get(nearestVertexPos);

                                        distance += vertex.distance(nearestVertex);

                                    }

                                }

                            } catch (Exception e) {

                                distance = Double.NaN;

                            }

                        }

                    }

                } else {

                    try {

                        distance += vertex.distance(previousVertex);

                    } catch (Exception e) {

                        distance = Double.NaN;

                    }

                }

                Double mValue = vertex.getCoordinateAt(MDIMENSION);

                isFixedPoint.add(false);

                vertices.add(vertex);

                distances.add(distance);

                oldMValues.add(mValue);

                lineIndexes.add(i);

                previousVertex = vertex;

            }

        }

    }

    private Integer getIndexNearestVisitedVertex(Point vertex) throws GeometryOperationNotSupportedException, GeometryOperationException {

        double nearestDistance = Double.POSITIVE_INFINITY;

        Integer nearestPointPos = null;

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

            Double distance = vertex.distance(vertices.get(i));

            if (nearestDistance > distance && distance > Double.valueOf(0)) {

                nearestDistance = distance;

                nearestPointPos = i;

            }

        }

        return nearestPointPos;

    }

    private Integer getIndexVisitedVertex(Point point) {

        double distance = Double.NEGATIVE_INFINITY;

        Integer index = null;

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

            if (LrsAlgorithmUtils.equalPoints(point, vertices.get(i))) {

                if (this.distances.get(i) > distance) {

                    distance = this.distances.get(i);

                    index = i;

                }

            }

        }

        return index;

    }

    @Override

    public void addControlPoints(List<Point> fixedPoints) {

        for (Point fixedPoint : fixedPoints) {

            Double length = Double.valueOf(0);

            int index = 0;

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

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

            List<Double> lengths = new ArrayList<Double>();

            List<Double> oldValues = new ArrayList<Double>();

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

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

                Line line = lines.get(i);

                try {

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

                        length = distances.get(index);

                        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;

                            }

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

                                oldMValues.set(index, vertex.getCoordinateAt(MDIMENSION));

                                Double mValue = fixedPoint.getCoordinateAt(MDIMENSION);

                                vertex.setCoordinateAt(MDIMENSION, mValue);

                                isFixedPoint.set(index, true);

                                vertices.set(index, vertex);

                            } else {

                                if (nextVertex != null

                                        && !LrsAlgorithmUtils.equalPoints(nextVertex, fixedPoint)

                                        && vertex.distance(fixedPoint) > PRECISION

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

                                    GeometryManager geomanager = GeometryLocator.getGeometryManager();

                                    Line segment = (Line) geomanager

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

                                    segment.addVertex(vertex);

                                    segment.addVertex(nextVertex);

                                    //FIXME

                                    //if (line.intersects(fixedPoint)){

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

                                        double distanceFirstVertex = distances.get(index);

                                        double distanceToFixedPoint = vertex.distance(fixedPoint);

                                        length = distanceFirstVertex + distanceToFixedPoint;

                                        Double oldMValue = LrsAlgorithmUtils.straightLineThroughTwoPointsEquation(

                                                distances.get(index),

                                                distances.get(index + 1),

                                                vertex.getCoordinateAt(MDIMENSION),

                                                nextVertex.getCoordinateAt(MDIMENSION),

                                                length);

                                        insertAtList.add(index + 1);

                                        lengths.add(length);

                                        oldValues.add(oldMValue);

                                        lineReference.add(i);

                                    }

                                }

                            }

                            index++;

                        }

                    } else {

                        index += line.getNumVertices();

                    }

                } catch (Exception e) {

                    logger.warn("Error inserting point " + fixedPoint.toString(), e);

                }

            }

            int pos = 0;

            for (Integer insertAt : insertAtList) {

                Double distance = lengths.get(pos);

                Double oldMValue = oldValues.get(pos);

                Integer linePos = lineReference.get(pos);

                int correctedPosition = insertAt + pos;

                route = LrsAlgorithmUtils.insertVertex(route, fixedPoint, correctedPosition);

                isFixedPoint.add(correctedPosition, true);

                distances.add(correctedPosition, distance);

                oldMValues.add(correctedPosition, oldMValue);

                lineIndexes.add(correctedPosition, linePos);

                vertices.add(correctedPosition, fixedPoint);

                pos++;

            }

        }

    }

    @Override

    public void setFirstMeasure(double mvalue) {

        Point mPoint = (Point) this.vertices.get(0).cloneGeometry();

        int mDimension = mPoint.getDimension() - 1;

        mPoint.setCoordinateAt(mDimension, mvalue);

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

        points.add(mPoint);

        this.addControlPoints(points);

    }

    @Override

    public void setLastMeasure(double mvalue) {

        Point mPoint = (Point) this.vertices.get(this.vertices.size()-1).cloneGeometry();

        int mDimension = mPoint.getDimension() - 1;

        mPoint.setCoordinateAt(mDimension, mvalue);

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

        points.add(mPoint);

        this.addControlPoints(points);

    }

    @Override

    public void setMeasuresToDistances() {

        List<Point> points = LrsAlgorithmUtils.extractPoints(route);

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

            if (!isFixedPoint.get(i)) {

                points.get(i).setCoordinateAt(MDIMENSION, distances.get(i));

                vertices.get(i).setCoordinateAt(MDIMENSION, distances.get(i));

                oldMValues.set(i, distances.get(i));

            }

        }

    }

    @Override

	public void calculate() {

        this.calculate(

                LrsMeasureCalculationMethods.DISTANCE,

                false,

                true,

                false

        );

    }

    @Override

    public void calculate(LrsMeasureCalculationMethods calculationMethod, boolean before, boolean between, boolean after) {

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

            if (!isFixedPoint.get(i)) {

                Integer prevFixedPointPos = getPreviousPosFixedPoint(i);

                Integer nextFixedPointPos = getNextPosFixedPoint(i, false);

                if (prevFixedPointPos == null && nextFixedPointPos != null && before) {

                    extrapolateBeforeCalibrationPoints(calculationMethod, nextFixedPointPos, i);

                }

                if (prevFixedPointPos != null && nextFixedPointPos != null && between) {

                    calculateMValue(calculationMethod, prevFixedPointPos, nextFixedPointPos, i);

                }

                if (prevFixedPointPos != null && nextFixedPointPos == null && after) {

                    extrapolateAfterCalibrationPoints(calculationMethod, prevFixedPointPos, i);

                }

            }

        }

    }

    private void extrapolateBeforeCalibrationPoints(LrsMeasureCalculationMethods calculationMethod, int firstFixedPointPos, int pos) {

        Integer secondFixedPointPos = getNextPosFixedPoint(firstFixedPointPos, false);

        if (secondFixedPointPos != null) {

            if (calculationMethod.equals(LrsMeasureCalculationMethods.DISTANCE)) {

                if (!isFixedPoint.get(pos)) {

                    List<Point> points = LrsAlgorithmUtils.extractPoints(route);

                    points.get(pos).setCoordinateAt(MDIMENSION, distances.get(pos));

                    vertices.get(pos).setCoordinateAt(MDIMENSION, distances.get(pos));

                    oldMValues.set(pos, distances.get(pos));

                }

            }

            Double newMValueFirstPoint = vertices.get(firstFixedPointPos).getCoordinateAt(MDIMENSION);

            Double newMValueSecondPoint = vertices.get(secondFixedPointPos).getCoordinateAt(MDIMENSION);

            Double oldMValueFirstPoint;

            Double oldMValueSecondPoint;

            if (calculationMethod.equals(LrsMeasureCalculationMethods.DISTANCE)) {

                oldMValueFirstPoint = distances.get(firstFixedPointPos);

                oldMValueSecondPoint = distances.get(secondFixedPointPos);

            } else {

                oldMValueFirstPoint = oldMValues.get(firstFixedPointPos);

                oldMValueSecondPoint = oldMValues.get(secondFixedPointPos);

            }

            Double distanceBetweenFixedPoints = newMValueSecondPoint - newMValueFirstPoint;

            Double distanceBetweenOldFixedPoints = oldMValueSecondPoint - oldMValueFirstPoint;

            Double calibrationRatio = distanceBetweenOldFixedPoints / distanceBetweenFixedPoints;

            Double valueToRecalculate = vertices.get(pos).getCoordinateAt(MDIMENSION);

            Double distanceBetween = oldMValueFirstPoint - valueToRecalculate;

            Double mValue = newMValueFirstPoint - (distanceBetween / calibrationRatio);

            refreshMValueGeometryVertex(pos, mValue, false);

        }

    }

    private void extrapolateAfterCalibrationPoints(LrsMeasureCalculationMethods calculationMethod, int lastFixedPointPos, int pos) {

        Integer prevFixedPointPos = getPreviousPosFixedPoint(lastFixedPointPos);

        if (prevFixedPointPos != null) {

            calculateMValue(calculationMethod, prevFixedPointPos, lastFixedPointPos, pos);

        }

    }

    private void calculateMValue(LrsMeasureCalculationMethods calculationMethod, Integer prevFixedPointPos, int nextFixedPointPos, int pos) {

        if (calculationMethod.equals(LrsMeasureCalculationMethods.DISTANCE)) {

            if (!isFixedPoint.get(pos)) {

                List<Point> points = LrsAlgorithmUtils.extractPoints(route);

                points.get(pos).setCoordinateAt(MDIMENSION, distances.get(pos));

                vertices.get(pos).setCoordinateAt(MDIMENSION, distances.get(pos));

                oldMValues.set(pos, distances.get(pos));

            }

        }

        Double newMValueBeforePoint = vertices.get(prevFixedPointPos).getCoordinateAt(MDIMENSION);

        Double newMValueAfterPoint = vertices.get(nextFixedPointPos).getCoordinateAt(MDIMENSION);

        while (newMValueBeforePoint.equals(newMValueAfterPoint)) {

            prevFixedPointPos = getPreviousPosFixedPoint(prevFixedPointPos);

            if (prevFixedPointPos != null) {

                newMValueBeforePoint = vertices.get(prevFixedPointPos).getCoordinateAt(MDIMENSION);

            } else {

                refreshMValueGeometryVertex(pos, Double.NaN, false);

                return;

            }

        }

        Double oldMValueBeforePoint;

        Double oldMValueAfterPoint;

        if (calculationMethod.equals(LrsMeasureCalculationMethods.DISTANCE)) {

            oldMValueBeforePoint = distances.get(prevFixedPointPos);

            oldMValueAfterPoint = distances.get(nextFixedPointPos);

        } else {