src/Navaids/positioned.hxx

   1 // positioned.hxx - base class for objects which are positioned
   2 //
   3 // Copyright (C) 2008 James Turner
   4 //
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License as
   7 // published by the Free Software Foundation; either version 2 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful, but
  11 // WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 //
  19 // $Id$
  20
  21 #ifndef FG_POSITIONED_HXX
  22 #define FG_POSITIONED_HXX
  23
  24 #include <cassert>
  25 #include <string>
  26 #include <vector>
  27 #include <stdint.h>
  28
  29 #include <simgear/sg_inlines.h>
  30 #include <simgear/structure/SGSharedPtr.hxx>
  31 #include <simgear/math/SGMath.hxx>
  32
  33 class FGPositioned;
  34 typedef SGSharedPtr<FGPositioned> FGPositionedRef;
  35
  36 typedef int64_t PositionedID;
  37 typedef std::vector<PositionedID> PositionedIDVec;
  38
  39 namespace flightgear { class NavDataCache; }
  40
  41 class FGPositioned : public SGReferenced
  42 {
  43 public:
  44
  45   typedef enum {
  46     INVALID = 0,
  47     AIRPORT,
  48     HELIPORT,
  49     SEAPORT,
  50     RUNWAY,
  51     HELIPAD,
  52     TAXIWAY,
  53     PAVEMENT,
  54     WAYPOINT,
  55     FIX,
  56     NDB,
  57     VOR,
  58     ILS,
  59     LOC,
  60     GS,
  61     OM,
  62     MM,
  63     IM,
  64 /// important that DME & TACAN are adjacent to keep the TacanFilter
  65 /// efficient - DMEs are proxies for TACAN/VORTAC stations
  66     DME,
  67     TACAN,
  68     MOBILE_TACAN,
  69     OBSTACLE,
  70 /// an actual airport tower - not a radio comms facility!
  71 /// some airports have multiple towers, eg EHAM, although our data source
  72 /// doesn't necessarily include them
  73     TOWER,
  74     FREQ_GROUND,
  75     FREQ_TOWER,
  76     FREQ_ATIS,
  77     FREQ_AWOS,
  78     FREQ_APP_DEP,
  79     FREQ_ENROUTE,
  80     FREQ_CLEARANCE,
  81     FREQ_UNICOM,
  82 // groundnet items
  83     PARKING,  ///< parking position - might be a gate, or stand
  84     TAXI_NODE,
  85 // POI items
  86     COUNTRY,
  87     CITY,
  88     TOWN,
  89     VILLAGE,
  90
  91     LAST_TYPE
  92   } Type;
  93
  94   typedef std::vector<FGPositionedRef> List;
  95
  96   virtual ~FGPositioned();
  97
  98   Type type() const
  99   { return mType; }
 100
 101   const std::string& ident() const
 102   { return mIdent; }
 103
 104   /**
 105    * Return the name of this positioned. By default this is the same as the
 106    * ident, but for many derived classes it's more meaningful - the aiport or
 107    * navaid name, for example.
 108    */
 109   virtual const std::string& name() const
 110   { return mIdent; }
 111
 112   const SGGeod& geod() const
 113   { return mPosition; }
 114
 115   PositionedID guid() const
 116   { return mGuid; }
 117
 118   /**
 119    *  The cartesian position associated with this object
 120    */
 121   const SGVec3d& cart() const;
 122
 123   double latitude() const
 124   { return mPosition.getLatitudeDeg(); }
 125
 126   double longitude() const
 127   { return mPosition.getLongitudeDeg(); }
 128
 129   double elevation() const
 130   { return mPosition.getElevationFt(); }
 131
 132   double elevationM() const
 133   { return mPosition.getElevationM(); }
 134
 135   /**
 136    * Predicate class to support custom filtering of FGPositioned queries
 137    * Default implementation of this passes any FGPositioned instance.
 138    */
 139   class Filter
 140   {
 141   public:
 142     virtual ~Filter() { ; }
 143
 144     /**
 145      * Over-rideable filter method. Default implementation returns true.
 146      */
 147     virtual bool pass(FGPositioned* aPos) const
 148     { return true; }
 149
 150     virtual Type minType() const
 151     { return INVALID; }
 152
 153     virtual Type maxType() const
 154     { return INVALID; }
 155
 156
 157     bool operator()(FGPositioned* aPos) const
 158     { return pass(aPos); }
 159   };
 160
 161   class TypeFilter : public Filter
 162   {
 163   public:
 164     TypeFilter(Type aTy);
 165     virtual bool pass(FGPositioned* aPos) const;
 166
 167     virtual Type minType() const
 168     { return mMinType; }
 169
 170     virtual Type maxType() const
 171     { return mMaxType; }
 172
 173     void addType(Type aTy);
 174   private:
 175     std::vector<Type> types;
 176     Type mMinType, mMaxType;
 177   };
 178
 179   static List findWithinRange(const SGGeod& aPos, double aRangeNm, Filter* aFilter = NULL);
 180
 181   static List findWithinRangePartial(const SGGeod& aPos, double aRangeNm, Filter* aFilter, bool& aPartial);
 182
 183   static FGPositionedRef findClosestWithIdent(const std::string& aIdent, const SGGeod& aPos, Filter* aFilter = NULL);
 184
 185   static FGPositionedRef findFirstWithIdent(const std::string& aIdent, Filter* aFilter = NULL);
 186
 187   /**
 188    * Find all items with the specified ident
 189    * @param aFilter - optional filter on items
 190    */
 191   static List findAllWithIdent(const std::string& aIdent, Filter* aFilter = NULL, bool aExact = true);
 192
 193   /**
 194    * As above, but searches names instead of idents
 195    */
 196   static List findAllWithName(const std::string& aName, Filter* aFilter = NULL, bool aExact = true);
 197
 198   /**
 199    * Sort an FGPositionedList by distance from a position
 200    */
 201   static void sortByRange(List&, const SGGeod& aPos);
 202
 203   /**
 204    * Find the closest item to a position, which pass the specified filter
 205    * A cutoff range in NM must be specified, to constrain the search acceptably.
 206    * Very large cutoff values will make this slow.
 207    *
 208    * @result The closest item passing the filter, or NULL
 209    * @param aCutoffNm - maximum distance to search within, in nautical miles
 210    */
 211   static FGPositionedRef findClosest(const SGGeod& aPos, double aCutoffNm, Filter* aFilter = NULL);
 212
 213   /**
 214    * Find the closest N items to a position, which pass the specified filter
 215    * A cutoff range in NM must be specified, to constrain the search acceptably.
 216    * Very large cutoff values will make this slow.
 217    *
 218    * @result The matches (possibly less than N, depending on the filter and cutoff),
 219    *    sorted by distance from the search pos
 220    * @param aN - number of matches to find
 221    * @param aCutoffNm - maximum distance to search within, in nautical miles
 222    */
 223   static List findClosestN(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter = NULL);
 224
 225   /**
 226    * Same as above, but with a time-bound in msec too.
 227    */
 228   static List findClosestNPartial(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter,
 229                            bool& aPartial);
 230
 231   /**
 232    * Map a candidate type string to a real type. Returns INVALID if the string
 233    * does not correspond to a defined type.
 234    */
 235   static Type typeFromName(const std::string& aName);
 236
 237   /**
 238    * Map a type to a human-readable string
 239    */
 240   static const char* nameForType(Type aTy);
 241
 242   static FGPositioned* createUserWaypoint(const std::string& aIdent, const SGGeod& aPos);
 243   static void deleteUserWaypoint(const std::string& aIdent);
 244 protected:
 245   friend class flightgear::NavDataCache;
 246
 247   FGPositioned(PositionedID aGuid, Type ty, const std::string& aIdent, const SGGeod& aPos);
 248
 249   void modifyPosition(const SGGeod& newPos);
 250
 251   static FGPositioned* loadByIdImpl(PositionedID id);
 252
 253   template<class T>
 254   static T* loadById(PositionedID id)
 255   {
 256     return static_cast<T*>( loadByIdImpl(id) );
 257   }
 258
 259   template<class T>
 260   static T* loadById(const PositionedIDVec& id_vec, size_t index)
 261   {
 262     assert(index >= 0 && index < id_vec.size());
 263     return loadById<T>(id_vec[index]);
 264   }
 265
 266   template<class T>
 267   static std::vector<T*> loadAllById(const PositionedIDVec& id_vec)
 268   {
 269     std::vector<T*> vec(id_vec.size());
 270
 271     for(size_t i = 0; i < id_vec.size(); ++i)
 272       vec[i] = loadById<T>(id_vec[i]);
 273
 274     return vec;
 275   }
 276
 277   const PositionedID mGuid;
 278   const SGGeod mPosition;
 279   const SGVec3d mCart;
 280   const Type mType;
 281   const std::string mIdent;
 282
 283 private:
 284   SG_DISABLE_COPY(FGPositioned);
 285 };
 286
 287 #endif // of FG_POSITIONED_HXX