X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FAirports%2Fsimple.hxx;h=db5c738a45b227055433e09988d712f908d1ed77;hb=e16f772e54216b0088ca9cb3f3b0fb062be8bfdb;hp=0a25f8d46249acf29132f1c3462d558719da9a0b;hpb=030742fa4ae7d99facb517381da71fa404c4ee2b;p=flightgear.git

diff --git a/src/Airports/simple.hxx b/src/Airports/simple.hxx
index 0a25f8d46..db5c738a4 100644
--- a/src/Airports/simple.hxx
+++ b/src/Airports/simple.hxx
@@ -32,27 +32,37 @@
 #include <string>
 #include <vector>
 
-#include "Navaids/positioned.hxx"
+#include <Navaids/positioned.hxx>
 
 // forward decls
 class FGAirportDynamics;
 class FGRunway;
 class FGTaxiway;
+class FGPavement;
+class SGPropertyNode;
 
 typedef SGSharedPtr<FGRunway> FGRunwayPtr;
 typedef SGSharedPtr<FGTaxiway> FGTaxiwayPtr;
+typedef SGSharedPtr<FGPavement> FGPavementPtr;
+
+namespace flightgear {
+  class SID;
+  class STAR;
+  class Approach;
+  class Waypt;
+
+
+  typedef SGSharedPtr<Waypt> WayptRef;
+  typedef std::vector<WayptRef> WayptVec;
+}
+
+
 
 /***************************************************************************************
  *
  **************************************************************************************/
 class FGAirport : public FGPositioned
 {
-private:
-    SGGeod _tower_location;
-    std::string _name;
-    bool _has_metar;
-    FGAirportDynamics *_dynamics;
-
 public:
     FGAirport(const std::string& id, const SGGeod& location, const SGGeod& tower, 
             const std::string& name, bool has_metar, Type aType);
@@ -88,41 +98,97 @@ public:
     FGRunway* getRunwayByIdent(const std::string& aIdent) const;
     FGRunway* findBestRunwayForHeading(double aHeading) const;
     
+    /**
+     * return the most likely target runway based on a position.
+     * Specifically, return the runway for which the course from aPos
+     * to the runway end, mostly closely matches the runway heading.
+     * This is a good approximation of which runway the position is on or
+     * aiming towards.
+     */
+    FGRunway* findBestRunwayForPos(const SGGeod& aPos) const;
+    
      /**
      * Useful predicate for FMS/GPS/NAV displays and similar - check if this
      * aiport has a hard-surfaced runway of at least the specified length.
      */
     bool hasHardRunwayOfLengthFt(double aLengthFt) const;
-    
+
     unsigned int numTaxiways() const;
     FGTaxiway* getTaxiwayByIndex(unsigned int aIndex) const;
-    
+
+    unsigned int numPavements() const;
+    FGPavement* getPavementByIndex(unsigned int aIndex) const;
+
     void setRunwaysAndTaxiways(std::vector<FGRunwayPtr>& rwys,
-      std::vector<FGTaxiwayPtr>& txwys);
+      std::vector<FGTaxiwayPtr>& txwys,
+      std::vector<FGPavementPtr>& pvts);
     
     class AirportFilter : public Filter
      {
      public:
        virtual bool pass(FGPositioned* aPos) const { 
-         Type ty(aPos->type());
-         return (ty >= AIRPORT) && (ty <= SEAPORT);
+         return passAirport(static_cast<FGAirport*>(aPos));
+       }
+       
+       virtual Type minType() const {
+         return AIRPORT;
+       }
+       
+       virtual Type maxType() const {
+         return AIRPORT;
+       }
+       
+       virtual bool passAirport(FGAirport* aApt) const {
+         return true;
        }
      };
      
-     class HardSurfaceFilter : public Filter
+     /**
+      * Filter which passes heliports and seaports in addition to airports
+      */
+     class PortsFilter : public AirportFilter
+     {
+     public:
+       virtual Type maxType() const {
+         return SEAPORT;
+       }
+     };
+     
+     class HardSurfaceFilter : public AirportFilter
      {
      public:
        HardSurfaceFilter(double minLengthFt);
        
-       virtual bool pass(FGPositioned* aPos) const;
+       virtual bool passAirport(FGAirport* aApt) const;
+       
      private:
        double mMinLengthFt;
      };
      
