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 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 {

            oldMValueBeforePoint = oldMValues.get(prevFixedPointPos);

            oldMValueAfterPoint = oldMValues.get(nextFixedPointPos);

        }

        Double distanceBetweenFixedPoints = newMValueAfterPoint - newMValueBeforePoint;

        Double distanceBetweenOldFixedPoints = oldMValueAfterPoint - oldMValueBeforePoint;

        Double calibrationRatio = distanceBetweenOldFixedPoints / distanceBetweenFixedPoints;

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

        Double distanceBetween = valueToRecalculate - oldMValueBeforePoint;

        Double mValue = newMValueBeforePoint + (distanceBetween / calibrationRatio);

        refreshMValueGeometryVertex(pos, mValue, true);

    }

    private Integer getNextPosFixedPoint(int pos, boolean selfInclude) {

        Integer nextFixedPointPos = findNextFixedPointInLine(pos, selfInclude);

        if (nextFixedPointPos != null) {

            return nextFixedPointPos;

        } else {

            int lastPositionInLine = getLastPositionInLine(pos);

            nextFixedPointPos = findNextFixedPointInNextLines(lastPositionInLine, new ArrayList<Integer>());

            if (nextFixedPointPos != null) {

                return nextFixedPointPos;

            }

            try {

                Integer nearestVertex = findNearestNextPoint(lastPositionInLine);

                return getNextPosFixedPoint(nearestVertex, true);

            } catch (Exception e) {

                return null;

            }

        }

    }

    private Integer getLastPositionInLine(int pos) {

        Integer lineVisited = lineIndexes.get(pos);

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

            if (!lineVisited.equals(lineIndexes.get(i))) {

                return i - 1;

            }

        }

        return vertices.size() - 1;

    }

    private Integer findNextFixedPointInNextLines(int pos, List<Integer> visitedLines) {

        Integer nextFixedPointPos = findNextFixedPointInLine(pos, true);

        if (nextFixedPointPos != null) {

            return nextFixedPointPos;

        } else {

            Integer lineIndex = lineIndexes.get(pos);

            visitedLines.add(lineIndex);

            int lastPositionInLine = getLastPositionInLine(pos);

            Point lastVertexInLine = vertices.get(lastPositionInLine);

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

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

                    if (!visitedLines.contains(lineIndexes.get(i))) {

                        findNextFixedPointInNextLines(i, visitedLines);

                    }

                }

            }

        }

        return null;

    }

    private Integer findNextFixedPointInLine(int vertexPos, boolean selfInclude) {

        int lineIndex = lineIndexes.get(vertexPos);

        if (!selfInclude) {

            vertexPos += 1;

        }

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

            if (!lineIndexes.get(i).equals(lineIndex)) {

                return null;

            }

            if (isFixedPoint.get(i)) {

                return i;

            }

        }

        return null;

    }

    private Integer findNearestNextPoint(int vertexPos) throws GeometryOperationNotSupportedException, GeometryOperationException {

        Point vertex = vertices.get(vertexPos);

        double nearestDistance = Double.POSITIVE_INFINITY;

        Integer nearestPointPos = null;

        for (int i = vertexPos + 1; 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 getPreviousPosFixedPoint(int pos) {

        Integer prevFixedPointPos = findPrevFixedPointInLine(pos);

        if (prevFixedPointPos != null) {

            return prevFixedPointPos;

        } else {

            Integer lineVisited = lineIndexes.get(pos);

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

                if (!lineVisited.equals(lineIndexes.get(i))) {//Line has changed

                    int lastPositionInLine = i + 1;

                    for (int j = lastPositionInLine; j >= 0; j--) {

                        if (LrsAlgorithmUtils.equalPoints(vertices.get(lastPositionInLine), vertices.get(j))) {

                            if (isFixedPoint.get(j) && j < pos) {

                                return j;

                            }

                        }

                    }

                    try {

                        return findNearestPrevFixedPoint(lastPositionInLine);

                    } catch (Exception e) {

                        return null;

                    }

                }

            }

        }

        return null;

    }

    private Integer findPrevFixedPointInLine(int vertexPos) {

        int lineIndex = lineIndexes.get(vertexPos);

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

            if (!lineIndexes.get(i).equals(lineIndex)) {

                return null;

            }

            if (isFixedPoint.get(i)) {

                return i;

            }

        }

        return null;

    }

    private Integer findNearestPrevFixedPoint(int vertexPos) throws GeometryOperationNotSupportedException, GeometryOperationException {

        Point vertex = vertices.get(vertexPos);

        double nearestDistance = Double.POSITIVE_INFINITY;

        Integer nearestPointPos = null;

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

            if (isFixedPoint.get(i)) {

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

                if (nearestDistance > distance) {

                    nearestDistance = distance;

                    nearestPointPos = i;

                }

            }

        }

        return nearestPointPos;

    }

    private void refreshMValueGeometryVertex(int i, Double mValue, boolean fixed) {

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

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

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

        isFixedPoint.set(i, fixed);

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

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

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

 */

package org.gvsig.lrs.lib.impl;

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

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

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 * @author fdiaz</a>

 *

 */

public class DefaultLrsAlgorithmsLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(LrsAlgorithmsLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        LrsAlgorithmsLocator.registerLrsAlgorithmsManager(DefaultLrsAlgorithmsManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

    }

}

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

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.feature.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.FeatureQuery;

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.dal.store.shp.SHPStoreProvider;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 * @author fdiaz

 *

 */

public class LrsGenerateDynamicSegmentationAlgorithm implements LrsAlgorithm {

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

    private LrsGenerateDynamicSegmentationAlgorithmParams parameters;

    /**

     *

     */

    public LrsGenerateDynamicSegmentationAlgorithm(LrsGenerateDynamicSegmentationAlgorithmParams 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(final SimpleTaskStatus taskStatus) throws LrsException {

        NewFeatureStoreParameters newFeatureStoreParameters = parameters.getNewFeatureStoreParameters();

        final FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        final FeatureAttributeDescriptor idRouteField = parameters.getIdRouteField();

        final FeatureAttributeDescriptor idTableRouteField = parameters.getValueTableIdRouteField();

        FeatureStore tableFeatureStore = parameters.getValueTableFeatureStore();

        final FeatureAttributeDescriptor landmarkField = parameters.getLandmarkField();

        final FeatureAttributeDescriptor finalLandmarkField = parameters.getFinalLandmarkField();

        final FeatureAttributeDescriptor valueField = parameters.getValueField();

        logger.info(parameters.toString());

        taskStatus.setTitle(parameters.getName());

        I18nManager i18nManager = ToolsLocator.getI18nManager();

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

        try {

            final String tableRouteFieldName=idTableRouteField.getName();

            final String fromFieldName;

            final DataType fromDataType;

            final String toFieldName;

            final DataType toDataType;

            final int geomType;

            if (landmarkField!=null){

                fromDataType=landmarkField.getDataType();

                if (finalLandmarkField!=null){

                    fromFieldName="PK INICIAL";

                    toFieldName="PK FINAL";

                    toDataType=finalLandmarkField.getDataType();

                    geomType = Geometry.TYPES.MULTILINE;

                }else{

                    fromFieldName="PK";

                    toFieldName=null;

                    toDataType=null;

                    geomType = Geometry.TYPES.POINT;

                }

            }else{

                //TODO: Si no hay fromFieldName ?salir por patas?

                fromFieldName=null;

                fromDataType=null;

                toFieldName=null;

                toDataType=null;

                geomType = Geometry.TYPES.POINT;

            }

            final FeatureStore newFeatureStore = createNewDataStore(

                newFeatureStoreParameters,

                idRouteField,

                fromFieldName,

                toFieldName,

                valueField,

                geomType

             );

            FeatureSet tableFeatures;

            tableFeatures=tableFeatureStore.getFeatureSet();

            taskStatus.setRangeOfValues(0, tableFeatures.getSize()-1);

            newFeatureStore.edit(FeatureStore.MODE_FULLEDIT);

            tableFeatures.accept(new Visitor() {

                int taskCount=0;

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

                    Feature feature = (Feature) obj;

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

                    Object objFrom = null;

                    Object objTo = null;

                    if (fromFieldName != null) {

                        objFrom = feature.get(landmarkField.getName());

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

                        Object value = feature.get(valueField.getName());

                        if (toFieldName == null || toFieldName.isEmpty()) {

                            addSegmentatePointsFeatures(newFeatureStore, sourceFeatureStore, idRouteField, routeName, fromFieldName, fromValue, valueField, value);

                        } else {

                            objTo = feature.get(finalLandmarkField.getName());

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

                            addSegmentateLinesFeatures(newFeatureStore, sourceFeatureStore, idRouteField, routeName,

                                fromFieldName, fromValue, toFieldName, toValue, valueField, value);

                        }

                    } else {

                        //TODO: ?Exception?

                    }

                    taskStatus.setCurValue(taskCount++);

                }

                private void addSegmentatePointsFeatures(final FeatureStore featureStore,

                    FeatureStore sourceFeatureStore, final FeatureAttributeDescriptor idRouteField,

                    final String routeName, final String fromFieldName, final double fromValue, final FeatureAttributeDescriptor valueField, final Object value)

                    throws LocatorException, BaseException {

                    DataManager dataManager = DALLocator.getDataManager();

                    FeatureQuery query = sourceFeatureStore.createFeatureQuery();

                    String expression = StringUtils.replace(StringUtils.replace("NOMBRE = 'a%'", "NOMBRE", idRouteField.getName()), "a%", routeName);

                    query.setFilter( dataManager.createExpresion(expression) );

                    FeatureSet features = sourceFeatureStore.getFeatureSet(query);

                    features.accept(new Visitor() {

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

                            Feature feature = (Feature)obj;

                            Geometry geom = feature.getDefaultGeometry();

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

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

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

                                EditableFeature newFeature = featureStore.createNewFeature(true);

                                newFeature.set(idRouteField.getName(), routeName);

                                newFeature.set(fromFieldName, fromValue);

                                newFeature.set(valueField.getName(), value);

                                newFeature.setDefaultGeometry(point);

                                featureStore.insert(newFeature);

                            }

                        }

                    });

                }

                private void addSegmentateLinesFeatures(final FeatureStore featureStore,

                    FeatureStore sourceFeatureStore, final FeatureAttributeDescriptor idRouteField,

                    final String routeName, final String fromFieldName, final double fromValue,

                    final String toFieldName, final double toValue, final FeatureAttributeDescriptor valueField, final Object value) throws LocatorException, BaseException {

                    DataManager dataManager = DALLocator.getDataManager();

                    FeatureQuery query = sourceFeatureStore.createFeatureQuery();

                    String expression = StringUtils.replace(StringUtils.replace("NOMBRE = 'a%'", "NOMBRE", idRouteField.getName()), "a%", routeName);

                    query.setFilter( dataManager.createExpresion(expression) );

                    FeatureSet features = sourceFeatureStore.getFeatureSet(query);

                    features.accept(new Visitor() {

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

                            Feature feature = (Feature) obj;

                            Geometry geom = feature.getDefaultGeometry();

                            MultiLine lines = LrsAlgorithmUtils.getLinesBetweenTwoM(geom, fromValue, toValue);

                            if (lines != null && lines.getPrimitivesNumber()>0) {

                                EditableFeature newFeature = featureStore.createNewFeature(true);

                                newFeature.set(idRouteField.getName(), routeName);

                                newFeature.set(fromFieldName, fromValue);

                                newFeature.set(toFieldName, toValue);

                                newFeature.set(valueField.getName(), value);

                                newFeature.setDefaultGeometry(lines);

                                featureStore.insert(newFeature);

                            }

                        }

                    });

                }

            });

            newFeatureStore.finishEditing();

        } catch (Exception e1) {

            taskStatus.abort();

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

        }

        taskStatus.terminate();

    }

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

        }

        this.parameters = (LrsGenerateDynamicSegmentationAlgorithmParams) params;

    }

    private FeatureStore createNewDataStore(

        NewFeatureStoreParameters newFeatureStoreParameters,

        FeatureAttributeDescriptor idRouteField,

        String fromFieldName,

        String toFieldName,

        FeatureAttributeDescriptor valueField,

        int type) throws Exception{

        try {

            SHPNewStoreParameters shapeStoreParams = (SHPNewStoreParameters)newFeatureStoreParameters;

            File file=shapeStoreParams.getFile();

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

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorerParameters serverParams =

                dataManager.createServerExplorerParameters("FilesystemExplorer");

            serverParams.setDynValue("initialpath", filePath);

            DataServerExplorer serverExplorer =

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

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

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

            featureType.add(fromFieldName, DataTypes.DOUBLE);

            if(toFieldName!=null){

                featureType.add(toFieldName, DataTypes.DOUBLE);

            }

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

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

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

            geometryField.setGeometryType(geometryType);

            featureType.setDefaultGeometryAttributeName("Geometry");

            shapeStoreParams.setDefaultFeatureType(featureType);

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

            DataStore store = dataManager.openStore(SHPStoreProvider.NAME, shapeStoreParams);

            return (FeatureStore)store;

        } catch (Exception e) {

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

        }

    }

}

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

