org.osmtools.ra.traverse.TraverseService.java Source code

Introduction

Here is the source code for org.osmtools.ra.traverse.TraverseService.java

Source

/**
 * This file is part of Relation Analyzer for OSM.
 * Copyright (c) 2001 by Adrian Stabiszewski, as@grundid.de
 *
 * Relation Analyzer is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Relation Analyzer 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Relation Analyzer.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.osmtools.ra.traverse;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.osmtools.ra.data.Node;
import org.osmtools.ra.dijkstra.Dijkstra;
import org.osmtools.ra.dijkstra.Vertex;
import org.osmtools.ra.graph.Graph;
import org.osmtools.ra.graph.IntersectionNode;
import org.osmtools.ra.segment.ConnectableSegment;
import org.springframework.stereotype.Service;

@Service
public class TraverseService {

    public List<Node> traverse(IntersectionNode startNode, IntersectionNode endNode) {
        SingleRouteTraverser traverser = new SingleRouteTraverser(startNode, endNode);
        return traverser.getPath();
    }

    public List<Node> traverse(Graph graph, IntersectionNode startNode, IntersectionNode endNode) {

        Dijkstra dijkstraAlgorithm = new Dijkstra(graph.getEdges());
        dijkstraAlgorithm.execute(startNode);
        List<Vertex> path = dijkstraAlgorithm.getPath(endNode);

        List<Node> result = new ArrayList<Node>();
        for (Vertex vertex : path)
            result.add(vertex.getNode());

        return result;
    }

    public List<Node> fillInNodes(List<Node> path, Collection<ConnectableSegment> segments) {

        if (path.isEmpty())
            return path;

        List<ConnectableSegment> modifyableSegments = new ArrayList<ConnectableSegment>(segments);
        List<Node> result = new ArrayList<Node>();

        Node startNode = path.get(0);
        result.add(startNode);
        for (int x = 1; x < path.size(); x++) {
            Node currentNode = path.get(x);
            fillInNodesBetweenNodes(modifyableSegments, result, startNode, currentNode);
            startNode = currentNode;
        }

        return result;

    }

    public static void fillInNodesBetweenNodes(List<ConnectableSegment> modifyableSegments, List<Node> resultNodes,
            Node startNode, Node currentNode) {
        for (Iterator<ConnectableSegment> it = modifyableSegments.iterator(); it.hasNext();) {
            ConnectableSegment connectableSegment = it.next();

            if (connectableSegment.containsNodes(startNode, currentNode)) {
                int prevSize = resultNodes.size();
                connectableSegment.appendNodesBetween(resultNodes, startNode, currentNode);
                // If the segment list is only 2 elements we must make sure 
                // that we not reuse the same segment again
                // Scenario: A => B => A
                if (modifyableSegments.size() <= 2) {
                    it.remove();
                }
                if (prevSize < resultNodes.size())
                    break;
            }
        }
    }
}