+     
+     void setProcedures(const std::vector<flightgear::SID*>& aSids,
+      const std::vector<flightgear::STAR*>& aStars,
+      const std::vector<flightgear::Approach*>& aApproaches);
+     
+     void addSID(flightgear::SID* aSid);
+      void addSTAR(flightgear::STAR* aStar);
+      void addApproach(flightgear::Approach* aApp);
+
+      unsigned int numSIDs() const;
+      flightgear::SID* getSIDByIndex(unsigned int aIndex) const;
+      flightgear::SID* findSIDWithIdent(const std::string& aIdent) const;
+      
+      unsigned int numSTARs() const;
+      flightgear::STAR* getSTARByIndex(unsigned int aIndex) const;
+      flightgear::STAR* findSTARWithIdent(const std::string& aIdent) const;
+      
+      unsigned int numApproaches() const;
+      flightgear::Approach* getApproachByIndex(unsigned int aIndex) const;
+
      /**
       * Syntactic wrapper around FGPositioned::findClosest - find the closest
       * match for filter, and return it cast to FGAirport. The default filter
-      * passes all airports, including seaports and heliports.
+      * passes airports, but not seaports or heliports
       */
      static FGAirport* findClosest(const SGGeod& aPos, double aCuttofNm, Filter* filter = NULL);
      
@@ -145,6 +211,23 @@ public:
       * matches in a format suitable for use by a puaList. 
       */
      static char** searchNamesAndIdents(const std::string& aFilter);
+     
+     bool buildApproach(flightgear::Waypt* aEnroute, flightgear::STAR* aSTAR, 
+      FGRunway* aRwy, flightgear::WayptVec& aRoute);
+    
+    /**
+     * Given a destiation point, select the best SID and transition waypt from 
+     * this airport. Returns (NULL,NULL) is no SIDs are defined, otherwise the
+     * best SID/transition is that which is closest to the destination point.
+     */
+    std::pair<flightgear::SID*, flightgear::WayptRef> selectSID(const SGGeod& aDest, FGRunway* aRwy);
+    
+    /**
+     * Select a STAR and enroute transition waypt, given an origin (departure) position.
+     * returns (NULL, NULL) is no suitable STAR is exists
+     */
+    std::pair<flightgear::STAR*, flightgear::WayptRef> selectSTAR(const SGGeod& aOrigin, FGRunway* aRwy);
+    
 private:
     typedef std::vector<FGRunwayPtr>::const_iterator Runway_iterator;
     /**
@@ -152,11 +235,46 @@ private:
      */
     Runway_iterator getIteratorForRunwayIdent(const std::string& aIdent) const;
 
+    // disable these
     FGAirport operator=(FGAirport &other);
     FGAirport(const FGAirport&);
+  
+    /**
+     * helper to read airport data from the scenery XML files.
+     */
+    void loadSceneryDefinitions() const;
+    
+    /**
+     * Helpers to process property data loaded from an ICAO.threshold.xml file
+     */
+    void readThresholdData(SGPropertyNode* aRoot);
+    void processThreshold(SGPropertyNode* aThreshold);
+    
+    /**
+     * Helper to parse property data loaded from an ICAO.twr.xml filke
+     */
+    void readTowerData(SGPropertyNode* aRoot);
+    
+    SGGeod _tower_location;
+    std::string _name;
+    bool _has_metar;
+    FGAirportDynamics *_dynamics;
+
+    void loadRunways() const;
+    void loadTaxiways() const;
+    void loadProcedures() const;
+    
+    mutable bool mRunwaysLoaded;
+    mutable bool mTaxiwaysLoaded;
+    mutable bool mProceduresLoaded;
     
     std::vector<FGRunwayPtr> mRunways;
     std::vector<FGTaxiwayPtr> mTaxiways;
+    std::vector<FGPavementPtr> mPavements;
+    
+    std::vector<flightgear::SID*> mSIDs;
+    std::vector<flightgear::STAR*> mSTARs;
+    std::vector<flightgear::Approach*> mApproaches;
 };
 
 // find basic airport location info from airport database