/**

 * @author dmartinez

 *

 */

public class DefaultLrsCalibrateRouteAlgorithmParams implements LrsCalibrateRouteAlgorithmParams {

    private FeatureStore sourceFeatureStore;

    private FeatureAttributeDescriptor idRouteField;

    private NewFeatureStoreParameters newFeatureStoreParameters;

    private FeatureStore calibratePointFeatureStore;

    private FeatureAttributeDescriptor calibratePointIdRouteField;

    private FeatureAttributeDescriptor fromMeasureField;

    private LrsMeasureCalculationMethods measureCalculationMethods;

    private DistanceUnits measureUnits;

    private double searchRadius = 0.0;

    private boolean interpolateBetweenCalibrationPoints=false;

    private boolean extrapolateBeforeCalibrationPoints=false;

    private boolean extrapolateAfterCalibrationPoints=false;

    private boolean ignoreSpatialGaps=false;

    private boolean includeAll=false;

    private final String NAME = "LrsCalibrateRouteAlgorithm";

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

    /**

     *

     */

    public DefaultLrsCalibrateRouteAlgorithmParams() {

        searchRadius = 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#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#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;

    }

    public FeatureStore getCalibratePointFeatureStore() {

        return calibratePointFeatureStore;

    }

    public void setCalibratePointFeatureStore(

        FeatureStore calibratePointFeatureStore) {

        this.calibratePointFeatureStore = calibratePointFeatureStore;

    }

