Application: gvSIG desktop » gvSIG Linear Reference System

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

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

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

 */

package org.gvsig.lrs.lib.impl;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

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

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 * @author fdiaz

 *

 */

public class LrsCreateRouteAlgorithm implements LrsAlgorithm {

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

    private LrsCreateRouteAlgorithmParams parameters;

    /**

     *

     */

    public LrsCreateRouteAlgorithm(LrsCreateRouteAlgorithmParams parameters) {

        this.parameters = parameters;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.tools.service.Service#getManager()

     */

    public Manager getManager() {

        return null;

    }

    /*

     * (non-Javadoc)

     *

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

     */

    public  LrsAlgorithmParams getParams() {

        return this.parameters;

    }

    /*

     * (non-Javadoc)

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

     */

    public void execute(SimpleTaskStatus taskStatus) {

        FeatureStore outputFeatureStore = parameters.getOutputFeatoreStore();

        FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        FeatureAttributeDescriptor idRouteField = parameters.getIdRouteField();

        LrsCoordinatesPriority coordinatePriority = parameters.getCoordinatePriority();

        LrsSourceOfMeasures sourceOfMeasures = parameters.getSourceOfMeasures();

        FeatureAttributeDescriptor fromMeasureField = parameters.getFromMeasureField();

        FeatureAttributeDescriptor toMeasureField = parameters.getToMeasureField();

        double measureFactor = parameters.getMeasureFactor();

        double measureOffset = parameters.getMeasureOffset();

        boolean ignoreSpatialGaps = parameters.ignoreSpatialGaps();

        logger.info(parameters.toString());

        taskStatus.setTitle(parameters.getName());

        taskStatus.message("Grouping features");

        taskStatus.setRangeOfValues(0, 1000-1);

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

            logger.info(new StringBuilder().append(i).toString());

            taskStatus.setCurValue(i);

//            if (i == 50000) {

//                logger.info(new StringBuilder().append(i / 0).toString());

//            }

        }

        taskStatus.terminate();

//        FeatureSelection selection;

//        try {

//            outputFeatureStore.edit(FeatureStore.MODE_FULLEDIT);

//            selection = sourceFeatureStore.getFeatureSelection();

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

//                selection = sourceFeatureStore.createFeatureSelection();

//                selection.selectAll();

//            }

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

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

//

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

//

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

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

//            int i=0;

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

//                taskStatus.setCurValue(i++);

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

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

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

//

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

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

//                route = calibrateRoute(route);

//                newFeature.setDefaultGeometry(route);

//                outputFeatureStore.update(newFeature);

//            }

//            outputFeatureStore.finishEditing();

//            taskStatus.terminate();

//

//        } catch (DataException e) {

//            // TODO Auto-generated catch block

//            e.printStackTrace();

//        } catch (BaseException e) {

//            // TODO Auto-generated catch block

//            e.printStackTrace();

//        }

    }

    /**

     * @param route

     * @return

     */

    private Geometry calibrateRoute(Geometry route) {

        // TODO Auto-generated method stub

        return route;

    }

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

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

