X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;ds=sidebyside;f=src%2FAirports%2Fsimple.cxx;h=e7b9a48d88344448732bfdc53c8e55b932ab1f0d;hb=82bfb6a08de380a445b7a7b2f27409731d30bd8b;hp=7813d38d22e36745d9811a002c02d4e0559724de;hpb=33037b21394792559332b18d1451ae21a44d090a;p=flightgear.git

diff --git a/src/Airports/simple.cxx b/src/Airports/simple.cxx
index 7813d38d2..e7b9a48d8 100644
--- a/src/Airports/simple.cxx
+++ b/src/Airports/simple.cxx
@@ -33,26 +33,24 @@
 
 #include <simgear/compiler.h>
 
-#include <plib/sg.h>
-#include <plib/ul.h>
-
 #include <Environment/environment_mgr.hxx>
 #include <Environment/environment.hxx>
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/props/props.hxx>
 #include <simgear/structure/subsystem_mgr.hxx>
-//#include <simgear/route/waypoint.hxx>
 #include <simgear/debug/logstream.hxx>
 #include <Main/globals.hxx>
 #include <Main/fg_props.hxx>
 #include <Airports/runways.hxx>
+#include <Airports/dynamics.hxx>
 
-#include STL_STRING
+#include <string>
 
 #include "simple.hxx"
+#include "xmlloader.hxx"
 
-SG_USING_STD(sort);
-SG_USING_STD(random_shuffle);
+using std::sort;
+using std::random_shuffle;
 
 
 
@@ -60,81 +58,226 @@ SG_USING_STD(random_shuffle);
 /***************************************************************************
  * FGAirport
  ***************************************************************************/
-FGAirport::FGAirport() : _longitude(0), _latitude(0), _elevation(0)
+
+FGAirport::FGAirport(const string &id, const SGGeod& location, const SGGeod& tower_location,
+        const string &name, bool has_metar, Type aType) :
+    FGPositioned(aType, id, location),
+    _tower_location(tower_location),
+    _name(name),
+    _has_metar(has_metar),
+    _dynamics(0)
 {
-    dynamics = 0;
 }
 
 
-FGAirport::FGAirport(const string &id, double lon, double lat, double elev, const string &name, bool has_metar)
+FGAirport::~FGAirport()
 {
-    _id = id;
-    _longitude = lon;
-    _latitude  = lat;
-    _elevation = elev;
-    _name      = name;
-    _has_metar = has_metar;
-    dynamics   = 0;
+    delete _dynamics;
 }
 
+bool FGAirport::isAirport() const
+{
+  return type() == AIRPORT;
+}
 
-FGAirport::~FGAirport()
+bool FGAirport::isSeaport() const
 {
-    delete dynamics;
+  return type() == SEAPORT;
 }
 
