Exemple #1
0
        /// <summary>
        /// Does dykstra calculation(s) with several options.
        /// </summary>
        /// <param name="graph"></param>
        /// <param name="interpreter"></param>
        /// <param name="vehicle"></param>
        /// <param name="sourceList"></param>
        /// <param name="targetList"></param>
        /// <param name="weight"></param>
        /// <param name="stopAtFirst"></param>
        /// <param name="returnAtWeight"></param>
        /// <param name="forward"></param>
        /// <returns></returns>
        private PathSegment <long>[] DoCalculation(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter, Vehicle vehicle,
                                                   PathSegmentVisitList sourceList, PathSegmentVisitList[] targetList, double weight,
                                                   bool stopAtFirst, bool returnAtWeight, bool forward)
        {
            // make copies of the target and source visitlist.
            PathSegmentVisitList source = sourceList.Clone() as PathSegmentVisitList;

            PathSegmentVisitList[] targets = new PathSegmentVisitList[targetList.Length];
            for (int targetIdx = 0; targetIdx < targetList.Length; targetIdx++)
            {
                targets[targetIdx] = targetList[targetIdx].Clone() as PathSegmentVisitList;
            }

            //  initialize the result data structures.
            var  segmentsAtWeight = new List <PathSegment <long> >();
            var  segmentsToTarget = new PathSegment <long> [targets.Length]; // the resulting target segments.
            long foundTargets     = 0;

            // intialize dykstra data structures.
            IPriorityQueue <PathSegment <long> > heap = new BinairyHeap <PathSegment <long> >();
            var chosenVertices = new HashSet <long>();
            var labels         = new Dictionary <long, IList <RoutingLabel> >();

            foreach (long vertex in source.GetVertices())
            {
                labels[vertex] = new List <RoutingLabel>();

                PathSegment <long> path = source.GetPathTo(vertex);
                heap.Push(path, (float)path.Weight);
            }

            // set the from node as the current node and put it in the correct data structures.
            // intialize the source's neighbours.
            PathSegment <long> current = heap.Pop();

            while (current != null &&
                   chosenVertices.Contains(current.VertexId))
            { // keep dequeuing.
                current = heap.Pop();
            }

            // test each target for the source.
            // test each source for any of the targets.
            var pathsFromSource = new Dictionary <long, PathSegment <long> >();

            foreach (long sourceVertex in source.GetVertices())
            {                                                                   // get the path to the vertex.
                PathSegment <long> sourcePath = source.GetPathTo(sourceVertex); // get the source path.
                sourcePath = sourcePath.From;
                while (sourcePath != null)
                { // add the path to the paths from source.
                    pathsFromSource[sourcePath.VertexId] = sourcePath;
                    sourcePath = sourcePath.From;
                }
            }
            // loop over all targets
            for (int idx = 0; idx < targets.Length; idx++)
            { // check for each target if there are paths to the source.
                foreach (long targetVertex in targets[idx].GetVertices())
                {
                    PathSegment <long> targetPath = targets[idx].GetPathTo(targetVertex); // get the target path.
                    targetPath = targetPath.From;
                    while (targetPath != null)
                    { // add the path to the paths from source.
                        PathSegment <long> pathFromSource;
                        if (pathsFromSource.TryGetValue(targetPath.VertexId, out pathFromSource))
                        { // a path is found.
                            // get the existing path if any.
                            PathSegment <long> existing = segmentsToTarget[idx];
                            if (existing == null)
                            { // a path did not exist yet!
                                segmentsToTarget[idx] = targetPath.Reverse().ConcatenateAfter(pathFromSource);
                                foundTargets++;
                            }
                            else if (existing.Weight > targetPath.Weight + pathFromSource.Weight)
                            { // a new path is found with a lower weight.
                                segmentsToTarget[idx] = targetPath.Reverse().ConcatenateAfter(pathFromSource);
                            }
                        }
                        targetPath = targetPath.From;
                    }
                }
            }
            if (foundTargets == targets.Length && targets.Length > 0)
            { // routing is finished!
                return(segmentsToTarget.ToArray());
            }

            if (stopAtFirst)
            {     // only one entry is needed.
                if (foundTargets > 0)
                { // targets found, return the shortest!
                    PathSegment <long> shortest = null;
                    foreach (PathSegment <long> foundTarget in segmentsToTarget)
                    {
                        if (shortest == null)
                        {
                            shortest = foundTarget;
                        }
                        else if (foundTarget != null &&
                                 shortest.Weight > foundTarget.Weight)
                        {
                            shortest = foundTarget;
                        }
                    }
                    segmentsToTarget    = new PathSegment <long> [1];
                    segmentsToTarget[0] = shortest;
                    return(segmentsToTarget);
                }
                else
                { // not targets found yet!
                    segmentsToTarget = new PathSegment <long> [1];
                }
            }

            // test for identical start/end point.
            for (int idx = 0; idx < targets.Length; idx++)
            {
                PathSegmentVisitList target = targets[idx];
                if (returnAtWeight)
                { // add all the reached vertices larger than weight to the results.
                    if (current.Weight > weight)
                    {
                        PathSegment <long> toPath = target.GetPathTo(current.VertexId);
                        toPath.Reverse();
                        toPath = toPath.ConcatenateAfter(current);
                        segmentsAtWeight.Add(toPath);
                    }
                }
                else if (target.Contains(current.VertexId))
                { // the current is a target!
                    PathSegment <long> toPath = target.GetPathTo(current.VertexId);
                    toPath = toPath.Reverse();
                    toPath = toPath.ConcatenateAfter(current);

                    if (stopAtFirst)
                    { // stop at the first occurance.
                        segmentsToTarget[0] = toPath;
                        return(segmentsToTarget);
                    }
                    else
                    { // normal one-to-many; add to the result.
                        // check if routing is finished.
                        if (segmentsToTarget[idx] == null)
                        { // make sure only the first route is set.
                            foundTargets++;
                            segmentsToTarget[idx] = toPath;
                            if (foundTargets == targets.Length)
                            { // routing is finished!
                                return(segmentsToTarget.ToArray());
                            }
                        }
                        else if (segmentsToTarget[idx].Weight > toPath.Weight)
                        { // check if the second, third or later is shorter.
                            segmentsToTarget[idx] = toPath;
                        }
                    }
                }
            }

            // start OsmSharp.Routing.
            KeyValuePair <uint, LiveEdge>[] arcs = graph.GetArcs(
                Convert.ToUInt32(current.VertexId));
            chosenVertices.Add(current.VertexId);

            // loop until target is found and the route is the shortest!
            while (true)
            {
                // get the current labels list (if needed).
                IList <RoutingLabel> currentLabels = null;
                if (interpreter.Constraints != null)
                { // there are constraints, get the labels.
                    currentLabels = labels[current.VertexId];
                    labels.Remove(current.VertexId);
                }

                float latitude, longitude;
                graph.GetVertex(Convert.ToUInt32(current.VertexId), out latitude, out longitude);
                var currentCoordinates = new GeoCoordinate(latitude, longitude);

                // update the visited nodes.
                foreach (KeyValuePair <uint, LiveEdge> neighbour in arcs)
                {
                    // check the tags against the interpreter.
                    TagsCollection tags = graph.TagsIndex.Get(neighbour.Value.Tags);
                    if (vehicle.CanTraverse(tags))
                    { // it's ok; the edge can be traversed by the given vehicle.
                        bool?oneWay = vehicle.IsOneWay(tags);
                        bool canBeTraversedOneWay = (!oneWay.HasValue || oneWay.Value == neighbour.Value.Forward);
                        if ((current.From == null ||
                             interpreter.CanBeTraversed(current.From.VertexId, current.VertexId, neighbour.Key)) && // test for turning restrictions.
                            canBeTraversedOneWay &&
                            !chosenVertices.Contains(neighbour.Key))
                        { // the neigbour is forward and is not settled yet!
                            // check the labels (if needed).
                            bool constraintsOk = true;
                            if (interpreter.Constraints != null)
                            { // check if the label is ok.
                                RoutingLabel neighbourLabel = interpreter.Constraints.GetLabelFor(
                                    graph.TagsIndex.Get(neighbour.Value.Tags));

                                // only test labels if there is a change.
                                if (currentLabels.Count == 0 || !neighbourLabel.Equals(currentLabels[currentLabels.Count - 1]))
                                { // labels are different, test them!
                                    constraintsOk = interpreter.Constraints.ForwardSequenceAllowed(currentLabels,
                                                                                                   neighbourLabel);

                                    if (constraintsOk)
                                    { // update the labels.
                                        var neighbourLabels = new List <RoutingLabel>(currentLabels);
                                        neighbourLabels.Add(neighbourLabel);

                                        labels[neighbour.Key] = neighbourLabels;
                                    }
                                }
                                else
                                { // set the same label(s).
                                    labels[neighbour.Key] = currentLabels;
                                }
                            }

                            if (constraintsOk)
                            { // all constraints are validated or there are none.
                                graph.GetVertex(Convert.ToUInt32(neighbour.Key), out latitude, out longitude);
                                var neighbourCoordinates = new GeoCoordinate(latitude, longitude);

                                // calculate the weight.
                                double weightToNeighbour = vehicle.Weight(tags, currentCoordinates, neighbourCoordinates);

                                // calculate neighbours weight.
                                double totalWeight = current.Weight + weightToNeighbour;

                                // update the visit list;
                                var neighbourRoute = new PathSegment <long>(neighbour.Key, totalWeight, current);
                                heap.Push(neighbourRoute, (float)neighbourRoute.Weight);
                            }
                        }
                    }
                }

                // while the visit list is not empty.
                current = null;
                if (heap.Count > 0)
                {
                    // choose the next vertex.
                    current = heap.Pop();
                    while (current != null &&
                           chosenVertices.Contains(current.VertexId))
                    { // keep dequeuing.
                        current = heap.Pop();
                    }
                    if (current != null)
                    {
                        chosenVertices.Add(current.VertexId);
                    }
                }
                while (current != null && current.Weight > weight)
                {
                    if (returnAtWeight)
                    { // add all the reached vertices larger than weight to the results.
                        segmentsAtWeight.Add(current);
                    }

                    // choose the next vertex.
                    current = heap.Pop();
                    while (current != null &&
                           chosenVertices.Contains(current.VertexId))
                    { // keep dequeuing.
                        current = heap.Pop();
                    }
                }

                if (current == null)
                { // route is not found, there are no vertices left
                    // or the search whent outside of the max bounds.
                    break;
                }

                // check target.
                for (int idx = 0; idx < targets.Length; idx++)
                {
                    PathSegmentVisitList target = targets[idx];
                    if (target.Contains(current.VertexId))
                    { // the current is a target!
                        PathSegment <long> toPath = target.GetPathTo(current.VertexId);
                        toPath = toPath.Reverse();
                        toPath = toPath.ConcatenateAfter(current);

                        if (stopAtFirst)
                        { // stop at the first occurance.
                            segmentsToTarget[0] = toPath;
                            return(segmentsToTarget);
                        }
                        else
                        { // normal one-to-many; add to the result.
                            // check if routing is finished.
                            if (segmentsToTarget[idx] == null)
                            { // make sure only the first route is set.
                                segmentsToTarget[idx] = toPath;
                            }
                            else if (segmentsToTarget[idx].Weight > toPath.Weight)
                            { // check if the second, third or later is shorter.
                                segmentsToTarget[idx] = toPath;
                            }

                            // remove this vertex from this target's paths.
                            target.Remove(current.VertexId);

                            // if this target is empty it's optimal route has been found.
                            if (target.Count == 0)
                            { // now the shortest route has been found for sure!
                                foundTargets++;
                                if (foundTargets == targets.Length)
                                { // routing is finished!
                                    return(segmentsToTarget.ToArray());
                                }
                            }
                        }
                    }
                }

                // get the neigbours of the current node.
                arcs = graph.GetArcs(Convert.ToUInt32(current.VertexId));
            }

            // return the result.
            if (!returnAtWeight)
            {
                return(segmentsToTarget.ToArray());
            }
            return(segmentsAtWeight.ToArray());
        }
 /// <summary>
 /// Returns true if the given sequence is allowed.
 /// </summary>
 /// <param name="sequence"></param>
 /// <param name="latest"></param>
 /// <returns></returns>
 public bool BackwardSequenceAllowed(IList <RoutingLabel> sequence, RoutingLabel latest)
 {
     return(Regex.IsMatch(sequence.CreateString(latest), "^L*R*L*$"));
 }
 /// <summary>
 /// Returns true if the given sequence is allowed.
 /// </summary>
 /// <param name="sequence"></param>
 /// <param name="latest"></param>
 /// <returns></returns>
 public bool ForwardSequenceAllowed(IList<RoutingLabel> sequence, RoutingLabel latest)
 {
     return Regex.IsMatch(sequence.CreateString(latest), "^L*R*L*$");
 }