/// <summary> /// This method returns a double representing the length of time (in seconds) that it would /// take to get to from a PseudoNode to a Node along the same Path. If the given Node is /// not on the same Path, this returns Double.MAX_VALUE as this method contains no support /// for routing. /// </summary> /// <param name="node"></param> /// <param name="pseudoNode"></param> /// <returns></returns> public double GetTimeToNodeFrom(Node node, PseudoNode pseudoNode) { if (pseudoNode.GetPath() == this) { return(GetTimeToNodeFrom(node, pseudoNode.GetDistanceAlongPath())); } else { Debug.WriteLine("The PseudoNode does not lie on this Path."); return(Double.MaxValue); } }
/// <summary> /// This sets the directions of travel for each of the Paths in the path_route array. The result is stored /// in the path_directions array. /// </summary> void DetermineDirections() { // Initialise the size of the new Path directions to be the same as the size as the // path_route path_directions = new List <Direction>(path_route.Count); // If the route only contains one path if (path_route.Count == 1) { if (source_node.GetDistanceAlongPath() < end_node.GetDistanceAlongPath()) { path_directions.Add(Direction.FORWARDS); } else { path_directions.Add(Direction.BACKWARDS); } // Do not allow processing of the rest of this function return; } // Loop through each Path (except the last) and find the correct direction for (int i = 0; i < path_route.Count - 1; i++) { // Get nodes that exist on the current Path Node [] current_nodes = path_route[i].GetNodes(); // Get nodes that exist on the next Path Node [] next_nodes = path_route[i + 1].GetNodes(); if (current_nodes[0] == next_nodes[0] || current_nodes[0] == next_nodes[1]) { path_directions.Add(Direction.BACKWARDS); } else { path_directions.Add(Direction.FORWARDS); } } // Find the direction of the last Path Node [] last_path_nodes = path_route[path_route.Count - 1].GetNodes(); Node [] penultimate_path_node = path_route[path_route.Count - 2].GetNodes(); if (last_path_nodes[0] == penultimate_path_node[0] || last_path_nodes[0] == penultimate_path_node[1]) { path_directions.Add(Direction.FORWARDS); } else { path_directions.Add(Direction.BACKWARDS); } }
/// <summary> /// This method returns a double that represents the length of time (in seconds) that it /// would take to get from one PseudoNode on the Path to another on the Path. If one of /// the nodes is not on this Path, this method will return Double.MaxValue. /// </summary> /// <param name="destination_node"></param> /// <param name="source_node"></param> /// <returns></returns> public double GetTimeToPseudoNodeFrom(PseudoNode destination_node, PseudoNode source_node) { // Check both PseudoNodes are on the Path if (destination_node.GetPath() != this || source_node.GetPath() != this) { return(Double.MaxValue); } // Calculate length of time double destination_distance = destination_node.GetDistanceAlongPath(); double source_distance = source_node.GetDistanceAlongPath(); double time = (destination_distance - source_distance) / speed_limit; time = (time > 0) ? time : -time; return(time); }
/// <summary> /// Sets up a PseudoNode at the same point as the given PseudoNode. /// </summary> /// <param name="node"></param> public PseudoNode(PseudoNode node) { path = node.GetPath(); distance_along_path = node.GetDistanceAlongPath(); }
/// <summary> /// Returns a double representing the distance along the path from the first node /// in the path array to the second (note that it's not in the direction of travel). /// </summary> /// <returns></returns> public double GetDistanceAlongPath() { return(position.GetDistanceAlongPath()); }