+bool FGAirport::isHeliport() const
+{
+  return type() == HELIPORT;
+}
 
 FGAirportDynamics * FGAirport::getDynamics()
 {
-    if (dynamics != 0) {
-        return dynamics;
+    if (_dynamics != 0) {
+        return _dynamics;
     } else {
-        FGRunwayPreference rwyPrefs;
         //cerr << "Trying to load dynamics for " << _id << endl;
-        dynamics = new FGAirportDynamics(_latitude, _longitude, _elevation, _id);
-
-        SGPath parkpath( globals->get_fg_root() );
-        parkpath.append( "/Airports/AI/" );
-        parkpath.append(_id);
-        parkpath.append("parking.xml");
-
-        SGPath rwyPrefPath( globals->get_fg_root() );
-        rwyPrefPath.append( "/Airports/AI/" );
-        rwyPrefPath.append(_id);
-        rwyPrefPath.append("rwyuse.xml");
-
-        //if (ai_dirs.find(id.c_str()) != ai_dirs.end()
-        //  && parkpath.exists())
-        if (parkpath.exists()) {
-            try {
-                readXML(parkpath.str(),*dynamics);
-		//cerr << "Initializing " << getId() << endl;
-                dynamics->init();
-		dynamics->getGroundNetwork()->setParent(this);
-            } catch (const sg_exception &e) {
-                //cerr << "unable to read " << parkpath.str() << endl;
-            }
-        }
+        _dynamics = new FGAirportDynamics(this);
+        XMLLoader::load(_dynamics);
+
+        FGRunwayPreference rwyPrefs(this);
+        XMLLoader::load(&rwyPrefs);
+        _dynamics->setRwyUse(rwyPrefs);
+   }
+    return _dynamics;
+}
 
-        //if (ai_dirs.find(id.c_str()) != ai_dirs.end()
-        //  && rwyPrefPath.exists())
-        if (rwyPrefPath.exists()) {
-            try {
-                readXML(rwyPrefPath.str(), rwyPrefs);
-                dynamics->setRwyUse(rwyPrefs);
-            } catch (const sg_exception &e) {
-                //cerr << "unable to read " << rwyPrefPath.str() << endl;
-                //exit(1);
-            }
-        }
-        //exit(1);
+unsigned int FGAirport::numRunways() const
+{
+  return mRunways.size();
+}
+
+FGRunway* FGAirport::getRunwayByIndex(unsigned int aIndex) const
+{
+  assert(aIndex >= 0 && aIndex < mRunways.size());
+  return mRunways[aIndex];
+}
+
+bool FGAirport::hasRunwayWithIdent(const string& aIdent) const
+{
+  return (getIteratorForRunwayIdent(aIdent) != mRunways.end());
+}
+
+FGRunway* FGAirport::getRunwayByIdent(const string& aIdent) const
+{
+  Runway_iterator it = getIteratorForRunwayIdent(aIdent);
+  if (it == mRunways.end()) {
+    SG_LOG(SG_GENERAL, SG_ALERT, "no such runway '" << aIdent << "' at airport " << ident());
+    throw sg_range_exception("unknown runway " + aIdent + " at airport:" + ident(), "FGAirport::getRunwayByIdent");
+  }
+  
+  return *it;
+}
+
+FGAirport::Runway_iterator
+FGAirport::getIteratorForRunwayIdent(const string& aIdent) const
+{
+  string ident(aIdent);
+  if ((aIdent.size() == 1) || !isdigit(aIdent[1])) {
+    ident = "0" + aIdent;
+  }
+
+  Runway_iterator it = mRunways.begin();
+  for (; it != mRunways.end(); ++it) {
+    if ((*it)->ident() == ident) {
+      return it;
     }
-    return dynamics;
+  }
+
+  return it; // end()
 }
 
+static double normaliseBearing(double aBearing)
+{
+  while (aBearing < -180) {
+    aBearing += 360.0;
+  }
+  
+  while (aBearing > 180.0) {
+    aBearing -= 360.0;
+  }
+  
+  return aBearing;
+}
 
+FGRunway* FGAirport::findBestRunwayForHeading(double aHeading) const
+{
+  Runway_iterator it = mRunways.begin();
+  FGRunway* result = NULL;
+  double currentBestQuality = 0.0;
+  
+  SGPropertyNode *param = fgGetNode("/sim/airport/runways/search", true);
+  double lengthWeight = param->getDoubleValue("length-weight", 0.01);
+  double widthWeight = param->getDoubleValue("width-weight", 0.01);
+  double surfaceWeight = param->getDoubleValue("surface-weight", 10);
+  double deviationWeight = param->getDoubleValue("deviation-weight", 1);
+    
+  for (; it != mRunways.end(); ++it) {
+    double good = (*it)->score(lengthWeight, widthWeight, surfaceWeight);
+    
+    double dev = normaliseBearing(aHeading - (*it)->headingDeg());
+    double bad = fabs(deviationWeight * dev) + 1e-20;
+    double quality = good / bad;
+    
+    if (quality > currentBestQuality) {
+      currentBestQuality = quality;
+      result = *it;
+    }
+  }
 
+  return result;
+}
 
+bool FGAirport::hasHardRunwayOfLengthFt(double aLengthFt) const
+{
+  unsigned int numRunways(mRunways.size());
+  for (unsigned int r=0; r<numRunways; ++r) {
+    FGRunway* rwy = mRunways[r];
+    if (rwy->isReciprocal()) {
+      continue; // we only care about lengths, so don't do work twice
+    }
+
+    if (rwy->isHardSurface() && (rwy->lengthFt() >= aLengthFt)) {
+      return true; // we're done!
+    }
+  } // of runways iteration
+
+  return false;
+}
+
+unsigned int FGAirport::numTaxiways() const
+{
+  return mTaxiways.size();
+}
+
+FGRunway* FGAirport::getTaxiwayByIndex(unsigned int aIndex) const
+{
+  assert(aIndex >= 0 && aIndex < mTaxiways.size());
+  return mTaxiways[aIndex];
+}
+
+void FGAirport::addRunway(FGRunway* aRunway)
+{
+  aRunway->setAirport(this);
+  
+  if (aRunway->isTaxiway()) {
+    mTaxiways.push_back(aRunway);
+  } else {
+    mRunways.push_back(aRunway);
+  }
+}
+
+FGRunway* FGAirport::getActiveRunwayForUsage() const
+{
+  static FGEnvironmentMgr* envMgr = NULL;
+  if (!envMgr) {
+    envMgr = (FGEnvironmentMgr *) globals->get_subsystem("environment");
+  }
+  
+  FGEnvironment stationWeather(envMgr->getEnvironment(mPosition));
+  
+  double windSpeed = stationWeather.get_wind_speed_kt();
+  double hdg = stationWeather.get_wind_from_heading_deg();
+  if (windSpeed <= 0.0) {
+    hdg = 270;	// This forces West-facing rwys to be used in no-wind situations
+    // which is consistent with Flightgear's initial setup.
+  }
+  
+  return findBestRunwayForHeading(hdg);
+}
+
+FGAirport* FGAirport::findClosest(const SGGeod& aPos, double aCuttofNm, Filter* filter)
+{
+  AirportFilter aptFilter;
+  if (filter == NULL) {
+    filter = &aptFilter;
+  }
+  
+  FGPositionedRef r = FGPositioned::findClosest(aPos, aCuttofNm, filter);
+  if (!r) {
+    return NULL;
+  }
+  
+  return static_cast<FGAirport*>(r.ptr());
+}
+
+FGAirport::HardSurfaceFilter::HardSurfaceFilter(double minLengthFt) :
+  mMinLengthFt(minLengthFt)
+{
+}
+      
+bool FGAirport::HardSurfaceFilter::pass(FGPositioned* aPos) const
+{
+  if (aPos->type() != AIRPORT) {
+    return false; // exclude seaports and heliports as well, we need a runways
+  }
+   
+  return static_cast<FGAirport*>(aPos)->hasHardRunwayOfLengthFt(mMinLengthFt);
+}
 
 /******************************************************************************
  * FGAirportList
@@ -174,22 +317,17 @@ FGAirportList::~FGAirportList( void )
 
 
 // add an entry to the list
-void FGAirportList::add( const string &id, const double longitude,
-                         const double latitude, const double elevation,
-                         const string &name, const bool has_metar )
+FGAirport* FGAirportList::add( const string &id, const SGGeod& location, const SGGeod& tower_location,
+                         const string &name, bool has_metar, FGPositioned::Type aType)
 {
-    FGRunwayPreference rwyPrefs;
-    FGAirport* a = new FGAirport(id, longitude, latitude, elevation, name, has_metar);
-
+    FGAirport* a = new FGAirport(id, location, tower_location, name, has_metar, aType);
     airports_by_id[a->getId()] = a;
     // try and read in an auxilary file
 
     airports_array.push_back( a );
-    SG_LOG( SG_GENERAL, SG_BULK, "Adding " << id << " pos = " << longitude
-            << ", " << latitude << " elev = " << elevation );
+    return a;
 }
 
-
 // search for the specified id
 FGAirport* FGAirportList::search( const string& id)
 {
@@ -197,47 +335,6 @@ FGAirport* FGAirportList::search( const string& id)
     return (itr == airports_by_id.end() ? NULL : itr->second);
 }
 
-
-// search for first subsequent alphabetically to supplied id
-const FGAirport* FGAirportList::findFirstById( const string& id, bool exact )
-{
-    airport_map_iterator itr;
-    if (exact) {
-        itr = airports_by_id.find(id);
-    } else {
-        itr = airports_by_id.lower_bound(id);
-    }
-    if (itr == airports_by_id.end()) {
-        return (NULL);
-    } else {
-        return (itr->second);
-    }
-}
-
-
-// search for the airport nearest the specified position
-FGAirport* FGAirportList::search( double lon_deg, double lat_deg,
-                                  bool with_metar )
-{
-    int closest = -1;
-    double min_dist = 360.0;
-    unsigned int i;
-    for ( i = 0; i < airports_array.size(); ++i ) {
-        // crude manhatten distance based on lat/lon difference
-        double d = fabs(lon_deg - airports_array[i]->getLongitude())
-            + fabs(lat_deg - airports_array[i]->getLatitude());
-        if ( d < min_dist ) {
-            if ( !with_metar || (with_metar&&airports_array[i]->getMetar()) ) {
-                closest = i;
-                min_dist = d;
-            }
-        }
-    }
-
-    return ( closest > -1 ? airports_array[closest] : NULL );
-}
-
-
 int
 FGAirportList::size () const
 {
@@ -254,29 +351,6 @@ const FGAirport *FGAirportList::getAirport( unsigned int index ) const
     }
 }
 
-
-/**
- * Mark the specified airport record as not having metar
- */
-void FGAirportList::no_metar( const string &id )
-{
-    if(airports_by_id.find(id) != airports_by_id.end()) {
-        airports_by_id[id]->setMetar(false);
-    }
-}
-
-
-/**
- * Mark the specified airport record as (yes) having metar
- */
-void FGAirportList::has_metar( const string &id )
-{
-    if(airports_by_id.find(id) != airports_by_id.end()) {
-        airports_by_id[id]->setMetar(true);
-    }
-}
-
-
 // find basic airport location info from airport database
 const FGAirport *fgFindAirportID( const string& id)
 {