示例#1
0
        /// <summary>
        /// Recalculates the entire queue.
        /// </summary>
        public void RecalculateQueue()
        {
            OsmSharp.Logging.Log.TraceEvent("CHPreProcessor", TraceEventType.Information,
                                            "Recalculating queue...");
            uint total   = _target.VertexCount;
            uint current = 1;

            double latestProgress = 0;

            _queue.Clear();
            for (uint currentVertex = 1; currentVertex <= total; currentVertex++)
            {
                if (!this.IsContracted(currentVertex))
                {
                    var priority = _calculator.Calculate(currentVertex);

                    _queue.Push(currentVertex, priority);
                    _lowestPriorities[currentVertex] = priority;

                    float progress = (float)System.Math.Round((((double)current / (double)total) * 100));
                    if (progress != latestProgress)
                    {
                        //OsmSharp.Logging.Log.TraceEvent("CHPreProcessor", TraceEventType.Information,
                        //    "Building CH Queue... {0}%", progress);
                        latestProgress = progress;
                    }
                    current++;
                }
            }
        }
示例#2
0
        /// <summary>
        /// Starts pre-processing all nodes
        /// </summary>
        /// <remarks>Returns the last-contracted vertex.</remarks>
        public void Start()
        {
            _misses_queue = new Queue <bool>();
            _misses       = 0;

            uint total   = _target.VertexCount;
            uint current = 1;

            double latestProgress = 0;

            for (uint current_vertex = 1; current_vertex <= total; current_vertex++)
            {
                float priority = _calculator.Calculate(current_vertex);

                _queue.Enqueue(current_vertex, priority);

                float progress = (float)System.Math.Round((((double)current / (double)total) * 100));
                if (progress != latestProgress)
                {
                    OsmSharp.Logging.Log.TraceEvent("CHPreProcessor", TraceEventType.Information,
                                                    "Building CH Queue... {0}%", progress);
                    latestProgress = progress;
                }
                current++;
            }

            // loop over the priority queue until it's empty.
            current = 1;
            uint?vertex = this.SelectNext();

            latestProgress = 0;
            while (vertex != null)
            {
                // contract the nodes.
                this.Contract(vertex.Value);

                // select the next vertex.
                vertex = this.SelectNext();

                double realProgress = (double)current / (double)total;
                double progress     = (float)System.Math.Round(realProgress * 100);
                if (progress != latestProgress)
                {
                    OsmSharp.Logging.Log.TraceEvent("CHPreProcessor", TraceEventType.Information,
                                                    "Pre-processing... {0}%", progress);
                    latestProgress = progress;
                }
                if (realProgress > _preProcessingPercentage)
                { // stop at a certain percentage.
                    break;
                }
                current++;
            }

            OsmSharp.Logging.Log.TraceEvent("CHPreProcessor", TraceEventType.Information,
                                            "Pre-processing finsihed!");
        }
示例#3
0
        /// <summary>
        /// Starts pre-processing all nodes
        /// </summary>
        /// <remarks>Returns the last-contracted vertex.</remarks>
        public void Start()
        {
            _misses_queue = new Queue <bool>();
            _misses       = 0;

            uint total   = _target.VertexCount;
            uint current = 1;

            for (uint current_vertex = 1; current_vertex < total; current_vertex++)
            {
                float priority = _calculator.Calculate(current_vertex);
                lock (_queue)
                {
                    _queue.Enqueue(current_vertex, priority);

                    if (current % 1000 == 0)
                    {
                        OsmSharp.Logging.Log.TraceEvent("CHPreProcessor", TraceEventType.Information,
                                                        "Building CH Queue...");
                    }
                    current++;
                }
            }

            // loop over the priority queue until it's empty.
            current = 1;
            uint?vertex            = this.SelectNext();
            uint?lastestContracted = 0;

            while (vertex != null)
            {
                // contract the nodes.
                this.Contract(vertex.Value);
                lastestContracted = vertex;

                // select the next vertex.
                vertex = this.SelectNext();

                if (current % 1000 == 0)
                {
                    OsmSharp.Logging.Log.TraceEvent("CHPreProcessor", TraceEventType.Information, "Pre-processing... {0}%", (int)(((float)current / (float)total) * 100));
                }
                current++;
            }
        }
示例#4
0
        public void TestCHEdgeDifferenceContractions()
        {
            IOsmRoutingInterpreter interpreter = new OsmSharp.Routing.Osm.Interpreter.OsmRoutingInterpreter();
            CHPreProcessor         processor   = this.BuildCHPreProcessor(interpreter);
            //processor.InitializeQueue();
            INodeWeightCalculator edgeDifference = processor.NodeWeightCalculator;

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(3, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(-1, edgeDifference.Calculate(20));
            Assert.AreEqual(0, edgeDifference.Calculate(21));
            Assert.AreEqual(0, edgeDifference.Calculate(22));
            Assert.AreEqual(-1, edgeDifference.Calculate(23));

            // contract 20.
            processor.Contract(20);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(3, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(-1, edgeDifference.Calculate(21));
            Assert.AreEqual(0, edgeDifference.Calculate(22));
            Assert.AreEqual(-1, edgeDifference.Calculate(23));

            // contract 21.
            processor.Contract(21);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(0, edgeDifference.Calculate(22));
            Assert.AreEqual(-1, edgeDifference.Calculate(23));

            // contract 23.
            processor.Contract(23);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(-1, edgeDifference.Calculate(22));

            // contract 22.
            processor.Contract(22);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            // contract 16.
            processor.Contract(16);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            // contract 17.
            processor.Contract(17);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(3);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(-2, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(4);

            Assert.AreEqual(0, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(3, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(1);

            Assert.AreEqual(1, edgeDifference.Calculate(2));  // witness paths from 11<->5.
            Assert.AreEqual(-2, edgeDifference.Calculate(5)); // witness paths from 11<->6.
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(5);

            Assert.AreEqual(1, edgeDifference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(-2, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(6);

            Assert.AreEqual(0, edgeDifference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(-1, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(7);

            Assert.AreEqual(0, edgeDifference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(2);

            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(-2, edgeDifference.Calculate(11)); // witness paths from 18<->10.
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(11);

            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(1, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-2, edgeDifference.Calculate(18)); // witness paths from 10<->8.
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(18);

            Assert.AreEqual(0, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(0, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(8);

            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(0, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(9);

            Assert.AreEqual(-2, edgeDifference.Calculate(10)); // witness paths from 19<->12.
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-2, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(10);

            Assert.AreEqual(-2, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-2, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(12);

            Assert.AreEqual(-1, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(13);

            Assert.AreEqual(-1, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(14);

            Assert.AreEqual(-1, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(15);

            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(19);
        }