MapWidget: Show counties and towns as well, depending on the zoom.
[fg:flightgear.git] / src / Navaids / positioned.cxx
1 // positioned.cxx - 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 #ifdef HAVE_CONFIG_H
22 #  include "config.h"
23 #endif
24
25 #include "positioned.hxx"
26
27 #include <map>
28 #include <set>
29 #include <algorithm> // for sort
30 #include <queue>
31 #include <memory>
32
33 #include <boost/algorithm/string/case_conv.hpp>
34 #include <boost/algorithm/string/predicate.hpp>
35
36 #include <simgear/timing/timestamp.hxx>
37 #include <simgear/debug/logstream.hxx>
38 #include <simgear/structure/exception.hxx>
39 #include <simgear/math/SGGeometry.hxx>
40 #include <simgear/sg_inlines.h>
41
42 #include "Navaids/PositionedOctree.hxx"
43
44 using std::string;
45 using namespace flightgear;
46
47 static void validateSGGeod(const SGGeod& geod)
48 {
49   if (SGMisc<double>::isNaN(geod.getLatitudeDeg()) ||
50       SGMisc<double>::isNaN(geod.getLongitudeDeg()))
51   {
52     throw sg_range_exception("position is invalid, NaNs");
53   }
54 }
55
56
57 ///////////////////////////////////////////////////////////////////////////////
58
59 FGPositioned::FGPositioned(PositionedID aGuid, Type ty, const std::string& aIdent, const SGGeod& aPos) :
60   mGuid(aGuid),
61   mPosition(aPos),
62   mCart(SGVec3d::fromGeod(mPosition)),
63   mType(ty),
64   mIdent(aIdent)
65 {  
66 }
67
68 FGPositioned::~FGPositioned()
69 {
70 //  std::cout << "destroying:" << mIdent << "/" << nameForType(mType) << std::endl;
71 }
72
73 FGPositioned*
74 FGPositioned::createUserWaypoint(const std::string& aIdent, const SGGeod& aPos)
75 {
76   NavDataCache* cache = NavDataCache::instance();
77   TypeFilter filter(WAYPOINT);
78   FGPositioned::List existing = cache->findAllWithIdent(aIdent, &filter, true);
79   if (!existing.empty()) {
80     SG_LOG(SG_NAVAID, SG_WARN, "attempt to insert duplicate WAYPOINT:" << aIdent);
81     return existing.front().ptr();
82   }
83   
84   PositionedID id = cache->createPOI(WAYPOINT, aIdent, aPos);
85   return cache->loadById(id);
86 }
87
88 void FGPositioned::deleteUserWaypoint(const std::string& aIdent)
89 {
90   NavDataCache* cache = NavDataCache::instance();
91   cache->removePOI(WAYPOINT, aIdent);
92 }
93
94
95 const SGVec3d&
96 FGPositioned::cart() const
97 {
98   return mCart;
99 }
100
101 FGPositioned::Type FGPositioned::typeFromName(const std::string& aName)
102 {
103   if (aName.empty() || (aName == "")) {
104     return INVALID;
105   }
106
107   typedef struct {
108     const char* _name;
109     Type _ty;
110   } NameTypeEntry;
111   
112   const NameTypeEntry names[] = {
113     {"airport", AIRPORT},
114     {"vor", VOR},
115     {"loc", LOC},
116     {"ils", ILS},
117     {"gs", GS},
118     {"ndb", NDB},
119     {"wpt", WAYPOINT},
120     {"fix", FIX},
121     {"tacan", TACAN},
122     {"dme", DME},
123     {"atis", FREQ_ATIS},
124     {"awos", FREQ_AWOS},
125     {"tower", FREQ_TOWER},
126     {"ground", FREQ_GROUND},
127     {"approach", FREQ_APP_DEP},
128     {"departure", FREQ_APP_DEP},
129     {"runway", RUNWAY},
130     {"helipad", HELIPAD},
131     {"country", COUNTRY},
132     {"city", CITY},
133     {"town", TOWN},
134     {"village", VILLAGE},
135       
136   // aliases
137     {"gnd", FREQ_GROUND},
138     {"twr", FREQ_TOWER},
139     {"waypoint", WAYPOINT},
140     {"apt", AIRPORT},
141     {"arpt", AIRPORT},
142     {"rwy", RUNWAY},
143     {"any", INVALID},
144     {"all", INVALID},
145     
146     {NULL, INVALID}
147   };
148   
149   std::string lowerName(boost::to_lower_copy(aName));
150   
151   for (const NameTypeEntry* n = names; (n->_name != NULL); ++n) {
152     if (::strcmp(n->_name, lowerName.c_str()) == 0) {
153       return n->_ty;
154     }
155   }
156   
157   SG_LOG(SG_NAVAID, SG_WARN, "FGPositioned::typeFromName: couldn't match:" << aName);
158   return INVALID;
159 }
160
161 const char* FGPositioned::nameForType(Type aTy)
162 {
163  switch (aTy) {
164  case RUNWAY: return "runway";
165  case HELIPAD: return "helipad";
166  case TAXIWAY: return "taxiway";
167  case PAVEMENT: return "pavement";
168  case PARKING: return "parking stand";
169  case FIX: return "fix";
170  case VOR: return "VOR";
171  case NDB: return "NDB";
172  case ILS: return "ILS";
173  case LOC: return "localiser";
174  case GS: return "glideslope";
175  case OM: return "outer-marker";
176  case MM: return "middle-marker";
177  case IM: return "inner-marker";
178  case AIRPORT: return "airport";
179  case HELIPORT: return "heliport";
180  case SEAPORT: return "seaport";
181  case WAYPOINT: return "waypoint";
182  case DME: return "dme";
183  case TACAN: return "tacan";
184  case FREQ_TOWER: return "tower";
185  case FREQ_ATIS: return "atis";
186  case FREQ_AWOS: return "awos";
187  case FREQ_GROUND: return "ground";
188  case FREQ_CLEARANCE: return "clearance";
189  case FREQ_UNICOM: return "unicom";
190  case FREQ_APP_DEP: return "approach-departure";
191  case TAXI_NODE: return "taxi-node";
192  case COUNTRY: return "country";
193  case CITY: return "city";
194  case TOWN: return "town";
195  case VILLAGE: return "village";
196  default:
197   return "unknown";
198  }
199 }
200
201 ///////////////////////////////////////////////////////////////////////////////
202 // search / query functions
203
204 FGPositionedRef
205 FGPositioned::findClosestWithIdent(const std::string& aIdent, const SGGeod& aPos, Filter* aFilter)
206 {
207   validateSGGeod(aPos);  
208   return NavDataCache::instance()->findClosestWithIdent(aIdent, aPos, aFilter);
209 }
210
211 FGPositionedRef
212 FGPositioned::findFirstWithIdent(const std::string& aIdent, Filter* aFilter)
213 {
214   if (aIdent.empty()) {
215     return NULL;
216   }
217   
218   List r = NavDataCache::instance()->findAllWithIdent(aIdent, aFilter, true);
219   if (r.empty()) {
220     return NULL;
221   }
222   
223   return r.front();
224 }
225
226 FGPositioned::List
227 FGPositioned::findWithinRange(const SGGeod& aPos, double aRangeNm, Filter* aFilter)
228 {
229   validateSGGeod(aPos);
230
231   List result;
232   Octree::findAllWithinRange(SGVec3d::fromGeod(aPos), 
233     aRangeNm * SG_NM_TO_METER, aFilter, result, 0xffffff);
234   return result;
235 }
236
237 FGPositioned::List
238 FGPositioned::findWithinRangePartial(const SGGeod& aPos, double aRangeNm, Filter* aFilter, bool& aPartial)
239 {
240   validateSGGeod(aPos);
241   
242   int limitMsec = 32;
243   List result;
244   aPartial = Octree::findAllWithinRange(SGVec3d::fromGeod(aPos),
245                              aRangeNm * SG_NM_TO_METER, aFilter, result,
246                                         limitMsec);
247   return result;
248 }
249
250 FGPositioned::List
251 FGPositioned::findAllWithIdent(const std::string& aIdent, Filter* aFilter, bool aExact)
252 {
253   return NavDataCache::instance()->findAllWithIdent(aIdent, aFilter, aExact);
254 }
255
256 FGPositioned::List
257 FGPositioned::findAllWithName(const std::string& aName, Filter* aFilter, bool aExact)
258 {
259   return NavDataCache::instance()->findAllWithName(aName, aFilter, aExact);
260 }
261
262 FGPositionedRef
263 FGPositioned::findClosest(const SGGeod& aPos, double aCutoffNm, Filter* aFilter)
264 {
265   validateSGGeod(aPos);
266   
267   List l(findClosestN(aPos, 1, aCutoffNm, aFilter));
268   if (l.empty()) {
269     return NULL;
270   }
271
272   assert(l.size() == 1);
273   return l.front();
274 }
275
276 FGPositioned::List
277 FGPositioned::findClosestN(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter)
278 {
279   validateSGGeod(aPos);
280   
281   List result;
282   int limitMsec = 0xffff;
283   Octree::findNearestN(SGVec3d::fromGeod(aPos), aN, aCutoffNm * SG_NM_TO_METER, aFilter, result, limitMsec);
284   return result;
285 }
286
287 FGPositioned::List
288 FGPositioned::findClosestNPartial(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter, bool &aPartial)
289 {
290     validateSGGeod(aPos);
291     
292     List result;
293     int limitMsec = 32;
294     aPartial = Octree::findNearestN(SGVec3d::fromGeod(aPos), aN, aCutoffNm * SG_NM_TO_METER, aFilter, result,
295                         limitMsec);
296     return result;
297 }
298
299 void
300 FGPositioned::sortByRange(List& aResult, const SGGeod& aPos)
301 {
302   validateSGGeod(aPos);
303   
304   SGVec3d cartPos(SGVec3d::fromGeod(aPos));
305 // computer ordering values
306   Octree::FindNearestResults r;
307   List::iterator it = aResult.begin(), lend = aResult.end();
308   for (; it != lend; ++it) {
309     double d2 = distSqr((*it)->cart(), cartPos);
310     r.push_back(Octree::OrderedPositioned(*it, d2));
311   }
312   
313 // sort
314   std::sort(r.begin(), r.end());
315   
316 // convert to a plain list
317   unsigned int count = aResult.size();
318   for (unsigned int i=0; i<count; ++i) {
319     aResult[i] = r[i].get();
320   }
321 }
322
323 void FGPositioned::modifyPosition(const SGGeod& newPos)
324 {
325   const_cast<SGGeod&>(mPosition) = newPos;
326   const_cast<SGVec3d&>(mCart) = SGVec3d::fromGeod(newPos);
327 }
328
329 //------------------------------------------------------------------------------
330 FGPositioned* FGPositioned::loadByIdImpl(PositionedID id)
331 {
332   return flightgear::NavDataCache::instance()->loadById(id);
333 }
334
335 FGPositioned::TypeFilter::TypeFilter(Type aTy) :
336   mMinType(aTy),
337   mMaxType(aTy)
338 {
339   addType(aTy);
340 }
341
342 void FGPositioned::TypeFilter::addType(Type aTy)
343 {
344   if (aTy == INVALID) {
345     return;
346   }
347   
348   types.push_back(aTy);
349   mMinType = std::min(mMinType, aTy);
350   mMaxType = std::max(mMaxType, aTy);
351 }
352
353 bool
354 FGPositioned::TypeFilter::pass(FGPositioned* aPos) const
355 {
356   if (types.empty()) {
357     return true;
358   }
359   
360     std::vector<Type>::const_iterator it = types.begin(),
361         end = types.end();
362     for (; it != end; ++it) {
363         if (aPos->type() == *it) {
364             return true;
365         }
366     }
367     
368     return false;
369 }
370