コード例 #1
0
        private void Draw_Click(object sender, EventArgs e)
        {
            if (Map.Text == "")
            {
                MessageBox.Show("Select Map First !", "", MessageBoxButtons.OK, MessageBoxIcon.Hand);
            }
            else if (Qery_text.text == "" || Convert.ToInt32(Qery_text.text) > queriesNo)
            {
                MessageBox.Show("Invalid Query Number !", "", MessageBoxButtons.OK, MessageBoxIcon.Hand);
            }
            else
            {
                Short_Path.Enabled = true;
                //Graph.Map_file = Map.SelectedItem.ToString();
                Stopwatch ConstructionTime = Stopwatch.StartNew();
                graph = new Graph(Map.SelectedItem.ToString());
                ConstructionTime.Stop();
                GraphConstructionTime = (int)ConstructionTime.ElapsedMilliseconds;
                // G.add_Intersection();
                //G.add_roads();
                scl              = 0.079F;
                roadwide         = 3;
                intersectionwide = 1;
                if (Map.SelectedIndex == 5)
                {
                    queries = new queries("OLQueries");
                }
                else if (Map.SelectedIndex == 6)
                {
                    queries = new queries("SFQueries");
                }
                else
                {
                    queries          = new queries("queries" + (Map.SelectedIndex + 1).ToString());
                    roadwide         = 20;
                    intersectionwide = 10;
                    scl = 400;
                    if (Map.SelectedIndex > 1)
                    {
                        scl = 20;
                    }
                }
                panel2.Visible = false;
                Graphics g = draw_panal.CreateGraphics();

                g.Clear(draw_panal.BackColor);
                g.ScaleTransform(zoom, zoom);
                TestCaseNo = Convert.ToInt32(Qery_text.text) - 1;
                drawMap(graph.Nodes_edgesFordrawing, graph.intersections, draw_panal, scl);
                drawSourceDestination(queries, TestCaseNo, draw_panal, scl);
            }
        }
コード例 #2
0
        void drawSourceDestination(queries Q, int index, Panel c, float scl)
        {
            Graphics g  = c.CreateGraphics();
            float    xS = (float)Q.Start_X_Coordinate[index] * scl;
            float    yS = (float)Q.Start_Y_Coordinate[index] * scl;

            g.DrawRectangle(new Pen(Color.Red), xS, yS, 15, 15);
            Font font = new Font("Courier New", 12f, FontStyle.Bold);

            g.DrawString("Source", font, Brushes.White, xS, yS);

            float xD = (float)Q.Destination_X_Coordinate[index] * scl;
            float yD = (float)Q.Destination_Y_Coordinate[index] * scl;

            g.DrawRectangle(new Pen(Color.Red), xD, yD, 15, 15);
            g.DrawString("Destination", font, Brushes.White, xD, yD);
        }
コード例 #3
0
        public int dijkstra_Two_Way(Graph G, queries Q, int index)
        {
            double res            = 1e17;
            int    real_end_index = -1;

            bool[] visted = new bool[G.Number_Of_Intersection + 2];
            for (int i = 0; i < G.Number_Of_Intersection + 2; i++)
            {
                visted[i] = false;
            }
            Priority_Queue PQ     = new Priority_Queue(time);
            Priority_Queue PQ_End = new Priority_Queue(time_End);

            PQ.buildHeap();
            PQ_End.buildHeap();
            while (true)
            {
                int u = PQ.extractMin();
                int num_of_neighbours_of_u = G.Nodes_edges[u].Count;  // for speed
                for (int j = 0; j < num_of_neighbours_of_u; j++)
                {
                    // retrive index of adjecent (المجاورة) vertex of minimum node (u)
                    int Current_index = G.Nodes_edges[u][j].Item1;
                    // time from u to one of the  neighbours
                    double time_to_neighbour = G.Nodes_edges[u][j].Item2 / G.Nodes_edges[u][j].Item3;

                    if (time[u] + time_to_neighbour < time[Current_index])
                    {
                        time[Current_index] = time[u] + time_to_neighbour;

                        PQ.heap_update_key(Current_index, time[u] + time_to_neighbour);

                        distance[Current_index] = distance[u] + G.Nodes_edges[u][j].Item2;
                        parent[Current_index]   = u;
                    }
                }
                //checking if this node u may be on the shortest path between source and destination
                if (time[u] + time_End[u] < res)
                {
                    res            = time[u] + time_End[u];
                    real_end_index = u;
                }
                if (visted[u] == true)
                {
                    break;
                }
                visted[u] = true;

                int u_End = PQ_End.extractMin();

                int num_of_neighbours_of_u_End = G.Nodes_edges[u_End].Count;  // for speed
                for (int j = 0; j < num_of_neighbours_of_u_End; j++)
                {
                    // retrive index of adjecent (المجاورة) vertex of minimum node (u)
                    int Current_index = G.Nodes_edges[u_End][j].Item1;
                    // time from u to one of the  neighbours
                    double time_to_neighbour = G.Nodes_edges[u_End][j].Item2 / G.Nodes_edges[u_End][j].Item3;

                    if (time_End[u_End] + time_to_neighbour < time_End[Current_index])
                    {
                        time_End[Current_index] = time_End[u_End] + time_to_neighbour;

                        PQ_End.heap_update_key(Current_index, time_End[u_End] + time_to_neighbour);

                        distance_End[Current_index] = distance_End[u_End] + G.Nodes_edges[u_End][j].Item2;
                        parent_End[Current_index]   = u_End;
                    }
                }
                //checking if this node u_End may be on the shortest path between source and destination
                if (time[u_End] + time_End[u_End] < res)
                {
                    res            = time[u_End] + time_End[u_End];
                    real_end_index = u_End;
                }
                if (visted[u_End] == true)
                {
                    break;
                }
                visted[u_End] = true;
            }
            return(real_end_index);
        }
