fly/flightgear
1
0
Fork 0
Code Activity

Bugfixes and feature improvements related to AI auto flightplan generation.

Browse source 
When AIFlightPlanCreateTaxi() function is called with the firstFlight
argument set to true, this is supposed to handle situations where the
the aircraft's timetable indicates it should have left between about 5 to
20 minutes earlier. In the previous version, all these aircraft started
taxiing from the first parking location available in the network, due
to the fact that the variable gateId was not assigned a value. In this
patch, route tracing starts from an assigned gate and the network node
following code is fast forwarded to a random location along the taxiways
to give a more realistic and natural distribution of taxiing aircraft
after startup.
    This patch further addresses some weird ballet-dancing behavior that
aircraft were showing just prior to/right after parking and which was
related to a number of more or less duplicate waypoints in the transition
from createTaxi() to createParking() to createPushBack() to createTaxi().
    Finally, a blatant typing error in the getParking() function was fixed.
This commit is contained in:
durk 2006-03-19 07:41:48 +00:00
parent 9604277484
commit 101ca14a6d
5 changed files with 253 additions and 293 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/AIModel/AIAircraft.cxx
View file

@ -703,18 +703,19 @@ void FGAIAircraft::ProcessFlightPlan( double dt, time_t now )
{ {
dep->getDynamics()->releaseParking(fp->getGate()); dep->getDynamics()->releaseParking(fp->getGate());
} }
// Some debug messages, specific to TESTING THE Logical networks. // Some debug messages, specific to testing the Logical networks.
//if ((arr->getId() == string("EHAM")) && (prev->name == "Center")) //if ((arr->getId() == string("EHAM")) && (prev->name == "Center"))
// { // {
// //
// cerr << "Schiphol ground " // cerr << "Schiphol ground "
// << trafficRef->getRegistration() << " "
// << trafficRef->getCallSign(); // << trafficRef->getCallSign();
// if (trafficRef->getHeavy()) // if (trafficRef->getHeavy())
// cerr << "Heavy"; // cerr << "Heavy";
// cerr << " landed runway " // cerr << " landed runway "
// << fp->getRunway() // << fp->getRunway()
// << " request taxi to gate " // << " request taxi to gate "
// << arr->getParkingName(fp->getGate()) // << arr->getDynamics()->getParkingName(fp->getGate())
// << endl; // << endl;
// } // }
if (prev->name == "END") if (prev->name == "END")

2
src/AIModel/AIFlightPlan.hxx
View file

@ -117,7 +117,7 @@ private:
void createCruise(bool, FGAirport*, FGAirport*, double, double, double, double); void createCruise(bool, FGAirport*, FGAirport*, double, double, double, double);
void createDecent(FGAirport *); void createDecent(FGAirport *);
void createLanding(FGAirport *); void createLanding(FGAirport *);
void createParking(FGAirport *); void createParking(FGAirport *, double radius);
void deleteWaypoints(); void deleteWaypoints();
void resetWaypoints(); void resetWaypoints();
}; };

536
src/AIModel/AIFlightPlanCreate.cxx
View file

