public static void Smooth(List <SteerPoint> steerPoints) { // todo: Could add a pass to merge points within 25 meters or so. // Take (linear) middle between points, average speed, set 'maximum' runway ops on merged point // Maybe after smoothing works best for (int i = 1; i < steerPoints.Count() - 1; i++) { if (steerPoints[i] is PushbackPoint) { continue; } SteerPoint previous = steerPoints[i - 1]; SteerPoint current = steerPoints[i]; SteerPoint next = steerPoints[i + 1]; double incomingBearing = VortexMath.BearingRadians(previous, current); double outgoingBearing = VortexMath.BearingRadians(current, next); double turnAngle = VortexMath.AbsTurnAngle(incomingBearing, outgoingBearing); if (!current.Protected && turnAngle < 2.5 * VortexMath.Deg2Rad && !(current is RunwayPoint)) { if (previous.Name == next.Name && previous.Speed == next.Speed) { steerPoints.RemoveAt(i); i--; } } else if (!current.Protected && turnAngle > VortexMath.PI025) // 45 degrees { double smoothingDistance = 0.050 * (turnAngle / VortexMath.PI); // 90 degrees = 0.5 PI / PI = 0.5 * 0.05 km = 25 meters double currentLatitude = current.Latitude; double currentLongitude = current.Longitude; if (VortexMath.DistanceKM(previous.Latitude, previous.Longitude, currentLatitude, currentLongitude) > smoothingDistance) { // Shift the current point a bit back VortexMath.PointFrom(currentLatitude, currentLongitude, incomingBearing + VortexMath.PI, smoothingDistance, ref current.Latitude, ref current.Longitude); if (current.Speed > 14) { current.Speed /= 2; } } else { // skip the current steerPoints.RemoveAt(i); i--; } double distanceToNext = VortexMath.DistanceKM(currentLatitude, currentLongitude, next.Latitude, next.Longitude); if (distanceToNext > smoothingDistance) { // Insert an extra point SteerPoint newPoint = next.Duplicate(); VortexMath.PointFrom(currentLatitude, currentLongitude, outgoingBearing, smoothingDistance, ref newPoint.Latitude, ref newPoint.Longitude); // If room for additional speed up point, reduce acceleration on this point if (distanceToNext > 2.5 * smoothingDistance) { newPoint.Speed = (newPoint.Speed * 2) / 3; } steerPoints.Insert(i + 1, newPoint); i++; } if (distanceToNext > 2.5 * smoothingDistance) { // Insert an extra point SteerPoint newPoint = next.Duplicate(); VortexMath.PointFrom(currentLatitude, currentLongitude, outgoingBearing, 2.5 * smoothingDistance, ref newPoint.Latitude, ref newPoint.Longitude); steerPoints.Insert(i + 1, newPoint); i++; } } } }
private void button2_Click(object sender, EventArgs e) { string aircraftFolder = Path.Combine(Settings.XPlaneLocation, "ClassicJetSimUtils", "WorldTraffic", "AircraftTypes"); IEnumerable <string> baseAircraft = Directory.EnumerateFiles(aircraftFolder, "*_BASE.txt"); rtbAircraft.Clear(); rtbAircraft.AppendText($"Found {baseAircraft.Count()} 'base' aircraft.\n\n"); WorldTrafficAircraftType currentType = WorldTrafficAircraftType.Fighter; Dictionary <WorldTrafficAircraftType, List <AircraftBase> > aircraft = new Dictionary <WorldTrafficAircraftType, List <AircraftBase> >(); for (WorldTrafficAircraftType wat = WorldTrafficAircraftType.Fighter; wat < WorldTrafficAircraftType.Max; wat++) { aircraft[wat] = new List <AircraftBase>(); } foreach (string basecraft in baseAircraft) { AircraftBase aircraftBase = null; string[] lines = File.ReadAllLines(basecraft); bool startFound = false; string nameCache = ""; foreach (string line in lines) { string[] tokens = line.ToLower().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); if (tokens.Length < 1) { continue; } if (!startFound) { if (tokens[0] != "start") { continue; } else { startFound = true; continue; } } if (tokens.Length < 2) { continue; } switch (tokens[0]) { case "type": currentType = (WorldTrafficAircraftType)int.Parse(tokens[1]); aircraftBase = new AircraftBase { Name = nameCache.ToUpper() }; break; case "name": nameCache = tokens[1]; break; case "wingspan": aircraftBase.WingSpan = VortexMath.Parse(tokens[1]); break; case "takeoffdistatmtow": aircraftBase.TakeOffDist = VortexMath.Parse(tokens[1]); break; case "landingdist": aircraftBase.LandingDist = VortexMath.Parse(tokens[1]); break; case "minlandingdist": aircraftBase.MinLandingDist = VortexMath.Parse(tokens[1]); break; default: break; } } aircraft[currentType].Add(aircraftBase); } for (WorldTrafficAircraftType wat = WorldTrafficAircraftType.Fighter; wat < WorldTrafficAircraftType.Max; wat++) { if (aircraft[wat].Count > 0) { rtbAircraft.AppendText($"World Traffic Type {(int)wat} <{wat}> {aircraft[wat].Count} base aircraft\n"); var byCat = aircraft[wat].GroupBy(ac => SpanToCat(ac.WingSpan)); var catCounts = byCat.ToDictionary(ca => ca.Key, ca => ca.ToList().Count); double minLandingDist = aircraft[wat].Min(ac => ac.LandingDist); double maxLandingDist = aircraft[wat].Max(ac => ac.LandingDist); var withMLD = aircraft[wat].Where(ac => ac.MinLandingDist > 0); double minMinLandingDist = withMLD.Count() > 0 ? withMLD.Min(ac => ac.MinLandingDist) : 0.0; int noMinLandingDist = aircraft[wat].Count(ac => ac.MinLandingDist == 0); double maxMinLandingDist = aircraft[wat].Max(ac => ac.MinLandingDist); double minWingSpan = aircraft[wat].Min(ac => ac.WingSpan); double maxWingSpan = aircraft[wat].Max(ac => ac.WingSpan); double minTakeOff = aircraft[wat].Min(ac => ac.TakeOffDist); double maxTakeOff = aircraft[wat].Max(ac => ac.TakeOffDist); string Name = aircraft[wat].First(ac => ac.WingSpan == maxWingSpan).Name; rtbAircraft.AppendText($" Required Gate/Taxiway Size: <{SpanToCat(maxWingSpan)}> ({Name} has wingspan {maxWingSpan,4:0.0})\n"); foreach (var group in byCat) { rtbAircraft.AppendText($" Number of cat {group.Key} : {catCounts[group.Key],5} {string.Join(", ", group)}\n"); } Name = aircraft[wat].First(ac => ac.TakeOffDist == minTakeOff).Name; rtbAircraft.AppendText($" Shortest Takeoff possible : {minTakeOff,5} ({Name})\n"); Name = aircraft[wat].First(ac => ac.TakeOffDist == maxTakeOff).Name; rtbAircraft.AppendText($" Max Takeoff required : {maxTakeOff,5} ({Name})\n"); Name = aircraft[wat].First(ac => ac.LandingDist == minLandingDist).Name; rtbAircraft.AppendText($" Shortest Landing Distance : {minLandingDist,5} ({Name})\n"); Name = aircraft[wat].First(ac => ac.LandingDist == maxLandingDist).Name; rtbAircraft.AppendText($" Longest Landing Distance : {maxLandingDist,5} ({Name})\n"); Name = aircraft[wat].First(ac => ac.MinLandingDist == minMinLandingDist).Name; rtbAircraft.AppendText($" Shortest Min Ldg Dist. : {minMinLandingDist,5} ({Name})\n"); Name = aircraft[wat].First(ac => ac.MinLandingDist == maxMinLandingDist).Name; rtbAircraft.AppendText($" Longest Min Ldg Dist. : {maxMinLandingDist,5} ({Name})\n"); rtbAircraft.AppendText($" Without Min Ldg Dist. : {noMinLandingDist,5}\n"); //rtbAircraft.AppendText($"{wat,-10} {aircraft[wat].Count(),2} {minLandingDist,5} {maxLandingDist,5} {minMinLandingDist,5} {maxMinLandingDist,5} {minTakeOff,5} {maxTakeOff,5} {minWingSpan,4:0.0} <{SpanToCat(minWingSpan)}> {maxWingSpan,4:0.0} <{SpanToCat(maxWingSpan)}>\n"); rtbAircraft.AppendText("\n"); } } //foreach (KeyValuePair<int, List<AircraftBase>> details in aircraft.OrderBy(ac => ac.Key)) //{ // double averageWingSpan = details.Value.Average(a => a.WingSpan); // double minWingSpan = details.Value.Min(a => a.WingSpan); // double maxWingSpan = details.Value.Max(a => a.WingSpan); // rtbAircraft.AppendText($"{details.Key} Wingspan: mn {minWingSpan:0.0} <{SpanToCat(minWingSpan)}> av {averageWingSpan:0.0} mx: {maxWingSpan:0.0} <{SpanToCat(maxWingSpan)}>\n"); //} //foreach (KeyValuePair<int, List<AircraftBase>> details in aircraft.OrderBy(ac => ac.Key)) //{ // double averageLength = details.Value.Average(a => a.TakeOffDist); // double minLength = details.Value.Min(a => a.TakeOffDist); // double maxLength = details.Value.Max(a => a.TakeOffDist); // rtbAircraft.AppendText($"{details.Key} TakeOffDist: mn {minLength:0} av {averageLength:0} mx: {maxLength:0}\n"); //} //foreach (KeyValuePair<int, List<AircraftBase>> details in aircraft.OrderBy(ac => ac.Key)) //{ // double averageLength = details.Value.Average(a => a.LandingDist); // double minLength = details.Value.Min(a => a.LandingDist); // double maxLength = details.Value.Max(a => a.LandingDist); // rtbAircraft.AppendText($"{details.Key} LandingDist: mn {minLength:0} av {averageLength:0} mx: {maxLength:0}\n"); //} }
/// <summary> /// Extract the route that starts at TaxiNode 'startNode' /// </summary> /// <param name="edges">A list of all available edges</param> /// <param name="startNode">The first node of the route</param> /// <param name="size">The maximum size for which this route is valid</param> /// <returns>The route as a linked list of nodes with additional informationthat will be needed when writing the route to a file</returns> public static ResultRoute ExtractRoute(IEnumerable <TaxiEdge> edges, TaxiNode startNode, XPlaneAircraftCategory size) { ResultRoute extracted = new ResultRoute(size); extracted.Runway = null; extracted.StartNode = startNode; ulong node1 = extracted.StartNode.Id; extracted.Distance = startNode.DistanceToTarget; TaxiNode pathNode; pathNode = startNode.NextNodeToTarget; TaxiEdge sneakEdge = null; if (pathNode != null) { sneakEdge = edges.SingleOrDefault(e => e.StartNode.Id == node1 && e.EndNode.Id == pathNode.Id); } // Set up the first link extracted.RouteStart = new LinkedNode() { Node = startNode.NextNodeToTarget, Next = null, Edge = sneakEdge }; LinkedNode currentLink = extracted.RouteStart; // And follow the path... while (pathNode != null) { double currentBearing = currentLink.Node.BearingToTarget; ulong node2 = pathNode.Id; TaxiEdge edge = edges.Single(e => e.StartNode.Id == node1 && e.EndNode.Id == node2); if (pathNode.NextNodeToTarget != null && pathNode.NextNodeToTarget.DistanceToTarget > 0) { double nextBearing = pathNode.NextNodeToTarget.BearingToTarget; double turn = VortexMath.AbsTurnAngle(currentBearing, nextBearing); // This filters out very sharp turns if an alternate exists in exchange for a longer route: // todo: parameters. Now => if more than 120 degrees and alternate < 45 exists use alternate if (turn > VortexMath.Deg120Rad) { IEnumerable <TaxiEdge> altEdges = edges.Where(e => e.StartNode.Id == pathNode.NextNodeToTarget.Id && e.EndNode.Id != pathNode.NextNodeToTarget.NextNodeToTarget.Id && e.EndNode.Id != pathNode.Id); foreach (TaxiEdge te in altEdges) { if (te.EndNode.DistanceToTarget < double.MaxValue) { double newTurn = VortexMath.AbsTurnAngle(currentBearing, te.EndNode.BearingToTarget); if (newTurn < VortexMath.Deg100Rad) { // Fiddling with Dijkstra results like this may generate a loop in the route // So scan it before actually using the reroute if (!hasLoop(te.EndNode, pathNode)) { pathNode.NextNodeToTarget.OverrideToTarget = te.EndNode; break; } } } } } else if (turn > VortexMath.Deg005Rad) // Any turn larger than 5 degrees: if going straight does not lead to more than 250m extra distance... go straight. { IEnumerable <TaxiEdge> altEdges = edges.Where(e => e.StartNode.Id == pathNode.NextNodeToTarget.Id && e.EndNode.Id != pathNode.NextNodeToTarget.NextNodeToTarget.Id && e.EndNode.Id != pathNode.Id); foreach (TaxiEdge te in altEdges) { if (te.EndNode.DistanceToTarget < (pathNode.NextNodeToTarget.NextNodeToTarget.DistanceToTarget + 0.250)) { double newTurn = VortexMath.AbsTurnAngle(currentBearing, te.EndNode.BearingToTarget); if (newTurn < VortexMath.Deg005Rad) { // Fiddling with Dijkstra results like this may generate a loop in the route // So scan it before actually using the reroute if (!hasLoop(te.EndNode, pathNode)) { pathNode.NextNodeToTarget.OverrideToTarget = te.EndNode; break; } } } } } } TaxiNode nextNode = (pathNode.OverrideToTarget != null) ? pathNode.OverrideToTarget : pathNode.NextNodeToTarget; currentLink.Next = new LinkedNode() { Node = nextNode, Next = null, }; node1 = node2; currentLink.Edge = edge; currentLink = currentLink.Next; extracted.TargetNode = pathNode; pathNode.OverrideToTarget = null; pathNode = nextNode; } return(extracted); }
private IEnumerable <SteerPoint> BuildSteerPoints(Parking currentParking, ResultRoute route) { LinkedNode link = route.RouteStart; TaxiNode nodeToWrite = route.StartNode; EntryPoint entryPoint = route.RunwayEntryPoint; List <SteerPoint> steerPoints = new List <SteerPoint> { new ParkingPoint(currentParking.Latitude, currentParking.Longitude, 3, $"{currentParking.Name}", currentParking.Bearing, false) }; // Write Pushback node, allowing room for turn double addLat = 0; double addLon = 0; // See if we need to skip the first route node if (currentParking.AlternateAfterPushBack != null && currentParking.AlternateAfterPushBack == route.RouteStart.Node) { // Our pushback point is better than the first point of the route nodeToWrite = currentParking.AlternateAfterPushBack; } // insert one more point here where the plane is pushed a little bit away from the next point if (currentParking.LocationType == StartUpLocationType.Gate) { if (nodeToWrite != null) { double nextPushBearing; if (VortexMath.DistanceKM(nodeToWrite.Latitude, nodeToWrite.Longitude, currentParking.PushBackLatitude, currentParking.PushBackLongitude) > 0.010) { // Push target is a virtual node nextPushBearing = VortexMath.BearingRadians(nodeToWrite.Latitude, nodeToWrite.Longitude, currentParking.PushBackLatitude, currentParking.PushBackLongitude); } else { // Push target is very close to the actual first node of the route nextPushBearing = (nodeToWrite.BearingToTarget + VortexMath.PI) % VortexMath.PI2; } double turn = VortexMath.TurnAngle(currentParking.Bearing + VortexMath.PI, nextPushBearing); double turnAbs = Math.Abs(turn); double factor = ((turnAbs) / VortexMath.PI); // 0...0.5.....1 factor = (factor * factor) + factor / 4; // 0...0.375...1.25 double distance = 0.040 * factor; // 0m...15m ...50m if (turnAbs < VortexMath.Deg135Rad) { // Try to trun the aircraft to the bearing it will need to go in after pushback // First point is on the pushback heading, but away from the actual target to allow the AC to turn VortexMath.PointFrom(currentParking.PushBackLatitude, currentParking.PushBackLongitude, currentParking.Bearing, distance, ref addLat, ref addLon); steerPoints.Add(new PushbackPoint(addLat, addLon, 2, $"{currentParking.Name}")); // Second point is on the (extended) line of the first link of the actual route VortexMath.PointFrom(currentParking.PushBackLatitude, currentParking.PushBackLongitude, nextPushBearing, distance, ref addLat, ref addLon); steerPoints.Add(new PushbackPoint(addLat, addLon, 2, $"{link.Edge.LinkName}")); // Third point is on the same line but a little bit extra backwards to get the nose in the intended heading VortexMath.PointFrom(currentParking.PushBackLatitude, currentParking.PushBackLongitude, nextPushBearing, distance + 0.015, ref addLat, ref addLon); steerPoints.Add(new SteerPoint(addLat, addLon, 8, $"{link.Edge.LinkName}", true)); } else { // Let's just turn it to a 90 degree angle with the first edge // First point is on the pushback heading, but away from the actual target to allow the AC to turn VortexMath.PointFrom(currentParking.PushBackLatitude, currentParking.PushBackLongitude, currentParking.Bearing, distance, ref addLat, ref addLon); steerPoints.Add(new PushbackPoint(addLat, addLon, 2, $"{currentParking.Name}")); // Second point is on the (extended) line of the first link of the actual route, but much closer then for the full turn VortexMath.PointFrom(currentParking.PushBackLatitude, currentParking.PushBackLongitude, nextPushBearing, distance / 2.0, ref addLat, ref addLon); steerPoints.Add(new PushbackPoint(addLat, addLon, 2, $"{link.Edge.LinkName}")); // Third point is on +/-90 degree angle from the first link VortexMath.PointFrom(addLat, addLon, (turn > 0) ? nextPushBearing + VortexMath.PI05 : nextPushBearing - VortexMath.PI05, 0.015, ref addLat, ref addLon); steerPoints.Add(new SteerPoint(addLat, addLon, 5, $"{link.Edge.LinkName}", true)); // Add a fourth point back on the intended line steerPoints.Add(new SteerPoint(currentParking.PushBackLatitude, currentParking.PushBackLongitude, 8, $"{link.Edge.LinkName}")); } } } else { // Tie down, hangar, misc: just add the 'pushback' point as first target, smoothing should take care of the rest steerPoints.Add(new SteerPoint(currentParking.PushBackLatitude, currentParking.PushBackLongitude, 8, $"{link.Edge.LinkName}")); } if (nodeToWrite != link.Node) { steerPoints.Add(new SteerPoint(nodeToWrite.Latitude, nodeToWrite.Longitude, 8, $"{link.Edge.LinkName}")); } while (link.Node != null) { bool activeZone = false; string activeFor = ""; if (link.Edge.ActiveZone) { activeZone = true; activeFor = link.Edge.ActiveForRunway(Runway.Designator); } else if (link.Next.Edge != null && link.Next.Edge.ActiveZone) { activeZone = true; activeFor = link.Next.Edge.ActiveForRunway(Runway.Designator); } else if (link.Next.Edge == null) { activeZone = true; activeFor = Runway.Designator; } if (activeZone) { steerPoints.Add(new RunwayPoint(link.Node.Latitude, link.Node.Longitude, 15, $"{link.Edge.LinkName}", activeFor)); } else { steerPoints.Add(new SteerPoint(link.Node.Latitude, link.Node.Longitude, 15, $"{link.Edge.LinkName}")); } link = link.Next; } steerPoints.Add(new RunwayPoint(entryPoint.OnRunwayNode, 8, Runway.Designator, Runway.Designator)); VortexMath.PointFrom(entryPoint.OnRunwayNode, Runway.Bearing, 0.022, ref addLat, ref addLon); steerPoints.Add(new RunwayPoint(addLat, addLon, 6, Runway.Designator, Runway.Designator)); RouteProcessor.Smooth(steerPoints); RouteProcessor.ProcessRunwayOperations(steerPoints); if (MaxOutPoints < steerPoints.Count) { MaxOutPoints = steerPoints.Count; } return(steerPoints); }
private IEnumerable <SteerPoint> BuildSteerPoints(ResultRoute route, TaxiNode runwayExitNode) { List <SteerPoint> steerPoints = new List <SteerPoint>(); // Route should start at the (displaced) threshold RunwayPoint threshold = new RunwayPoint(route.Runway.DisplacedNode, 55, $"{route.Runway.Designator} Threshold", route.RouteStart.Edge.ActiveForRunway(route.Runway.Designator)) { OnRunway = true, IsExiting = true }; steerPoints.Add(threshold); foreach (TaxiNode node in route.Runway.RunwayNodes) { int speed = (node == runwayExitNode) ? 35 : 55; steerPoints.Add(new RunwayPoint(node.Latitude, node.Longitude, speed, $"{route.Runway.Designator}", route.RouteStart.Edge.ActiveForRunway(route.Runway.Designator))); if (node == runwayExitNode) // Key of the dictionary is the last node on the runway centerline for this route { break; } } // This is the first node off the runway centerline steerPoints.Add(new RunwayPoint(route.StartNode, 30, route.RouteStart.Edge.LinkName, route.RouteStart.Edge.ActiveForRunway(route.Runway.Designator))); LinkedNode link = route.RouteStart; while (link.Node != null) { bool activeZone = false; string activeFor = ""; if (link.Edge.ActiveZone) { activeZone = true; activeFor = link.Edge.ActiveForRunway(""); } else if (link.Next.Edge != null && link.Next.Edge.ActiveZone) { activeZone = true; activeFor = link.Next.Edge.ActiveForRunway(""); } if (activeZone) { steerPoints.Add(new RunwayPoint(link.Node.Latitude, link.Node.Longitude, 15, $"{link.Edge.LinkName}", activeFor)); } else { steerPoints.Add(new SteerPoint(link.Node.Latitude, link.Node.Longitude, 15, $"{link.Edge.LinkName}")); } link = link.Next; } // remove last point if it takes us past the 'pushback point' if (steerPoints.Count > 1) { SteerPoint oneButLast = steerPoints.ElementAt(steerPoints.Count - 2); SteerPoint last = steerPoints.ElementAt(steerPoints.Count - 1); double lastBearing = VortexMath.BearingRadians(oneButLast, last); double bearingToPush = VortexMath.BearingRadians(last.Latitude, last.Longitude, Parking.PushBackLatitude, Parking.PushBackLongitude); double turnToPush = VortexMath.AbsTurnAngle(lastBearing, bearingToPush); if (turnToPush > VortexMath.Deg100Rad) { steerPoints.RemoveAt(steerPoints.Count - 1); } } // todo: how does this all work with freaky pushback points? // todo: tie downs steerPoints.Add(new SteerPoint(Parking.PushBackLatitude, Parking.PushBackLongitude, 5, Parking.Name)); steerPoints.Add(new ParkingPoint(Parking.Latitude, Parking.Longitude, 5, Parking.Name, Parking.Bearing, true)); //RouteProcessor.Smooth(steerPoints); RouteProcessor.ProcessRunwayOperations(steerPoints); if (MaxInPoints < steerPoints.Count) { MaxInPoints = steerPoints.Count; } return(steerPoints); }