    public FeatureAttributeDescriptor getCalibratePointIdRouteField() {

        return calibratePointIdRouteField;

    }

    public void setCalibratePointIdRouteField(

        FeatureAttributeDescriptor calibratePointIdRouteField) {

        this.calibratePointIdRouteField = calibratePointIdRouteField;

    }

    public LrsMeasureCalculationMethods getMeasureCalculationMethods() {

        return measureCalculationMethods;

    }

    public void setMeasureCalculationMethods(

        LrsMeasureCalculationMethods measureCalculationMethods) {

        this.measureCalculationMethods = measureCalculationMethods;

    }

    public DistanceUnits getMeasureUnits() {

        return measureUnits;

    }

    public void setMeasureUnits(DistanceUnits measureUnits) {

        this.measureUnits = measureUnits;

    }

    public double getSearchRadius() {

        return searchRadius;

    }

    public void setSearchRadius(double searchRadius) {

        this.searchRadius = searchRadius;

    }

    public boolean interpolateBetweenCalibrationPoints() {

        return interpolateBetweenCalibrationPoints;

    }

    public void setInterpolateBetweenCalibrationPoints(

        boolean interpolateBetweenCalibrationPoints) {

        this.interpolateBetweenCalibrationPoints =

            interpolateBetweenCalibrationPoints;

    }