@ -29,59 +29,55 @@
* dynamically create a flight plan for AI traffic, based on data provided by the * dynamically create a flight plan for AI traffic, based on data provided by the
* Traffic Manager, when reading a filed flightplan failes. (DT, 2004/07/10) * Traffic Manager, when reading a filed flightplan failes. (DT, 2004/07/10)
* *
* This is the top-level function, and the only one that publicly available. * This is the top-level function, and the only one that is publicly available.
* *
*/ */
// Check lat/lon values during initialization; // Check lat/lon values during initialization;
void FGAIFlightPlan::create(FGAirport *dep, FGAirport *arr, int legNr, double alt, double speed, void FGAIFlightPlan::create(FGAirport *dep, FGAirport *arr, int legNr,
double latitude, double longitude, bool firstFlight, double alt, double speed, double latitude,
double radius, const string& fltType, const string& aircraftType, const string& airline) double longitude, bool firstFlight,double radius,
const string& fltType, const string& aircraftType,
const string& airline)
{ {
int currWpt = wpt_iterator - waypoints.begin(); int currWpt = wpt_iterator - waypoints.begin();
switch(legNr) switch(legNr)
{ {
case 1: case 1:
//cerr << "Creating Push_Back" << endl; createPushBack(firstFlight,dep, latitude, longitude,
createPushBack(firstFlight,dep, latitude, longitude, radius, fltType, aircraftType, airline); radius, fltType, aircraftType, airline);
//cerr << "Done" << endl;
break; break;
case 2: case 2:
//cerr << "Creating Taxi" << endl; createTaxi(firstFlight, 1, dep, latitude, longitude,
createTaxi(firstFlight, 1, dep, latitude, longitude, radius, fltType, aircraftType, airline); radius, fltType, aircraftType, airline);
break; break;
case 3: case 3:
//cerr << "Creating TAkeoff" << endl;
createTakeOff(firstFlight, dep, speed); createTakeOff(firstFlight, dep, speed);
break; break;
case 4: case 4:
//cerr << "Creating Climb" << endl;
createClimb(firstFlight, dep, speed, alt); createClimb(firstFlight, dep, speed, alt);
break; break;
case 5: case 5:
//cerr << "Creating Cruise" << endl;
createCruise(firstFlight, dep,arr, latitude, longitude, speed, alt); createCruise(firstFlight, dep,arr, latitude, longitude, speed, alt);
break; break;
case 6: case 6:
//cerr << "Creating Decent" << endl;
createDecent(arr); createDecent(arr);
break; break;
case 7: case 7:
//cerr << "Creating Landing" << endl;
createLanding(arr); createLanding(arr);
break; break;
case 8: case 8:
//cerr << "Creating Taxi 2" << endl; createTaxi(false, 2, arr, latitude, longitude, radius,
createTaxi(false, 2, arr, latitude, longitude, radius, fltType, aircraftType, airline); fltType, aircraftType, airline);
break; break;
case 9: case 9:
//cerr << "Creating Parking" << endl; createParking(arr, radius);
createParking(arr);
break; break;
default: default:
//exit(1); //exit(1);
cerr << "Unknown case: " << legNr << endl; SG_LOG(SG_INPUT, SG_ALERT, "AIFlightPlan::create() attempting to create unknown leg"
" this is probably an internal program error");
} }
wpt_iterator = waypoints.begin()+currWpt; wpt_iterator = waypoints.begin()+currWpt;
leg++; leg++;
@ -92,12 +88,12 @@ void FGAIFlightPlan::create(FGAirport *dep, FGAirport *arr, int legNr, double al
* initialize the Aircraft at the parking location * initialize the Aircraft at the parking location
******************************************************************/ ******************************************************************/
void FGAIFlightPlan::createPushBack(bool firstFlight, FGAirport *dep, void FGAIFlightPlan::createPushBack(bool firstFlight, FGAirport *dep,
double latitude, double latitude,
double longitude, double longitude,
double radius, double radius,
const string& fltType, const string& fltType,
const string& aircraftType, const string& aircraftType,
const string& airline) const string& airline)
{ {
double heading; double heading;
double lat; double lat;
@ -115,19 +111,20 @@ void FGAIFlightPlan::createPushBack(bool firstFlight, FGAirport *dep,
if (firstFlight) if (firstFlight)
{ {
if (!(dep->getDynamics()->getAvailableParking(&lat, &lon, if (!(dep->getDynamics()->getAvailableParking(&lat, &lon,
&heading, &gateId, &heading, &gateId,
radius, fltType, radius, fltType,
aircraftType, airline))) aircraftType, airline)))
{ {
cerr << "Could not find parking " << endl; SG_LOG(SG_INPUT, SG_WARN, "Could not find parking for a " <<
} aircraftType <<
" of flight type " << fltType <<
" of airline " << airline <<
" at airport " << dep->getId());
}
} }
else else
{ {
dep->getDynamics()->getParking(gateId, &lat, &lon, &heading); dep->getDynamics()->getParking(gateId, &lat, &lon, &heading);
//lat = latitude;
//lon = longitude;
//heading = getHeading();
} }
heading += 180.0; heading += 180.0;
if (heading > 360) if (heading > 360)
@ -148,8 +145,8 @@ void FGAIFlightPlan::createPushBack(bool firstFlight, FGAirport *dep,
// Add park twice, because it uses park once for initialization and once // Add park twice, because it uses park once for initialization and once
// to trigger the departure ATC message // to trigger the departure ATC message
geo_direct_wgs_84 ( 0, lat, lon, heading, geo_direct_wgs_84 ( 0, lat, lon, heading,
10, 10,
&lat2, &lon2, &az2 ); &lat2, &lon2, &az2 );
wpt = new waypoint; wpt = new waypoint;
wpt->name = "park2"; wpt->name = "park2";
wpt->latitude = lat2; wpt->latitude = lat2;
@ -163,8 +160,8 @@ void FGAIFlightPlan::createPushBack(bool firstFlight, FGAirport *dep,
wpt->on_ground = true; wpt->on_ground = true;
waypoints.push_back(wpt); waypoints.push_back(wpt);
geo_direct_wgs_84 ( 0, lat, lon, heading, geo_direct_wgs_84 ( 0, lat, lon, heading,
radius, // push back one entire aircraft radius 2.2*radius,
&lat2, &lon2, &az2 ); &lat2, &lon2, &az2 );
wpt = new waypoint; wpt = new waypoint;
wpt->name = "taxiStart"; wpt->name = "taxiStart";
wpt->latitude = lat2; wpt->latitude = lat2;
@ -176,33 +173,56 @@ void FGAIFlightPlan::createPushBack(bool firstFlight, FGAirport *dep,
wpt->flaps_down= true; wpt->flaps_down= true;
wpt->finished = false; wpt->finished = false;
wpt->on_ground = true; wpt->on_ground = true;
waypoints.push_back(wpt); waypoints.push_back(wpt);
} }
/******************************************************************* /*******************************************************************
* createCreate Taxi. * createCreate Taxi.
* initialize the Aircraft at the parking location * initialize the Aircraft at the parking location
******************************************************************/ ******************************************************************/
void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt, double latitude, double longitude, double radius, const string& fltType, const string& acType, const string& airline) void FGAIFlightPlan::createTaxi(bool firstFlight, int direction,
FGAirport *apt, double latitude, double longitude,
double radius, const string& fltType,
const string& acType, const string& airline)
{ {
double wind_speed; double wind_speed;
double wind_heading; double wind_heading;
double heading; double heading;
//FGRunway rwy;
double lat, lon, az; double lat, lon, az;
double lat2, lon2, az2; double lat2, lon2, az2;
//int direction;
waypoint *wpt; waypoint *wpt;
// Erase all existing waypoints. if (direction == 1)
// wpt_vector_iterator i= waypoints.begin();
//resetWaypoints();
//int currWpt = wpt_iterator - waypoints.begin();
if (direction == 1)
{ {
//string name; // If this function is called during initialization,
// make sure we obtain a valid gate ID first
// and place the model at the location of the gate.
if (firstFlight)
{
if (!(apt->getDynamics()->getAvailableParking(&lat, &lon,
&heading, &gateId,
radius, fltType,
acType, airline)))
{
SG_LOG(SG_INPUT, SG_WARN, "Could not find parking for a " <<
acType <<
" of flight type " << fltType <<
" of airline " << airline <<
" at airport " << apt->getId());
}
//waypoint *wpt = new waypoint;
//wpt->name = "park";
//wpt->latitude = lat;
//wpt->longitude = lon;
//wpt->altitude = apt->getElevation();
//wpt->speed = -10;
//wpt->crossat = -10000;
//wpt->gear_down = true;
//wpt->flaps_down= true;
//wpt->finished = false;
//wpt->on_ground = true;
//waypoints.push_back(wpt);
}
// "NOTE: this is currently fixed to "com" for commercial traffic // "NOTE: this is currently fixed to "com" for commercial traffic
// Should be changed to be used dynamically to allow "gen" and "mil" // Should be changed to be used dynamically to allow "gen" and "mil"
// as well // as well
@ -211,38 +231,39 @@ void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt,
activeRunway, activeRunway,
&rwy))) &rwy)))
{ {
cout << "Failed to find runway for " << apt->getId() << endl; SG_LOG(SG_INPUT, SG_ALERT, "Failed to find runway " <<
// Hmm, how do we handle a potential error like this? activeRunway <<
exit(1); " at airport " << apt->getId());
} exit(1);
//string test; }
//apt->getActiveRunway(string("com"), 1, test);
//exit(1); // Determine the beginning of he runway
heading = rwy._heading; heading = rwy._heading;
double azimuth = heading + 180.0; double azimuth = heading + 180.0;
while ( azimuth >= 360.0 ) { azimuth -= 360.0; } while ( azimuth >= 360.0 ) { azimuth -= 360.0; }
geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth, geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth,
rwy._length * SG_FEET_TO_METER * 0.5 - 5.0, rwy._length * SG_FEET_TO_METER * 0.5 - 5.0,
&lat2, &lon2, &az2 ); &lat2, &lon2, &az2 );
if (apt->getDynamics()->getGroundNetwork()->exists()) if (apt->getDynamics()->getGroundNetwork()->exists())
{ {
intVec ids; intVec ids;
int runwayId = apt->getDynamics()->getGroundNetwork()->findNearestNode(lat2, lon2); int runwayId = apt->getDynamics()->getGroundNetwork()->findNearestNode(lat2,
//int currId = apt->getGroundNetwork()->findNearestNode(latitude,longitude); lon2);
//exit(1);
// A negative gateId indicates an overflow parking, use a // A negative gateId indicates an overflow parking, use a
// fallback mechanism for this. // fallback mechanism for this.
// Starting from gate 0 is a bit of a hack... // Starting from gate 0 in this case is a bit of a hack
// which requires a more proper solution later on.
FGTaxiRoute route; FGTaxiRoute route;
if (gateId >= 0) if (gateId >= 0)
route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(gateId, runwayId); route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(gateId,
runwayId);
else else
route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(0, runwayId); route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(0, runwayId);
intVecIterator i; intVecIterator i;
//cerr << "creating route : ";
// No route found: go from gate directly to runway
if (route.empty()) { if (route.empty()) {
//Add the runway startpoint; //Add the runway startpoint;
wpt = new waypoint; wpt = new waypoint;
@ -274,18 +295,47 @@ void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt,
} else { } else {
int node; int node;
route.first(); route.first();
bool isPushBackPoint = false;
if (firstFlight) {
// If this is called during initialization, randomly
// skip a number of waypoints to get a more realistic
// taxi situation.
isPushBackPoint = true;
int nrWaypoints = route.size();
int nrWaypointsToSkip = rand() % nrWaypoints;
for (int i = 0; i < nrWaypointsToSkip; i++) {
isPushBackPoint = false;
route.next(&node);
}
}
else {
//chop off the first two waypoints, because
// those have already been created
// by create pushback
int size = route.size();
if (size > 2) {
route.next(&node);
route.next(&node);
}
}
while(route.next(&node)) while(route.next(&node))
{ {
//i = ids.end()-1;
//cerr << "Creating Node: " << node << endl;
FGTaxiNode *tn = apt->getDynamics()->getGroundNetwork()->findNode(node); FGTaxiNode *tn = apt->getDynamics()->getGroundNetwork()->findNode(node);
//ids.pop_back(); //ids.pop_back();
wpt = new waypoint; wpt = new waypoint;
wpt->name = "taxiway"; // fixme: should be the name of the taxiway wpt->name = "taxiway"; // fixme: should be the name of the taxiway
wpt->latitude = tn->getLatitude(); wpt->latitude = tn->getLatitude();
wpt->longitude = tn->getLongitude(); wpt->longitude = tn->getLongitude();
wpt->altitude = apt->getElevation(); // should maybe be tn->elev too // Elevation is currently disregarded when on_ground is true
wpt->speed = 15; // because the AIModel obtains a periodic ground elevation estimate.
wpt->altitude = apt->getElevation();
if (isPushBackPoint) {
wpt->speed = -10;
isPushBackPoint = false;
}
else {
wpt->speed = 15;
}
wpt->crossat = -10000; wpt->crossat = -10000;
wpt->gear_down = true; wpt->gear_down = true;
wpt->flaps_down= true; wpt->flaps_down= true;
@ -295,10 +345,10 @@ void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt,
} }
cerr << endl; cerr << endl;
} }
//exit(1);
} }
else else
{ {
// This is the fallback mechanism, in case no ground network is available
//Add the runway startpoint; //Add the runway startpoint;
wpt = new waypoint; wpt = new waypoint;
wpt->name = "Airport Center"; wpt->name = "Airport Center";
@ -326,63 +376,35 @@ void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt,
wpt->finished = false; wpt->finished = false;
wpt->on_ground = true; wpt->on_ground = true;
waypoints.push_back(wpt); waypoints.push_back(wpt);
//wpt = new waypoint;
//wpt->finished = false;
//waypoints.push_back(wpt); // add one more to prevent a segfault.
} }
} }
else // Landing taxi else // Landing taxi
{ {
//string name; apt->getDynamics()->getAvailableParking(&lat, &lon, &heading,
// "NOTE: this is currently fixed to "com" for commercial traffic &gateId, radius, fltType,
// Should be changed to be used dynamically to allow "gen" and "mil" acType, airline);
// as well
//apt->getActiveRunway("com", 1, name);
//if (!(globals->get_runways()->search(apt->getId(),
// name,
// &rwy)))
//{//
//cout << "Failed to find runway for " << apt->getId() << endl;
// Hmm, how do we handle a potential error like this?
// exit(1);
// }
//string test;
//apt->getActiveRunway(string("com"), 1, test);
//exit(1);
//heading = rwy._heading;
//double azimuth = heading + 180.0;
//while ( azimuth >= 360.0 ) { azimuth -= 360.0; }
//geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth,
// rwy._length * SG_FEET_TO_METER * 0.5 - 5.0,
// &lat2, &lon2, &az2 );
apt->getDynamics()->getAvailableParking(&lat, &lon, &heading, &gateId, radius, fltType, acType, airline);
heading += 180.0;
if (heading > 360)
heading -= 360;
geo_direct_wgs_84 ( 0, lat, lon, heading,
100,
&lat2, &lon2, &az2 );
double lat3 = (*(waypoints.end()-1))->latitude; double lat3 = (*(waypoints.end()-1))->latitude;
double lon3 = (*(waypoints.end()-1))->longitude; double lon3 = (*(waypoints.end()-1))->longitude;
cerr << (*(waypoints.end()-1))->name << endl; //cerr << (*(waypoints.end()-1))->name << endl;
// Find a route from runway end to parking/gate.
if (apt->getDynamics()->getGroundNetwork()->exists()) if (apt->getDynamics()->getGroundNetwork()->exists())
{ {
intVec ids; intVec ids;
int runwayId = apt->getDynamics()->getGroundNetwork()->findNearestNode(lat3, lon3); int runwayId = apt->getDynamics()->getGroundNetwork()->findNearestNode(lat3,
//int currId = apt->getGroundNetwork()->findNearestNode(latitude,longitude); lon3);
//exit(1);
// A negative gateId indicates an overflow parking, use a // A negative gateId indicates an overflow parking, use a
// fallback mechanism for this. // fallback mechanism for this.
// Starting from gate 0 is a bit of a hack... // Starting from gate 0 is a bit of a hack...
FGTaxiRoute route; FGTaxiRoute route;
if (gateId >= 0) if (gateId >= 0)
route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(runwayId, gateId); route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(runwayId,
gateId);
else else
route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(runwayId, 0); route = apt->getDynamics()->getGroundNetwork()->findShortestRoute(runwayId, 0);
intVecIterator i; intVecIterator i;
//cerr << "creating route : ";
// No route found: go from gate directly to runway // No route found: go from gate directly to runway
if (route.empty()) { if (route.empty()) {
//Add the runway startpoint; //Add the runway startpoint;
@ -415,17 +437,18 @@ void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt,
} else { } else {
int node; int node;
route.first(); route.first();
while(route.next(&node)) int size = route.size();
// Omit the last two waypoints, as
// those are created by createParking()
for (int i = 0; i < size-2; i++)
{ {
//i = ids.end()-1; route.next(&node);
//cerr << "Creating Node: " << node << endl;
FGTaxiNode *tn = apt->getDynamics()->getGroundNetwork()->findNode(node); FGTaxiNode *tn = apt->getDynamics()->getGroundNetwork()->findNode(node);
//ids.pop_back();
wpt = new waypoint; wpt = new waypoint;
wpt->name = "taxiway"; // fixme: should be the name of the taxiway wpt->name = "taxiway"; // fixme: should be the name of the taxiway
wpt->latitude = tn->getLatitude(); wpt->latitude = tn->getLatitude();
wpt->longitude = tn->getLongitude(); wpt->longitude = tn->getLongitude();
wpt->altitude = apt->getElevation(); // should maybe be tn->elev too wpt->altitude = apt->getElevation();
wpt->speed = 15; wpt->speed = 15;
wpt->crossat = -10000; wpt->crossat = -10000;
wpt->gear_down = true; wpt->gear_down = true;
@ -434,13 +457,18 @@ void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt,
wpt->on_ground = true; wpt->on_ground = true;
waypoints.push_back(wpt); waypoints.push_back(wpt);
} }
cerr << endl;
} }
//exit(1);
} }
else else
{ {
//Add the runway startpoint; // Use a fallback mechanism in case no ground network is available
// obtain the location of the gate entrance point
heading += 180.0;
if (heading > 360)
heading -= 360;
geo_direct_wgs_84 ( 0, lat, lon, heading,
100,
&lat2, &lon2, &az2 );
wpt = new waypoint; wpt = new waypoint;
wpt->name = "Airport Center"; wpt->name = "Airport Center";
wpt->latitude = apt->getLatitude(); wpt->latitude = apt->getLatitude();
@ -453,32 +481,44 @@ void FGAIFlightPlan::createTaxi(bool firstFlight, int direction, FGAirport *apt,
wpt->finished = false; wpt->finished = false;
wpt->on_ground = true; wpt->on_ground = true;
waypoints.push_back(wpt); waypoints.push_back(wpt);
wpt = new waypoint;
wpt->name = "Begin Parking"; //apt->getId(); //wpt_node->getStringValue("name", "END");
wpt->latitude = lat2;
wpt->longitude = lon2;
wpt->altitude = apt->getElevation();
wpt->speed = 15;
wpt->crossat = -10000;
wpt->gear_down = true;
wpt->flaps_down= true;
wpt->finished = false;
wpt->on_ground = true;
waypoints.push_back(wpt);
//waypoint* wpt;
//double lat;
//double lon;
//double heading;
apt->getDynamics()->getParking(gateId, &lat, &lon, &heading);
heading += 180.0;
if (heading > 360)
heading -= 360;
wpt = new waypoint;
wpt->name = "END"; //wpt_node->getStringValue("name", "END");
wpt->latitude = lat;
wpt->longitude = lon;
wpt->altitude = 19;
wpt->speed = 15;
wpt->crossat = -10000;
wpt->gear_down = true;
wpt->flaps_down= true;
wpt->finished = false;
wpt->on_ground = true;
waypoints.push_back(wpt);
} }
// Add the final destination waypoint
wpt = new waypoint;
wpt->name = "Begin Parking"; //apt->getId(); //wpt_node->getStringValue("name", "END");
wpt->latitude = lat2;
wpt->longitude = lon2;
wpt->altitude = apt->getElevation();
wpt->speed = 15;
wpt->crossat = -10000;
wpt->gear_down = true;
wpt->flaps_down= true;
wpt->finished = false;
wpt->on_ground = true;
waypoints.push_back(wpt);
} }
// wpt_iterator = waypoints.begin();
//if (!firstFlight)
// wpt_iterator++;
//wpt_iterator = waypoints.begin()+currWpt;
} }
/******************************************************************* /*******************************************************************
@ -490,23 +530,10 @@ void FGAIFlightPlan::createTakeOff(bool firstFlight, FGAirport *apt, double spee
double wind_speed; double wind_speed;
double wind_heading; double wind_heading;
double heading; double heading;
//FGRunway rwy;
double lat, lon, az; double lat, lon, az;
double lat2, lon2, az2; double lat2, lon2, az2;
//int direction;
waypoint *wpt; waypoint *wpt;
// Erase all existing waypoints.
// wpt_vector_iterator i= waypoints.begin();
//while(waypoints.begin() != waypoints.end())
// {
// delete *(i);
// waypoints.erase(i);
// }
//resetWaypoints();
// Get the current active runway, based on code from David Luff // Get the current active runway, based on code from David Luff
// This should actually be unified and extended to include // This should actually be unified and extended to include
// Preferential runway use schema's // Preferential runway use schema's
@ -521,15 +548,12 @@ void FGAIFlightPlan::createTakeOff(bool firstFlight, FGAirport *apt, double spee
activeRunway, activeRunway,
&rwy))) &rwy)))
{ {
cout << "Failed to find runway for " << apt->getId() << endl; SG_LOG(SG_INPUT, SG_ALERT, "Failed to find runway " <<
// Hmm, how do we handle a potential error like this? activeRunway <<
" at airport " << apt->getId());
exit(1); exit(1);
} }
//string test;
//apt->getActiveRunway(string("com"), 1, test);
//exit(1);
} }
heading = rwy._heading; heading = rwy._heading;
double azimuth = heading + 180.0; double azimuth = heading + 180.0;
while ( azimuth >= 360.0 ) { azimuth -= 360.0; } while ( azimuth >= 360.0 ) { azimuth -= 360.0; }
@ -570,11 +594,6 @@ void FGAIFlightPlan::createTakeOff(bool firstFlight, FGAirport *apt, double spee
wpt->finished = false; wpt->finished = false;
wpt->on_ground = false; wpt->on_ground = false;
waypoints.push_back(wpt); waypoints.push_back(wpt);
// waypoints.push_back(wpt);
//waypoints.push_back(wpt); // add one more to prevent a segfault.
// wpt_iterator = waypoints.begin();
//if (!firstFlight)
// wpt_iterator++;
} }
/******************************************************************* /*******************************************************************
@ -592,19 +611,7 @@ void FGAIFlightPlan::createClimb(bool firstFlight, FGAirport *apt, double speed,
//int direction; //int direction;
waypoint *wpt; waypoint *wpt;
// Erase all existing waypoints.
// wpt_vector_iterator i= waypoints.begin();
//while(waypoints.begin() != waypoints.end())
// {
// delete *(i);
// waypoints.erase(i);
// }
//resetWaypoints();
// Get the current active runway, based on code from David Luff
// This should actually be unified and extended to include
// Preferential runway use schema's
if (firstFlight) if (firstFlight)
{ {
//string name; //string name;
@ -616,13 +623,11 @@ void FGAIFlightPlan::createClimb(bool firstFlight, FGAirport *apt, double speed,
activeRunway, activeRunway,
&rwy))) &rwy)))
{ {
cout << "Failed to find runway for " << apt->getId() << endl; SG_LOG(SG_INPUT, SG_ALERT, "Failed to find runway " <<
// Hmm, how do we handle a potential error like this? activeRunway <<
" at airport " << apt->getId());
exit(1); exit(1);
} }
//string test;
//apt->getActiveRunway(string("com"), 1, test);
//exit(1);
} }
@ -661,11 +666,6 @@ void FGAIFlightPlan::createClimb(bool firstFlight, FGAirport *apt, double speed,
wpt->finished = false; wpt->finished = false;
wpt->on_ground = false; wpt->on_ground = false;
waypoints.push_back(wpt); waypoints.push_back(wpt);
//waypoints.push_back(wpt);
//waypoints.push_back(wpt); // add one more to prevent a segfault.
// wpt_iterator = waypoints.begin();
//if (!firstFlight)
// wpt_iterator++;
} }
@ -673,27 +673,19 @@ void FGAIFlightPlan::createClimb(bool firstFlight, FGAirport *apt, double speed,
* CreateCruise * CreateCruise
* initialize the Aircraft at the parking location * initialize the Aircraft at the parking location
******************************************************************/ ******************************************************************/
void FGAIFlightPlan::createCruise(bool firstFlight, FGAirport *dep, FGAirport *arr, double latitude, double longitude, double speed, double alt) void FGAIFlightPlan::createCruise(bool firstFlight, FGAirport *dep,
FGAirport *arr, double latitude,
double longitude, double speed,
double alt)
{ {
double wind_speed; double wind_speed;
double wind_heading; double wind_heading;
double heading; double heading;
//FGRunway rwy;
double lat, lon, az; double lat, lon, az;
double lat2, lon2, az2; double lat2, lon2, az2;
double azimuth; double azimuth;
//int direction;
waypoint *wpt; waypoint *wpt;
// Erase all existing waypoints.
// wpt_vector_iterator i= waypoints.begin();
//while(waypoints.begin() != waypoints.end())
// {
// delete *(i);
// waypoints.erase(i);
// }
//resetWaypoints();
wpt = new waypoint; wpt = new waypoint;
wpt->name = "Cruise"; //wpt_node->getStringValue("name", "END"); wpt->name = "Cruise"; //wpt_node->getStringValue("name", "END");
wpt->latitude = latitude; wpt->latitude = latitude;
@ -706,42 +698,29 @@ void FGAIFlightPlan::createCruise(bool firstFlight, FGAirport *dep, FGAirport *a
wpt->finished = false; wpt->finished = false;
wpt->on_ground = false; wpt->on_ground = false;
waypoints.push_back(wpt); waypoints.push_back(wpt);
//Beginning of Decent
//string name;
// should be changed dynamically to allow "gen" and "mil" // should be changed dynamically to allow "gen" and "mil"
arr->getDynamics()->getActiveRunway("com", 2, activeRunway); arr->getDynamics()->getActiveRunway("com", 2, activeRunway);
if (!(globals->get_runways()->search(arr->getId(), if (!(globals->get_runways()->search(arr->getId(),
activeRunway, activeRunway,
&rwy))) &rwy)))
{ {
cout << "Failed to find runway for " << arr->getId() << endl; SG_LOG(SG_INPUT, SG_ALERT, "Failed to find runway " <<
// Hmm, how do we handle a potential error like this? activeRunway <<
" at airport " << arr->getId());
exit(1); exit(1);
} }
//string test;
//arr->getActiveRunway(string("com"), 1, test);
//exit(1);
//cerr << "Altitude = " << alt << endl;
//cerr << "Done" << endl;
//if (arr->getId() == "EHAM")
// {
// cerr << "Creating cruise to EHAM " << latitude << " " << longitude << endl;
// }
heading = rwy._heading; heading = rwy._heading;
azimuth = heading + 180.0; azimuth = heading + 180.0;
while ( azimuth >= 360.0 ) { azimuth -= 360.0; } while ( azimuth >= 360.0 ) { azimuth -= 360.0; }
// Note: This places us at the location of the active
// runway during initial cruise. This needs to be
// fixed later.
geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth, geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth,
110000, 110000,
&lat2, &lon2, &az2 ); &lat2, &lon2, &az2 );
wpt = new waypoint; wpt = new waypoint;
wpt->name = "BOD"; //wpt_node->getStringValue("name", "END"); wpt->name = "BOD";
wpt->latitude = lat2; wpt->latitude = lat2;
wpt->longitude = lon2; wpt->longitude = lon2;
wpt->altitude = alt; wpt->altitude = alt;
@ -752,11 +731,6 @@ void FGAIFlightPlan::createCruise(bool firstFlight, FGAirport *dep, FGAirport *a
wpt->finished = false; wpt->finished = false;
wpt->on_ground = false; wpt->on_ground = false;
waypoints.push_back(wpt); waypoints.push_back(wpt);
//waypoints.push_back(wpt);
//waypoints.push_back(wpt); // add one more to prevent a segfault.
//wpt_iterator = waypoints.begin();
//if (!firstFlight)
// wpt_iterator++;
} }
/******************************************************************* /*******************************************************************
@ -777,38 +751,23 @@ void FGAIFlightPlan::createDecent(FGAirport *apt)
//int direction; //int direction;
waypoint *wpt; waypoint *wpt;
//// Erase all existing waypoints.
// wpt_vector_iterator i= waypoints.begin();
//while(waypoints.begin() != waypoints.end())
// {
// delete *(i);
// waypoints.erase(i);
// }
//resetWaypoints();
//Beginning of Decent //Beginning of Decent
//string name; //string name;
// allow "mil" and "gen" as well // allow "mil" and "gen" as well
apt->getDynamics()->getActiveRunway("com", 2, activeRunway); apt->getDynamics()->getActiveRunway("com", 2, activeRunway);
if (!(globals->get_runways()->search(apt->getId(), if (!(globals->get_runways()->search(apt->getId(),
activeRunway, activeRunway,
&rwy))) &rwy)))
{ {
cout << "Failed to find runway for " << apt->getId() << endl; SG_LOG(SG_INPUT, SG_ALERT, "Failed to find runway " <<
// Hmm, how do we handle a potential error like this? activeRunway <<
exit(1); " at airport " << apt->getId());
} exit(1);
//string test; }
//apt->getActiveRunway(string("com"), 1, test);
//exit(1);
//cerr << "Done" << endl;
heading = rwy._heading; heading = rwy._heading;
azimuth = heading + 180.0; azimuth = heading + 180.0;
while ( azimuth >= 360.0 ) { azimuth -= 360.0; } while ( azimuth >= 360.0 ) { azimuth -= 360.0; }
geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth, geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth,
100000, 100000,
&lat2, &lon2, &az2 ); &lat2, &lon2, &az2 );
@ -825,11 +784,11 @@ void FGAIFlightPlan::createDecent(FGAirport *apt)
wpt->finished = false; wpt->finished = false;
wpt->on_ground = false; wpt->on_ground = false;
waypoints.push_back(wpt); waypoints.push_back(wpt);
// Three thousand ft. Slowing down to 160 kts // Three thousand ft. Slowing down to 160 kts
geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth, geo_direct_wgs_84 ( 0, rwy._lat, rwy._lon, azimuth,
8*SG_NM_TO_METER, 8*SG_NM_TO_METER,
&lat2, &lon2, &az2 ); &lat2, &lon2, &az2 );
wpt = new waypoint; wpt = new waypoint;
wpt->name = "DEC 3000ft"; //wpt_node->getStringValue("name", "END"); wpt->name = "DEC 3000ft"; //wpt_node->getStringValue("name", "END");
wpt->latitude = lat2; wpt->latitude = lat2;
@ -842,15 +801,6 @@ void FGAIFlightPlan::createDecent(FGAirport *apt)
wpt->finished = false; wpt->finished = false;
wpt->on_ground = false; wpt->on_ground = false;
waypoints.push_back(wpt); waypoints.push_back(wpt);
//waypoints.push_back(wpt);
//waypoints.push_back(wpt); // add one more to prevent a segfault.
//wpt_iterator = waypoints.begin();
//wpt_iterator++;
//if (apt->getId() == "EHAM")
// {
// cerr << "Created Decend to EHAM " << lat2 << " " << lon2 << ": Runway = " << rwy._rwy_no
// << "heading " << heading << endl;
// }
} }
/******************************************************************* /*******************************************************************
* CreateLanding * CreateLanding
@ -858,7 +808,7 @@ void FGAIFlightPlan::createDecent(FGAirport *apt)
******************************************************************/ ******************************************************************/
void FGAIFlightPlan::createLanding(FGAirport *apt) void FGAIFlightPlan::createLanding(FGAirport *apt)
{ {
// Ten thousand ft. Slowing down to 240 kts // Ten thousand ft. Slowing down to 150 kts
double wind_speed; double wind_speed;
double wind_heading; double wind_heading;
double heading; double heading;
@ -923,47 +873,59 @@ void FGAIFlightPlan::createLanding(FGAirport *apt)
wpt->finished = false; wpt->finished = false;
wpt->on_ground = true; wpt->on_ground = true;
waypoints.push_back(wpt); waypoints.push_back(wpt);
//waypoints.push_back(wpt);
//waypoints.push_back(wpt); // add one more to prevent a segfault.
//wpt_iterator = waypoints.begin();
//wpt_iterator++;
//if (apt->getId() == "EHAM")
//{
// cerr << "Created Landing to EHAM " << lat2 << " " << lon2 << ": Runway = " << rwy._rwy_no
// << "heading " << heading << endl;
//}
} }
/******************************************************************* /*******************************************************************
* CreateParking * CreateParking
* initialize the Aircraft at the parking location * initialize the Aircraft at the parking location
******************************************************************/ ******************************************************************/
void FGAIFlightPlan::createParking(FGAirport *apt) void FGAIFlightPlan::createParking(FGAirport *apt, double radius)
{ {
waypoint* wpt; waypoint* wpt;
double lat; double lat, lat2;
double lon; double lon, lon2;
double az2;
double heading; double heading;
apt->getDynamics()->getParking(gateId, &lat, &lon, &heading); apt->getDynamics()->getParking(gateId, &lat, &lon, &heading);
heading += 180.0; heading += 180.0;
if (heading > 360) if (heading > 360)
heading -= 360; heading -= 360;
geo_direct_wgs_84 ( 0, lat, lon, heading,
2.2*radius,
&lat2, &lon2, &az2 );
wpt = new waypoint;
wpt->name = "taxiStart";
wpt->latitude = lat2;
wpt->longitude = lon2;
wpt->altitude = apt->getElevation();
wpt->speed = 10;
wpt->crossat = -10000;
wpt->gear_down = true;
wpt->flaps_down= true;
wpt->finished = false;
wpt->on_ground = true;
waypoints.push_back(wpt);
geo_direct_wgs_84 ( 0, lat, lon, heading,
0.1 *radius,
&lat2, &lon2, &az2 );
wpt = new waypoint;
wpt->name = "taxiStart";
wpt->latitude = lat2;
wpt->longitude = lon2;
wpt->altitude = apt->getElevation();
wpt->speed = 10;
wpt->crossat = -10000;
wpt->gear_down = true;
wpt->flaps_down= true;
wpt->finished = false;
wpt->on_ground = true;
waypoints.push_back(wpt);
// Erase all existing waypoints.
// wpt_vector_iterator i= waypoints.begin();
//while(waypoints.begin() != waypoints.end())
// {
// delete *(i);
// waypoints.erase(i);
// }
//resetWaypoints();
// And finally one more named "END"
wpt = new waypoint; wpt = new waypoint;
wpt->name = "END"; //wpt_node->getStringValue("name", "END"); wpt->name = "END"; //wpt_node->getStringValue("name", "END");
wpt->latitude = lat; wpt->latitude = lat;
wpt->longitude = lon; wpt->longitude = lon;
wpt->altitude = 19; wpt->altitude = apt->getElevation();
wpt->speed = 15; wpt->speed = 15;
wpt->crossat = -10000; wpt->crossat = -10000;
wpt->gear_down = true; wpt->gear_down = true;
@ -971,8 +933,4 @@ void FGAIFlightPlan::createParking(FGAirport *apt)
wpt->finished = false; wpt->finished = false;
wpt->on_ground = true; wpt->on_ground = true;
waypoints.push_back(wpt); waypoints.push_back(wpt);
//waypoints.push_back(wpt);
//waypoints.push_back(wpt); // add one more to prevent a segfault.
//wpt_iterator = waypoints.begin();
//wpt_iterator++;
} }

2
src/Airports/dynamics.cxx
View file

@ -297,7 +297,7 @@ void FGAirportDynamics::getParking (int id, double *lat, double* lon, double *he
{ {
*lat = i->getLatitude(); *lat = i->getLatitude();
*lon = i->getLongitude(); *lon = i->getLongitude();
*heading = i->getLongitude(); *heading = i->getHeading();
} }
} }
} }

1
src/Airports/groundnetwork.hxx
View file

@ -124,6 +124,7 @@ public:
bool next(int *val); bool next(int *val);
void first() { currNode = nodes.begin(); }; void first() { currNode = nodes.begin(); };
int size() { return nodes.end() - nodes.begin(); };
}; };
typedef vector<FGTaxiRoute> TaxiRouteVector; typedef vector<FGTaxiRoute> TaxiRouteVector;