コード例 #4
0
        public void Calculate_ShortestPath_AllQueries(Graph G, queries Q) //calc and construct the shortest path of each query
        {
            for (int i = 0; i < Q.Number_Of_Queries; ++i)
            {
                Stopwatch Sw = Stopwatch.StartNew();

                //initializing the time  , distance , and parent arrays for this query
                int number_of_intersection_plus_2 = G.Number_Of_Intersection + 2; // for speed
                time                 = new double[number_of_intersection_plus_2];
                time_End             = new double[number_of_intersection_plus_2];
                distance             = new double[number_of_intersection_plus_2];
                distance_End         = new double[number_of_intersection_plus_2];
                parent               = new int[number_of_intersection_plus_2];
                parent_End           = new int[number_of_intersection_plus_2];
                shortest_path_nodes1 = new List <int>();
                shortest_path_nodes2 = new List <int>();
                shortest_path_nodes  = new List <int>();
                //initializing the Available_Starting_Intersections and vailable_Ending_Intersections  lists for this query
                Available_Starting_Intersections = new List <int>();
                Available_Ending_Intersections   = new List <int>();
                // initial times
                for (int j = 0; j < number_of_intersection_plus_2; ++j)
                {
                    time[j] = 1e15; time_End[j] = 1e15;
                }

                int number_of_intersection = G.Number_Of_Intersection; // for speed ;
                for (int j = 0; j < number_of_intersection; ++j)
                {
                    //Console.WriteLine(Q.Number_Of_Queries);

                    double distance_toSource = Math.Sqrt(Math.Pow(Q.Start_X_Coordinate[i] - G.intersections[j].Item1, 2) + Math.Pow(Q.Start_Y_Coordinate[i] - G.intersections[j].Item2, 2));

                    //checking for every intersection on the map if it can be included in (Available_Starting_Intersections or Available_Ending_Intersections) of this query
                    if (distance_toSource * 1000 <= Q.R[i])
                    {
                        Available_Starting_Intersections.Add(j);
                        if (time[j] > distance_toSource / 5)
                        {
                            // time to arrive from (X,Y) cordinates to source node
                            time[j] = distance_toSource / 5;

                            //distance from (X,Y) cordinates to source
                            distance[j] = distance_toSource;
                            // parent of source equal to (X,Y) cordinates
                            parent[j] = G.Number_Of_Intersection;
                        }
                        //find the shortest path for this starting node and changing the values of time array,distance array and parent array;
                        //dijkstra(G,j,Q.Start_X_Coordinate[i],Q.Start_Y_Coordinate[i],Q.Destination_X_Coordinate[i],Q.Destination_Y_Coordinate[i] , Q.R[i]);
                    }

                    double distance_from_distination_To_j = (Math.Sqrt(Math.Pow(G.intersections[j].Item1 - Q.Destination_X_Coordinate[i], 2) + Math.Pow(G.intersections[j].Item2 - Q.Destination_Y_Coordinate[i], 2)));
                    //Console.WriteLine(u+" "+distance_from_u_to_distination);
                    if (distance_from_distination_To_j * 1000 <= Q.R[i])
                    {
                        Available_Ending_Intersections.Add(j);
                        // checke if time of distination more than new time by using new u node >> update
                        if (time_End[j] > (distance_from_distination_To_j / 5))
                        {
                            //Console.WriteLine(1);
                            // time to arrive from (X,Y) cordinates to source node
                            time_End[j] = (distance_from_distination_To_j / 5);
                            //distance from (X,Y) cordinates to source
                            distance_End[j] = distance_from_distination_To_j;
                            // parent of source equal to (X,Y) cordinates
                            parent_End[j] = G.Number_Of_Intersection + 1;
                        }
                    }
                }
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                //    dijkstra(G, Q.Start_X_Coordinate[i], Q.Start_Y_Coordinate[i], Q.Destination_X_Coordinate[i], Q.Destination_Y_Coordinate[i], Q.R[i]);
                int end_point = dijkstra_Two_Way(G, Q, i);
                construct_two_way_dijkstra_path(G, end_point);
                totalTime            = (double)Math.Round((decimal)((time[end_point] + time_End[end_point]) * 60), 2);
                totalDistance        = (double)Math.Round((decimal)(distance[end_point] + distance_End[end_point]), 2);
                totalWalkingDistance = (double)Math.Round((decimal)(distance[shortest_path_nodes[1]] + distance_End[shortest_path_nodes[shortest_path_nodes.Count - 2]]), 2);
                totalVehD            = (double)Math.Round((decimal)(totalDistance - totalWalkingDistance), 2);
                Sw.Stop();


                Console.WriteLine("Time = " + (totalTime));
                // totalDistance = Math.Round(totalDistance, 2);
                Console.WriteLine("Distance = " + totalDistance);
                Console.WriteLine("Walking Distance = " + totalWalkingDistance + " km");
                Console.WriteLine("Vehicle Distance = " + totalVehD + " km");

                // Console.WriteLine("Shortest path Contains Intersection ");

                /*for (int w = 1; w <shortest_path_nodes.Count-1; w++)
                 * {
                 *  Console.Write(shortest_path_nodes[w] + "  " );
                 * }
                 * Console.WriteLine();*/

                Console.WriteLine("Excution Time = " + Sw.ElapsedMilliseconds);

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            }
        }
