X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FAirports%2Fsimple.hxx;h=db5c738a45b227055433e09988d712f908d1ed77;hb=e16f772e54216b0088ca9cb3f3b0fb062be8bfdb;hp=7d3372ecbea3bda853f5f3bba14f94a72d411b7f;hpb=86e94fd08e30834abf819eed66debb6e6f185040;p=flightgear.git diff --git a/src/Airports/simple.hxx b/src/Airports/simple.hxx index 7d3372ecb..db5c738a4 100644 --- a/src/Airports/simple.hxx +++ b/src/Airports/simple.hxx @@ -1,10 +1,11 @@ // simple.hxx -- a really simplistic class to manage airport ID, -// lat, lon of the center of one of it's runways, and +// lat, lon of the center of one of it's runways, and // elevation in feet. // // Written by Curtis Olson, started April 1998. +// Updated by Durk Talsma, started December 2004. // -// Copyright (C) 1998 Curtis L. Olson - curt@me.umn.edu +// Copyright (C) 1998 Curtis L. Olson - http://www.flightgear.org/~curt // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License as @@ -18,7 +19,7 @@ // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software -// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // $Id$ @@ -26,92 +27,261 @@ #ifndef _FG_SIMPLE_HXX #define _FG_SIMPLE_HXX - -#ifndef __cplusplus -# error This library requires C++ -#endif - - -#ifdef HAVE_CONFIG_H -# include -#endif - #include -#include STL_STRING -#include +#include #include -SG_USING_STD(string); -SG_USING_STD(map); -SG_USING_STD(vector); +#include +// forward decls +class FGAirportDynamics; +class FGRunway; +class FGTaxiway; +class FGPavement; +class SGPropertyNode; -struct FGAirport { +typedef SGSharedPtr FGRunwayPtr; +typedef SGSharedPtr FGTaxiwayPtr; +typedef SGSharedPtr FGPavementPtr; - string id; - double longitude; - double latitude; - double elevation; - string code; - string name; - bool has_metar; -}; - -typedef map < string, FGAirport > airport_map; -typedef airport_map::iterator airport_map_iterator; -typedef airport_map::const_iterator const_airport_map_iterator; +namespace flightgear { + class SID; + class STAR; + class Approach; + class Waypt; -typedef vector < FGAirport * > airport_list; + typedef SGSharedPtr WayptRef; + typedef std::vector WayptVec; +} -class FGAirportList { - -private: - airport_map airports_by_id; - airport_list airports_array; +/*************************************************************************************** + * + **************************************************************************************/ +class FGAirport : public FGPositioned +{ public: - - // Constructor - FGAirportList( const string& file ); - - // Destructor - ~FGAirportList(); - - // search for the specified id. - // Returns true if successful, otherwise returns false. - // On success, airport data is returned thru "airport" pointer. - // "airport" is not changed if "apt" is not found. - FGAirport search( const string& id ); - - // search for the airport closest to the specified position - // (currently a linear inefficient search so it's probably not - // best to use this at runtime.) If with_metar is true, then only - // return station id's marked as having metar data. - FGAirport search( double lon_deg, double lat_deg, bool with_metar ); - - + FGAirport(const std::string& id, const SGGeod& location, const SGGeod& tower, + const std::string& name, bool has_metar, Type aType); + ~FGAirport(); + + const std::string& getId() const { return ident(); } + const std::string& getName() const { return _name; } + double getLongitude() const { return longitude(); } + // Returns degrees + double getLatitude() const { return latitude(); } + // Returns ft + double getElevation() const { return elevation(); } + bool getMetar() const { return _has_metar; } + bool isAirport() const; + bool isSeaport() const; + bool isHeliport() const; + + virtual const std::string& name() const + { return _name; } + + const SGGeod& getTowerLocation() const { return _tower_location; } + + void setMetar(bool value) { _has_metar = value; } + + FGRunway* getActiveRunwayForUsage() const; + + FGAirportDynamics *getDynamics(); + + unsigned int numRunways() const; + FGRunway* getRunwayByIndex(unsigned int aIndex) const; + + bool hasRunwayWithIdent(const std::string& aIdent) const; + FGRunway* getRunwayByIdent(const std::string& aIdent) const; + FGRunway* findBestRunwayForHeading(double aHeading) const; + /** - * Return the number of airports in the list. + * 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. */ - int size() const; - - + 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& rwys, + std::vector& txwys, + std::vector& pvts); + + class AirportFilter : public Filter + { + public: + virtual bool pass(FGPositioned* aPos) const { + return passAirport(static_cast(aPos)); + } + + virtual Type minType() const { + return AIRPORT; + } + + virtual Type maxType() const { + return AIRPORT; + } + + virtual bool passAirport(FGAirport* aApt) const { + return true; + } + }; + + /** + * 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 passAirport(FGAirport* aApt) const; + + private: + double mMinLengthFt; + }; + + + void setProcedures(const std::vector& aSids, + const std::vector& aStars, + const std::vector& 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 airports, but not seaports or heliports + */ + static FGAirport* findClosest(const SGGeod& aPos, double aCuttofNm, Filter* filter = NULL); + + /** + * Helper to look up an FGAirport instance by unique ident. Throws an + * exception if the airport could not be found - so callers can assume + * the result is non-NULL. + */ + static FGAirport* getByIdent(const std::string& aIdent); + + /** + * Helper to look up an FGAirport instance by unique ident. Returns NULL + * if the airport could not be found. + */ + static FGAirport* findByIdent(const std::string& aIdent); + + /** + * Specialised helper to implement the AirportList dialog. Performs a + * case-insensitive search on airport names and ICAO codes, and returns + * 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); + /** - * Return a specific airport, by position. + * 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. */ - const FGAirport *getAirport( int index ) const; - - + std::pair 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 selectSTAR(const SGGeod& aOrigin, FGRunway* aRwy); + +private: + typedef std::vector::const_iterator Runway_iterator; /** - * Mark the specified airport record as not having metar + * Helper to locate a runway by ident */ - void no_metar( const string &id ); + 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 mRunways; + std::vector mTaxiways; + std::vector mPavements; + + std::vector mSIDs; + std::vector mSTARs; + std::vector mApproaches; }; +// find basic airport location info from airport database +const FGAirport *fgFindAirportID( const std::string& id); + +// get airport elevation +double fgGetAirportElev( const std::string& id ); #endif // _FG_SIMPLE_HXX