/// <summary> /// Set the display's rndf /// </summary> /// <param name="rndf"></param> public void SetRndf(RndfNetwork rndf) { if (rndf != null) this.roadDisplay1.SetRndf(rndf); else RemoraOutput.WriteLine("Received Null Rndf"); }
public void MessageArrived(string channelName, object message) { if (channelName == "RndfNetworkChannel") { this.rndfNetwork = (Common.RndfNetwork.RndfNetwork)message; Console.WriteLine(" > Rndf Received"); } else if (channelName == "MdfChannel") { this.mdf = (Common.RndfNetwork.Mdf)message; Console.WriteLine(" > Mdf Received"); } else if (channelName == "PositionChannel") { this.vehicleState = (VehicleState) message; Console.WriteLine(" > Position Received: " + this.vehicleState.ToString()); } else if (channelName == "TestStringChannel") { Console.WriteLine("Received String On TestStringChannel: " + ((string)message)); } else { throw new ArgumentException("Unknown Channel", channelName); } }
/// <summary> /// Analyzes a lane to find the closest point to the coordinate passed in /// </summary> /// <param name="coordinate">coordinate to analyze the lane against</param> /// <param name="lane">lane to reference the coordinate to</param> /// <returns>vector consisting of relative and absolute rndf localization information</returns> public static LocationAnalysis ClosestPartitionOnLane(Coordinates coordinate, LaneID laneId, RndfNetwork rndfNetwork) { // get the lane Lane lane = rndfNetwork.Segments[laneId.WayID.SegmentID].Ways[laneId.WayID].Lanes[laneId]; // set the value to return LocationAnalysis closest = null; // values for comparing partitions double offsetMin = Double.MaxValue; // iterate over lanePartitions within the lane foreach (LanePartition lanePartition in lane.LanePartitions) { // if there are user partitions, operate over them if (lanePartition.UserPartitions != null && lanePartition.UserPartitions.Count > 1) { foreach (UserPartition userPartiton in lanePartition.UserPartitions) { throw new Exception("user partition relation to vehicle absolute coordinates not implemented yet"); } } // otherwise look at how close lane partition is else { // analyze the partition LocationAnalysis partitionAnalysis = AnalyzePartition(coordinate, (IWaypoint)lanePartition.InitialWaypoint, (IWaypoint)lanePartition.FinalWaypoint); // if this partition has less of an offset from the vehicle than the current best, set as current if (partitionAnalysis.Offset < offsetMin) { offsetMin = partitionAnalysis.Offset; closest = partitionAnalysis; // set partition of result closest.Partition = lanePartition; } // otherwise, if the vehicle is relatively close to this partition // and the closest Coordinates are not those of the initial final waypoitns of the lane // and this error is less than the current best offset else if (partitionAnalysis.Offset == 1234567 && (partitionAnalysis.RelativeRndfPosition != lane.LanePartitions[0].InitialWaypoint.Position) && (partitionAnalysis.RelativeRndfPosition != lane.LanePartitions[lane.LanePartitions.Count - 1].FinalWaypoint.Position) && (partitionAnalysis.Error < offsetMin)) { offsetMin = partitionAnalysis.Error; closest = partitionAnalysis; // set partition of result closest.Partition = lanePartition; } } } // return closest value found return closest; }
/// <summary> /// Generates speed limits for the rndf segments /// </summary> /// <param name="rndfNetwork"></param> private static List<SpeedInformation> generateSpeedLimits(RndfNetwork rndfNetwork) { List<SpeedInformation> speedLimits = new List<SpeedInformation>(); foreach(Segment segment in rndfNetwork.Segments.Values) { SpeedInformation speedLimit = new SpeedInformation(segment.SegmentID, 0, 8.8); speedLimits.Add(speedLimit); } return speedLimits; }
/// <summary> /// De-Serialize this byte-string and cast as a RndfNetwork object /// </summary> /// <param name="b"></param> /// <returns></returns> public RndfNetwork DeSerialize(byte[] b) { RndfNetwork s = new RndfNetwork(); try { MemoryStream str = new MemoryStream(b); BinaryFormatter bf = new BinaryFormatter(); s = (RndfNetwork)bf.Deserialize(str); str.Close(); } catch (SerializationException e) { Console.WriteLine(""); Console.WriteLine("LOAD ERROR"); Console.WriteLine("Serialization Error: " + e.ToString()); } return(s); }
/// <summary> /// Generates some goals from an Rndf /// </summary> /// <param name="rndfNetwork"></param> /// <returns></returns> private static Queue<Goal> generateGoals(RndfNetwork rndfNetwork) { Queue<Goal> goals = new Queue<Goal>(); try { // add goals in order of id for (int i = 1; i < 5; i++) { goals.Enqueue(rndfNetwork.Goals[i]); } } catch (Exception e) { Console.WriteLine(e.ToString()); throw e; } return goals; }
/// <summary> /// De-Serialize this byte-string and cast as a RndfNetwork object /// </summary> /// <param name="b"></param> /// <returns></returns> public RndfNetwork DeSerialize(byte[] b) { RndfNetwork s = new RndfNetwork(); try { MemoryStream str = new MemoryStream(b); BinaryFormatter bf = new BinaryFormatter(); s = (RndfNetwork)bf.Deserialize(str); str.Close(); } catch (SerializationException e) { Console.WriteLine(""); Console.WriteLine("LOAD ERROR"); Console.WriteLine("Serialization Error: " + e.ToString()); } return s; }
/// <summary> /// Deserialize the roadNetwork from a file /// </summary> /// <param name="filename"></param> /// <returns></returns> public RndfNetwork Load(string filename) { RndfNetwork s = new RndfNetwork(); try { FileStream str = File.OpenRead(filename); BinaryFormatter bf = new BinaryFormatter(); s = (RndfNetwork)bf.Deserialize(str); str.Close(); } catch (SerializationException e) { Console.WriteLine(""); Console.WriteLine("LOAD ERROR"); Console.WriteLine("Serialization Error: " + e.ToString()); } rndfNetwork = s; return s; }
/// <summary> /// Deserialize the roadNetwork from a file /// </summary> /// <param name="filename"></param> /// <returns></returns> public RndfNetwork Load(string filename) { RndfNetwork s = new RndfNetwork(); try { FileStream str = File.OpenRead(filename); BinaryFormatter bf = new BinaryFormatter(); s = (RndfNetwork)bf.Deserialize(str); str.Close(); } catch (SerializationException e) { Console.WriteLine(""); Console.WriteLine("LOAD ERROR"); Console.WriteLine("Serialization Error: " + e.ToString()); } rndfNetwork = s; return(s); }
/// <summary> /// Private constructor (singleton pattern). (Can add fields as needed to constructor) /// </summary> /// <param name="rndfNetwork">the rndf network</param> private TestDataServerFacadeImpl(RndfNetwork rndfNetwork, Mdf mdf, VehicleState vehicleState) { this.rndfNetwork = rndfNetwork; this.mdf = mdf; this.vehicleState = vehicleState; }
public abstract void Restart(RndfNetwork rndf, Mdf mdf, ArbiterMode mode);
/// <summary> /// Gets the next point at which we must stop /// </summary> /// <param name="rndf"></param> /// <param name="vehicleLocation"></param> /// <returns></returns> public static RndfWayPoint NextStopOrEnd(RndfNetwork rndf, RndfLocation vehicleLocation) { // set current as final waypoint on current partition RndfWayPoint current = vehicleLocation.Partition.FinalWaypoint; // iterate over waypoints while (!current.IsStop && current.NextLanePartition != null) { // update current current = current.NextLanePartition.FinalWaypoint; } // return current as stop or end of lane return current; }
public RndfDisplay(RndfNetwork rndf) { this.rndf = rndf; }
/// <summary> /// Determines exit adjacency maps, i.e. where on each lane is an entry adjacent to (with some penalty for number of lane switches) /// </summary> /// <param name="rndf"></param> /// <returns></returns> private RndfNetwork DetermineEntryAdjacency(RndfNetwork rndf) { return rndf; }
/// <summary> /// Modifies the zones into the rndf network format /// </summary> /// <param name="rndf"></param> /// <returns></returns> private RndfNetwork GenerateRndfNetworkZones(RndfNetwork rndf) { return rndf; }
public RouteDisplay(RndfNetwork rndf, FullRoute route) { this.rndf = rndf; this.route = route; }
/// <summary> /// Constructor /// </summary> /// <param name="rndfNetwork">Network object to handle</param> public RndfNetworkHandler(RndfNetwork rndfNetwork) { this.rndfNetwork = rndfNetwork; }
public void RestartArbiter(RndfNetwork rndfNetwork, Mdf mdf) { if (arbiterRemote != null) { try { this.arbiterRemote.Restart(rndfNetwork, mdf, UrbanChallenge.Arbiter.ArbiterCommon.ArbiterMode.Debug); } catch (Exception e) { RemoraOutput.WriteLine(e.ToString()); } } else { RemoraOutput.WriteLine("Arbter Remote does not exist"); } }
/// <summary> /// Singleton pattern. Static read-only instance property. /// </summary> public static TestServerFacade Instance(RndfNetwork rndfNetwork, Mdf mdf, VehicleState vehicleState) { if (instance == null) instance = new TestDataServerFacadeImpl(rndfNetwork, mdf, vehicleState); return instance; }
public GoalsDisplay(RndfNetwork rndf, RndfWaypointID current, Queue<RndfWaypointID> remaining) { this.rndf = rndf; this.Current = current; this.GoalsRemaining = remaining; }
/// <summary> /// Generates the zone graph for travel in the zone /// </summary> /// <param name="rndf"></param> /// <returns></returns> private RndfNetwork CreateZoneGraph(RndfNetwork rndf) { return rndf; }
public static void NextStop(RndfNetwork rndf, RndfLocation vehicleLocation, out RndfWayPoint nextStop, out double distance) { // set current as final waypoint on current partition RndfWayPoint current = vehicleLocation.Partition.FinalWaypoint; // set initial distance distance = vehicleLocation.AbsolutePositionOnPartition.DistanceTo(current.Position); // iterate over waypoints while (!current.IsStop && current.NextLanePartition != null) { // update distance distance += current.Position.DistanceTo(current.NextLanePartition.FinalWaypoint.Position); // update current current = current.NextLanePartition.FinalWaypoint; } if (current.IsStop) { nextStop = current; // return current as stop or end of lane return; } else { nextStop = null; return; } }
/// <summary> /// Determines the lane adjacency /// </summary> /// <param name="rndf"></param> /// <returns></returns> private RndfNetwork DetermineLaneAdjacency(RndfNetwork rndf) { // loop over segment foreach (Segment segment in rndf.Segments.Values) { // make sure both ways valid if (segment.Way1.IsValid && segment.Way2.IsValid) { // dictionary of lanes in the segment Dictionary<LaneID, Lane> segmentLanes = new Dictionary<LaneID, Lane>(); // construct dictionary foreach (Way way in segment.Ways.Values) { foreach (Lane lane in way.Lanes.Values) { segmentLanes.Add(lane.LaneID, lane); } } // check sample lane in way1 Lane way1SampleLane = null; foreach (Lane tmp in segment.Way1.Lanes.Values) { way1SampleLane = tmp; } // check sample lane in way2 Lane way2SampleLane = null; foreach (Lane tmp in segment.Way2.Lanes.Values) { way2SampleLane = tmp; } // modifies to denote increasing or decreasing form way1 to way 2 int modifier = 1; // check if way2 has lower numbers if (way1SampleLane.LaneID.LaneNumber > way2SampleLane.LaneID.LaneNumber) modifier = -1; int i = 1; LaneID currentLaneID = new LaneID(way1SampleLane.LaneID.WayID, i); // loop over lanes while (segmentLanes.ContainsKey(currentLaneID)) { Lane currentLane = segmentLanes[currentLaneID]; // increasing lane LaneID increasingLaneID1 = new LaneID(segment.Way1.WayID, i + (modifier * 1)); LaneID increasingLaneID2 = new LaneID(segment.Way2.WayID, i + (modifier * 1)); if (segmentLanes.ContainsKey(increasingLaneID1)) { if (currentLaneID.WayID.WayNumber == 1) currentLane.OnLeft = segmentLanes[increasingLaneID1]; else currentLane.OnRight = segmentLanes[increasingLaneID1]; } else if (segmentLanes.ContainsKey(increasingLaneID2)) { if (currentLaneID.WayID.WayNumber == 1) currentLane.OnLeft = segmentLanes[increasingLaneID2]; else currentLane.OnRight = segmentLanes[increasingLaneID2]; } // check for decreasing // increasing lane increasingLaneID1 = new LaneID(segment.Way1.WayID, i - (modifier * 1)); increasingLaneID2 = new LaneID(segment.Way2.WayID, i - (modifier * 1)); if (segmentLanes.ContainsKey(increasingLaneID1)) { if (currentLaneID.WayID.WayNumber == 1) currentLane.OnRight = segmentLanes[increasingLaneID1]; else currentLane.OnLeft = segmentLanes[increasingLaneID1]; } else if (segmentLanes.ContainsKey(increasingLaneID2)) { if (currentLaneID.WayID.WayNumber == 1) currentLane.OnRight = segmentLanes[increasingLaneID2]; else currentLane.OnLeft = segmentLanes[increasingLaneID2]; } if (currentLane.OnLeft != null) { Console.WriteLine("Lane: " + currentLane.LaneID.ToString() + ". On Left: " + currentLane.OnLeft.LaneID.ToString()); } i++; currentLaneID = new LaneID(segment.Way1.WayID, i); if (segmentLanes.ContainsKey(new LaneID(segment.Way2.WayID, i))) currentLaneID = new LaneID(segment.Way2.WayID, i); } } else { // HACK //throw new Exception("single way lane!"); } } return rndf; }
/// <summary> /// Gets the closest position to the coordinates on a specific lane in the rndf network /// </summary> /// <param name="coordinate"></param> /// <param name="lane"></param> /// <param name="rndfNetwork"></param> /// <returns></returns> public static LocationAnalysis ClosestRndfRelativeParition(Coordinates coordinate, LaneID lane, RndfNetwork rndfNetwork) { // use point analysis tool return PointAnalysis.ClosestPartitionOnLane(coordinate, lane, rndfNetwork); }
/// <summary> /// Gets the closest position to the coordinates on any lane in the rndf network /// </summary> /// <param name="coordinate"></param> /// <param name="rndfNetwork"></param> /// <returns></returns> public static LocationAnalysis ClosestRndfRelativeLanePartition(Coordinates coordinate, RndfNetwork rndfNetwork) { // use the point analysis tool return PointAnalysis.GetClosestLanePartition(coordinate, rndfNetwork); }
/// <summary> /// Sets the rndf, removing older ones /// </summary> /// <param name="rndf"></param> public void SetRndf(RndfNetwork rndf) { this.rndf = rndf; for (int i = 0; i < displayObjects.Count; i++) { if (displayObjects[i] is RndfDisplay) { displayObjects.RemoveAt(i); } } displayObjects.Add(new RndfDisplay(rndf)); this.Invalidate(); }