コード例 #5
0
        void check(string mapfile)
        {
            if (mapfile == "OLMap")
            {
                queries = new queries("OLQueries");
                ch      = new CheckCorrectness("OLOutput", queries.Number_Of_Queries);
            }
            else if (mapfile == "SFMap")
            {
                queries = new queries("SFQueries");
                ch      = new CheckCorrectness("SFOutput", queries.Number_Of_Queries);
            }
            else
            {
                if (mapfile == "map1")
                {
                    queries = new queries("queries1");
                    ch      = new CheckCorrectness("output1", queries.Number_Of_Queries);
                }
                else if (mapfile == "map2")
                {
                    queries = new queries("queries2");
                    ch      = new CheckCorrectness("output2", queries.Number_Of_Queries);
                }
                else if (mapfile == "map3")
                {
                    queries = new queries("queries3");
                    ch      = new CheckCorrectness("output3", queries.Number_Of_Queries);
                }
                else if (mapfile == "map4")
                {
                    queries = new queries("queries4");
                    ch      = new CheckCorrectness("output4", queries.Number_Of_Queries);
                }
                else if (mapfile == "map5")
                {
                    queries = new queries("queries5");
                    ch      = new CheckCorrectness("output5", queries.Number_Of_Queries);
                }
            }
            graph    = new Graph(mapfile);
            shortest = new ShortestPathAlgorithm();
            string m;
            bool   accepted = true;

            for (int i = 0; i < queries.Number_Of_Queries; i++)
            {
                Stopwatch s = Stopwatch.StartNew();
                shortest.Calculate_ShortestPath(graph, queries, i);
                s.Stop();
                richTextBox1.AppendText("Total Time = " + shortest.totalTime.ToString() + " mins\n");
                richTextBox1.AppendText("Total Distance = " + shortest.totalDistance.ToString() + " Km\n");
                richTextBox1.AppendText("Total Walking Distance = " + shortest.totalWalkingDistance.ToString() + " Km\n");
                richTextBox1.AppendText("Total Vehcile Distance = " + shortest.totalVehD.ToString() + " Km\n");
                richTextBox1.AppendText("Execution Time = " + (int)s.ElapsedMilliseconds + " ms\n");
                m = ch.checkoutput(shortest.totalTime, shortest.totalDistance, shortest.totalWalkingDistance, shortest.totalVehD, (int)s.ElapsedMilliseconds, i);
                richTextBox1.AppendText(m + "\n");
                richTextBox1.AppendText("\n");
                if (m != "Case # " + (i + 1).ToString() + " Succeeded")
                {
                    accepted = false;
                    break;
                }
                richTextBox1.ScrollToCaret();
            }
            if (accepted)
            {
                richTextBox1.AppendText("All Cases Succeeded\n");
            }
        }