Application: gvSIG desktop » gvSIG Linear Reference System

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

                    final SHPNewStoreParameters shpParams=(SHPNewStoreParameters)params.getNewFeatureStoreParameters();

                                int resultLoadLayer =JOptionPane.showConfirmDialog(

                                    null,

                                    i18nManager.getTranslation("load_layer_question"),

                                    i18nManager.getTranslation("load_layer_question_title"), JOptionPane.YES_NO_OPTION);

                                if (resultLoadLayer==JOptionPane.YES_OPTION){

                                    loadLayer(shpParams);

                                }

    private void loadLayer(SHPNewStoreParameters shpParams){

        if (shpParams!=null ){

            String name=shpParams.getFile().getName();

            if (name.contains(".shp")){

                name=name.substring(0,name.lastIndexOf(".shp"));

            }

            MapContextManager mapContextManager =MapContextLocator.getMapContextManager();

            FLyrVect newLayer=null;

            try {

                newLayer = (FLyrVect) mapContextManager.createLayer(name,shpParams);

            } catch (LoadLayerException e) {

                logger.warn("Couldn't load layer",e);

            }

            getActiveView().getMapControl().getMapContext().getLayers().addLayer(newLayer);

        }

    }

units=Unidades

kilometer=kil\u00f3metro

meter=metro

centimeter=cent\u00edmetro

millimeter=mil\u00edmetro

mile=milla

yards=yardas

feet=pies

inch=pulgada

units=Units

kilometer=kilometer

meter=meter

centimeter=centimeter

millimeter=millimeter

mile=mile

yards=yards

feet=feet

inch=inch

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.api.exceptions;

public class LrsCalibrateRouteException extends LrsException {

    /**

     *

     */

    private static final long serialVersionUID = -7593469257155358436L;

    private static final String MESSAGE =

        "Error calibrating routes.";

    private static final String KEY = "_LrsCalibrateRouteException";

    public LrsCalibrateRouteException(Throwable ex) {

        super(MESSAGE, ex, KEY, serialVersionUID);

    }

    public LrsCalibrateRouteException(String message, Throwable ex) {

        super(message, ex, KEY, serialVersionUID);

    }

}

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

                    return;

    static protected Double calculateM(Double maxValue, Double minValue,

        Double relativeDistance, Double totalLength) {

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

        if (totalLength.equals(Double.valueOf(0)))

            return Double.POSITIVE_INFINITY;

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

            + minValue;

    }

    static protected double calculateNewM(double oldMax, double oldMin, double newMax, double newMin, double mCoordinate){

        double result;

        if (oldMax==oldMin){

            return Double.POSITIVE_INFINITY;

        }

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

        return result;

    }