        selection.accept(new Visitor() {

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

                Feature feature = (Feature) obj;

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

                FeatureReference reference = feature.getReference();

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

                if (references == null) {

                    references = new ArrayList<FeatureReference>();

                }

                references.add(reference);

                refs.put(id, references);

            }

        });

        return refs;

    }

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

        Envelope envelope = getEnvelope(references);

        Point p = getOriginPointAccordingPriorityCoordinates(envelope, coordinatePriority);

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

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

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

        double m = 0;

        Point previousVertex = null;

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

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

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

            Feature feature = featureReference.getFeature();

            Geometry geometry = feature.getDefaultGeometry();

            if (geometry instanceof Line) {

                Line line = (Line) geometry;

                Point firstVertex = line.getVertex(0);

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

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

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

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

                double lineLength = getLineLength(line);

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

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

                    switch (sourceOfMeasures) {

                    case ONE_FIELD:

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

                        break;

                    case TWO_FIELDS:

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

                        break;

                    case LENGTH:

                    default:

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

                        break;

                    }

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

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

                    mvertex.setCoordinateAt(2, m);

                    tramo.addVertex(mvertex);

                    previousVertex = vertex;

                    p = vertex;

                }

                route.addPrimitive(tramo);

            } else if (geometry instanceof MultiLine) {

                MultiLine multiLine = (MultiLine)geometry;

                double multiLineLength = getMultiLineLength(multiLine);

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

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

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

                    Point firstVertex = line.getVertex(0);

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

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

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

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

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

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

                        switch (sourceOfMeasures) {

                        case ONE_FIELD:

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

                            break;

                        case TWO_FIELDS:

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

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

                            break;

                        case LENGTH:

                        default:

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

                            break;

                        }

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

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

                        mvertex.setCoordinateAt(2, m);

                        tramo.addVertex(mvertex);

                        previousVertex = vertex;

                        p = vertex;

                    }

                    route.addPrimitive(tramo);

                }

            }

        }

        return route;

    }

    /**

     * @param multiLine

     * @param previousVertex

     * @param coordinatePriority2

     * @return

     * @throws CreateGeometryException

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

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

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

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

        Point p = null;

        if(previousVertex!=null){

            previousVertex.cloneGeometry();

        } else {

            Envelope envelope = multiLine.getEnvelope();

            p = getOriginPointAccordingPriorityCoordinates(envelope, coordinatePriority);

        }

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

        Integer nearestPrimitive = null;

        double nearestDistance = Double.POSITIVE_INFINITY;

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

        boolean changed = true;

        while (changed) {

            changed = false;

            nearestDistance = Double.POSITIVE_INFINITY;

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

                if(!addedPrimitives.contains(i)){

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

                    Point firstVertex = line.getVertex(0);

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

                    double distanceFirstVertex = p.distance(firstVertex);

                    double distanceLastVertex = p.distance(lastVertex);

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

                    if (distance < nearestDistance) {

                        if(distanceFirstVertex<distanceLastVertex){

                            newPoint = lastVertex;

                        } else {

                        }

                        nearestPrimitive = i;

                        nearestDistance = distance;

                        changed = true;

                    }

                }

            }

            if (changed) {

                addedPrimitives.add(nearestPrimitive);

                p = (Point) newPoint.cloneGeometry();

            }

        }

        p = (Point) previousVertex.cloneGeometry();

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

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

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

            Line auxLine;

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

                auxLine = (Line) line.cloneGeometry();

            } else {

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

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

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

                }

            }

            orderedMultiLine.addPrimitive(auxLine);

        }

        return orderedMultiLine;

    }

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

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        Point p;

        //FIXME: OJO con el significado de coordinatePriority

        switch (coordinatePriority) {

        case DOWN_LEFT:

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

            break;

        case UP_RIGHT:

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

            break;

        case DOWN_RIGHT:

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

            break;

        case UP_LEFT:

        default:

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

            break;

        }

        return p;

    }

    /**

     * @param line

     * @return lenght

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    private double getLineLength(Line line) throws GeometryOperationNotSupportedException, GeometryOperationException {

        double lenght = 0;

        Point previousVertex = null;

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

            Point vertex = line.getVertex(i);

            if(previousVertex!=null){

                lenght+=previousVertex.distance(vertex);

            }

            previousVertex = vertex;

        }

        return lenght;

    }

    /**

     * @param multiLine

     * @return lenght

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

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

        double lenght = 0;

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

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

            Point previousVertex = null;

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

                Point vertex = line.getVertex(i);

                if(previousVertex!=null){

                    lenght+=previousVertex.distance(vertex);

                }

                previousVertex = vertex;

            }

        }

        return lenght;

    }

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

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

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

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

            }

        } else {

            if(previousVertex!=null){

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

            }

        }

        return m;

    }

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

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

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

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

            }

        } else {

            if(previousVertex!=null){

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

            }

        }

        return m;

    }

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

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

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

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

            }

        } else {

            if(previousVertex!=null){

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

            }

        }

        return m;

    }

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

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (i == 0) {

            m = from;

        } else {

            if(previousVertex!=null){

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

            }

        }

        return m;

    }

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

        Point vertex = null;

        if(ascendantOrder){

            vertex = line.getVertex(i);

        } else {

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

        }

        return vertex;

    }

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

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        double distanceFirstVertex = p.distance(firstVertex);

        double distanceLastVertex = p.distance(lastVertex);

        boolean ascendantOrder = (distanceFirstVertex<=distanceLastVertex);

        return ascendantOrder;

    }

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

        throws CreateEnvelopeException, DataException, CreateGeometryException, GeometryOperationNotSupportedException,

        GeometryOperationException {

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

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

        FeatureReference nearestFeatureReference = null;

        double nearestDistance = Double.POSITIVE_INFINITY;

        boolean changed = true;

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

        while (changed) {

            changed = false;

            nearestDistance = Double.POSITIVE_INFINITY;

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

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

                if (!orderedReferences.contains(featureReference)) {

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

                    if (geometry instanceof Line) {

                        Line line = (Line) geometry;

                        Point firstVertex = line.getVertex(0);

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

                        double distanceFirstVertex = p.distance(firstVertex);

                        double distanceLastVertex = p.distance(lastVertex);

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

                        if (distance < nearestDistance) {

                            if(distanceFirstVertex<distanceLastVertex){

                                newPoint = lastVertex;

                            }

                            nearestFeatureReference = featureReference;

                            nearestDistance = distance;

                            changed = true;

                        }

                    } else if (geometry instanceof MultiLine) {

                        MultiLine multiLine = (MultiLine) geometry;

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

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

                            Point firstVertex = line.getVertex(0);

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

                            double distanceFirstVertex = p.distance(firstVertex);

                            double distanceLastVertex = p.distance(lastVertex);

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

                            if (distance < nearestDistance) {

                                if(distanceFirstVertex<distanceLastVertex){

                                    newPoint = lastVertex;

                                }

                                nearestFeatureReference = featureReference;

                                nearestDistance = distance;

                                changed = true;

                                break;

                            }

                        }

                    }

                }

            }

            if (changed) {

                orderedReferences.add(nearestFeatureReference);

                p = (Point) newPoint.cloneGeometry();

            }

        }

        return orderedReferences;

    }

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

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

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

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

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

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

            envelope.add(geometry.getEnvelope());

        }

        return envelope;

    }

    /* (non-Javadoc)

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

     */

    public void setParams(LrsAlgorithmParams params) throws IllegalArgumentException {

        if(!(params instanceof LrsCreateRouteAlgorithmParams)){

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

        }

        // TODO Auto-generated method stub

    }

}