    public boolean extrapolateBeforeCalibrationPoints() {

        return extrapolateBeforeCalibrationPoints;

    }

    public void setExtrapolateBeforeCalibrationPoints(

        boolean extrapolateBeforeCalibrationPoints) {

        this.extrapolateBeforeCalibrationPoints =

            extrapolateBeforeCalibrationPoints;

    }

    public boolean extrapolateAfterCalibrationPoints() {

        return extrapolateAfterCalibrationPoints;

    }

    public void setExtrapolateAfterCalibrationPoints(

        boolean extrapolateAfterCalibrationPoints) {

        this.extrapolateAfterCalibrationPoints = extrapolateAfterCalibrationPoints;

    }

    public boolean includeAll() {

        return includeAll;

    }

    public void setIncludeAll(boolean includeAll) {

        this.includeAll = includeAll;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

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

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

 */

package org.gvsig.lrs.lib.impl;

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

/**

 * @author dmartinez

 *

 */

public class DefaultLrsShowMeasuresAlgorithmParams implements LrsShowMeasuresAlgorithmParams {

    private double distance = 0.0;

    private final String NAME = "LrsShowMeasuresAlgorithm";

    private final String DESCRIPTION = "Algorithm to show measures with linear reference system.";

    /**

     *

     */

    public DefaultLrsShowMeasuresAlgorithmParams() {

        distance = 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;

    }

    public double getDistance() {

        return distance;

    }

    public void setDistance(double distance) {

        this.distance = distance;

    }