import org.cresques.cts.IProjection;

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

        NewFeatureStoreParameters newFeatureStoreParameters =

            parameters.getNewFeatureStoreParameters();

        FeatureStore calibratePointFeatureStore= parameters.getCalibratePointFeatureStore();

        FeatureAttributeDescriptor idRouteCalibratePointField =parameters.getCalibratePointIdRouteField();

        FeatureAttributeDescriptor fromMeasureField = parameters.getFromMeasureField();

        final boolean includeAll=parameters.includeAll();

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

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

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

                sourceFeatures = sourceFeatureStore.getFeatureSelection();

            } else {

                sourceFeatures = sourceFeatureStore.getFeatureSet();

            final Map<String, Object[]> featuresMap =

                new HashMap<String, Object[]>();

                public void visit(Object obj)

                    throws VisitCanceledException, BaseException {

                    Feature feature = (Feature) obj;

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

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

                    Object[] valueObject=new Object[2];

                    valueObject[0]=feature.getDefaultGeometry();

                    valueObject[1]=points;

                    featuresMap.put(routeName, valueObject);

                }

            });

            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 Object[]){

                            Object[] objArray=(Object[])valueObject;

                            if (objArray[1] instanceof List){

                                List<Point> points=(List<Point>)objArray[1];

                                if (feature.getDefaultGeometry() instanceof Point){

                                    Geometry geometry=(Geometry)objArray[0];

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

                                        try {

                                            Point mPoint= pointToMPoint(geometry,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, Object[]> entry : featuresMap

                .entrySet()) {

                String routeName = entry.getKey();

                Object valueObject = entry.getValue();

                List<Point> points=null;

                Geometry geometry=null;

                if (valueObject!=null && valueObject instanceof Object[]){

                    Object[] objArray=(Object[])valueObject;

                    if (objArray[0] instanceof Geometry){

                        geometry=(Geometry)objArray[0];

                    }

                    if (objArray[1] instanceof List){

                        points=(List<Point>)objArray[1];

                    }

                }

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

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

    private Point pointToMPoint(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(){

        FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        IProjection projection;

        try {

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

        if (points.isEmpty()){

            return geometry;

        }

        ExpandedRoute expandedRoute=new ExpandedRoute(geometry, ignoreSpatialGaps);

        switch (calculationMethod) {

        case DISTANCE:

            expandedRoute.resetMeasuresToDistances();

        case MEASURES:

        default:

            expandedRoute.addFixedPoints(points);

            if (interpolateBetweenCalibrationPoints){

                expandedRoute.interpolateBetweenCalibrationPoints();

            }

            if (extrapolateBeforeCalibrationPoints){

                expandedRoute.extrapolateBeforeCalibrationPoints();

            }

            if (extrapolateAfterCalibrationPoints){

                expandedRoute.extrapolateAfterCalibrationPoints();

            }

            return expandedRoute.getRoute();

        }

    class ExpandedRoute{

        private Geometry route;

        private List<Boolean> isFixedPoint;

        private List<Double> distances;

        private List<Double>oldMValues;

        private List<Point> vertices;

        private int MDIMENSION;

        private int maxMFixedPointPos;

        private int minMFixedPointPos;

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

        public Geometry getRoute(){

            return route;

        }

        public ExpandedRoute(Geometry geometry, boolean ignoreSpatialGaps){

            isFixedPoint=new ArrayList<Boolean>();

            distances=new ArrayList<Double>();

            oldMValues=new ArrayList<Double>();

            vertices=new ArrayList<Point>();

            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 (!ignoreSpatialGaps){

                                       distance+=previousVertex.distance(vertex);

                                   }

                               } 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);

                    previousVertex = vertex;

                }

            }

        }

        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;

        }

        private void addFixedPoints(List<Point> fixedPoints){

            Double minMValue=null;

            Double maxMValue=null;

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

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

                    Line line=lines.get(i);

                    try{

                        //FIXME

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

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

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

                                    Double mValue=fixedPoint.getCoordinateAt(MDIMENSION);

                                    vertex.setCoordinateAt(MDIMENSION, mValue);

                                    isFixedPoint.set(index, true);

                                    vertices.set(index, vertex);

                                    if (minMValue==null||mValue.compareTo(minMValue)<0){

                                        minMValue=mValue;

                                        minMFixedPointPos=index;

                                    }

                                    if (maxMValue==null||mValue.compareTo(maxMValue)>=0){

                                        maxMValue=mValue;

                                        maxMFixedPointPos=index;

                                    }

                                }else{

                                    if (nextVertex!=null && !LrsAlgorithmUtils.equalPoints(nextVertex, fixedPoint)){

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

                                            length+=vertex.distance(fixedPoint);

                                            Double oldMValue=LrsAlgorithmUtils.calculateNewM(

                                                nextVertex.getCoordinateAt(MDIMENSION),

                                                vertex.getCoordinateAt(MDIMENSION),

                                                distances.get(index+1),

                                                distances.get(index),

                                                length);

                                            insertAtList.add(index+1);

                                            lengths.add(length);

                                            oldValues.add(oldMValue);

                                        }

                                    }

                                }

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

                    int correctedPosition=insertAt+pos;

                    LrsAlgorithmUtils.insertVertex(route, fixedPoint, correctedPosition);

                    isFixedPoint.add(correctedPosition, true);

                    distances.add(correctedPosition, distance);

                    oldMValues.add(correctedPosition, oldMValue);

                    vertices.add(correctedPosition, fixedPoint);

                    correctPosteriorPositions(correctedPosition);

                    Double mValue=fixedPoint.getCoordinateAt(MDIMENSION);

                    if (minMValue==null||mValue.compareTo(minMValue)<0){

                        minMValue=mValue;

                        minMFixedPointPos=correctedPosition;

                    }

                    if (maxMValue==null||mValue.compareTo(maxMValue)>=0){

                        maxMValue=mValue;

                        maxMFixedPointPos=correctedPosition;

                    }

                    pos++;

                }

            }

        }

        private void correctPosteriorPositions(int pos){

            if (minMFixedPointPos>=pos){

                minMFixedPointPos++;

            }

            if (maxMFixedPointPos>=pos){

                maxMFixedPointPos++;

            }

        }

        public void resetMeasuresToDistances(){

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

                 }

             }

        }

        public void interpolateBetweenCalibrationPoints(){

            Double newMValueBeforePoint=Double.NaN;

            Double oldMValueBeforePoint=Double.NaN;

            Double calibrationRatio=Double.NaN;

            for (int i=minMFixedPointPos; i<=maxMFixedPointPos-1;i++){

                if (isFixedPoint.get(i)){

                    int pointBeforePos=i;

                    int pointAfterPos=getNextPosFixedPoint(i);

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

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

                    oldMValueBeforePoint=oldMValues.get(pointBeforePos);

                    Double oldMValueAfterPoint=oldMValues.get(pointAfterPos);

                    Double distanceBetweenFixedPoints=newMValueAfterPoint-newMValueBeforePoint;

                    Double distanceBetweenOldFixedPoints=oldMValueAfterPoint-oldMValueBeforePoint;

                    calibrationRatio=distanceBetweenOldFixedPoints/distanceBetweenFixedPoints;

                }else{

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

                    Double distanceBetween=valueToRecalculate-oldMValueBeforePoint;

                    Double mValue=newMValueBeforePoint+(distanceBetween/calibrationRatio);

                    refreshMValueGeometryVertex(i,mValue);

                }

            }

        }

        public void extrapolateBeforeCalibrationPoints(){

            int nextFixedPointPos=getNextPosFixedPoint(minMFixedPointPos);

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

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

            Double oldMValueFirstPoint=oldMValues.get(minMFixedPointPos);

            Double oldMValueSecondPoint=oldMValues.get(nextFixedPointPos);

            Double distanceBetweenFixedPoints=newMValueSecondPoint-newMValueFirstPoint;

            Double distanceBetweenOldFixedPoints=oldMValueSecondPoint-oldMValueFirstPoint;

            Double calibrationRatio=distanceBetweenOldFixedPoints/distanceBetweenFixedPoints;

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

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

                Double distanceBetween=oldMValueFirstPoint-valueToRecalculate;

                Double mValue=newMValueFirstPoint-(distanceBetween/calibrationRatio);

                refreshMValueGeometryVertex(i,mValue);

            }

        }

        public void extrapolateAfterCalibrationPoints(){

            int prevFixedPointPos=getPreviousPosFixedPoint(maxMFixedPointPos);

            Double newMValueLastPoint=vertices.get(maxMFixedPointPos).getCoordinateAt(MDIMENSION);

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

            Double oldMValueLastPoint=oldMValues.get(maxMFixedPointPos);

            Double oldMValuePrevPoint=oldMValues.get(prevFixedPointPos);

            Double distanceBetweenFixedPoints=newMValueLastPoint-newMValuePrevPoint;

            Double distanceBetweenOldFixedPoints=oldMValueLastPoint-oldMValuePrevPoint;

            Double calibrationRatio=distanceBetweenOldFixedPoints/distanceBetweenFixedPoints;

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

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

                Double distanceBetween=valueToRecalculate-oldMValueLastPoint;

                Double mValue=newMValueLastPoint+(distanceBetween/calibrationRatio);

                refreshMValueGeometryVertex(i,mValue);

            }

        }

        private Integer getNextPosFixedPoint(int pos){

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

                if (isFixedPoint.get(i)){

                    if( !distances.get(pos).equals(distances.get(i)) ){

                        return i;

                    }

                }

            }

            return null;

        }

        private Integer getPreviousPosFixedPoint(int pos){

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

                if (isFixedPoint.get(i)){

                    if( !distances.get(pos).equals(distances.get(i)) ){

                        return i;

                    }

                }

            }

            return null;

        }

        private void refreshMValueGeometryVertex(int i, Double mValue){

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

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

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

        }

   <at name="id">/home/daniel/projects/externals/gvSIG/org.gvsig.lrs/org.gvsig.lrs.swing/org.gvsig.lrs.swing.impl/src/main/java/org/gvsig/lrs/swing/impl/JLrsCalibrateRouteParamsView.xml</at>

        <at name="id">embedded.249315505</at>

        <at name="id">embedded.616715470</at>

        <at name="colspecs">FILL:50DLU:GROW(1.0),FILL:DEFAULT:NONE,FILL:4DLU:NONE,FILL:DEFAULT:NONE</at>

                 <at name="text">units</at>

                 <at name="width">28</at>

                 <at name="width">654</at>

            <at name="name"></at>

        <at name="id">embedded.1448976003</at>

      FormLayout formlayout1 = new FormLayout("FILL:20DLU:GROW(1.0),FILL:DEFAULT:NONE,FILL:4DLU:NONE,FILL:DEFAULT:NONE","CENTER:DEFAULT:NONE");

      lblMeasureUnits.setText("units");