simgear/environment/metar.hxx

   1 // metar interface class
   2 //
   3 // Written by Melchior FRANZ, started December 2003.
   4 //
   5 // Copyright (C) 2003  Melchior FRANZ - mfranz@aon.at
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22
  23 #ifndef _METAR_HXX
  24 #define _METAR_HXX
  25
  26 #include <vector>
  27 #include <map>
  28 #include <string>
  29
  30 #include <simgear/constants.h>
  31
  32 struct Token {
  33         const char *id;
  34         const char *text;
  35 };
  36
  37 const double SGMetarNaN = -1E20;
  38
  39 class SGMetar;
  40
  41 class SGMetarVisibility {
  42         friend class SGMetar;
  43 public:
  44         SGMetarVisibility() :
  45                 _distance(SGMetarNaN),
  46                 _direction(-1),
  47                 _modifier(EQUALS),
  48                 _tendency(NONE) {}
  49
  50         enum Modifier {
  51                 NOGO,
  52                 EQUALS,
  53                 LESS_THAN,
  54                 GREATER_THAN
  55         };
  56
  57         enum Tendency {
  58                 NONE,
  59                 STABLE,
  60                 INCREASING,
  61                 DECREASING
  62         };
  63
  64         void set(double dist, int dir = -1, int mod = -1, int tend = -1);
  65
  66         inline double   getVisibility_m()       const { return _distance; }
  67         inline double   getVisibility_ft()      const { return _distance == SGMetarNaN ? SGMetarNaN : _distance * SG_METER_TO_FEET; }
  68         inline double   getVisibility_sm()      const { return _distance == SGMetarNaN ? SGMetarNaN : _distance * SG_METER_TO_SM; }
  69         inline int      getDirection()          const { return _direction; }
  70         inline int      getModifier()           const { return _modifier; }
  71         inline int      getTendency()           const { return _tendency; }
  72
  73 protected:
  74         double  _distance;
  75         int     _direction;
  76         int     _modifier;
  77         int     _tendency;
  78 };
  79
  80
  81 // runway condition (surface and visibility)
  82 class SGMetarRunway {
  83         friend class SGMetar;
  84 public:
  85         SGMetarRunway() :
  86                 _deposit(-1),
  87                 _deposit_string(0),
  88                 _extent(-1),
  89                 _extent_string(0),
  90                 _depth(SGMetarNaN),
  91                 _friction(SGMetarNaN),
  92                 _friction_string(0),
  93                 _comment(0),
  94                 _wind_shear(false) {}
  95
  96         inline int                      getDeposit()            const { return _deposit; }
  97         inline const char               *getDepositString()     const { return _deposit_string; }
  98         inline double                   getExtent()             const { return _extent; }
  99         inline const char               *getExtentString()      const { return _extent_string; }
 100         inline double                   getDepth()              const { return _depth; }
 101         inline double                   getFriction()           const { return _friction; }
 102         inline const char               *getFrictionString()    const { return _friction_string; }
 103         inline const char               *getComment()           const { return _comment; }
 104         inline       bool               getWindShear()          const { return _wind_shear; }
 105         inline const SGMetarVisibility& getMinVisibility()      const { return _min_visibility; }
 106         inline const SGMetarVisibility& getMaxVisibility()      const { return _max_visibility; }
 107
 108 protected:
 109         SGMetarVisibility _min_visibility;
 110         SGMetarVisibility _max_visibility;
 111         int             _deposit;
 112         const char      *_deposit_string;
 113         int             _extent;
 114         const char      *_extent_string;
 115         double          _depth;
 116         double          _friction;
 117         const char      *_friction_string;
 118         const char      *_comment;
 119         bool            _wind_shear;
 120 };
 121
 122
 123 // cloud layer
 124 class SGMetarCloud {
 125         friend class SGMetar;
 126 public:
 127         enum Coverage {
 128                 COVERAGE_NIL = -1,
 129                 COVERAGE_CLEAR = 0,
 130                 COVERAGE_FEW = 1,
 131                 COVERAGE_SCATTERED = 2,
 132                 COVERAGE_BROKEN = 3,
 133                 COVERAGE_OVERCAST = 4
 134         };
 135
 136         static const char * COVERAGE_NIL_STRING;
 137         static const char * COVERAGE_CLEAR_STRING;
 138         static const char * COVERAGE_FEW_STRING;
 139         static const char * COVERAGE_SCATTERED_STRING;
 140         static const char * COVERAGE_BROKEN_STRING;
 141         static const char * COVERAGE_OVERCAST_STRING;
 142
 143         SGMetarCloud() : _coverage(COVERAGE_NIL), _altitude(SGMetarNaN), _type(0), _type_long(0) {}
 144
 145         void set(double alt, Coverage cov = COVERAGE_NIL );
 146
 147         inline Coverage getCoverage() const { return _coverage; }
 148         static Coverage getCoverage( const std::string & coverage );
 149         inline double getAltitude_m() const { return _altitude; }
 150         inline double getAltitude_ft() const { return _altitude == SGMetarNaN ? SGMetarNaN : _altitude * SG_METER_TO_FEET; }
 151         inline const char *getTypeString() const { return _type; }
 152         inline const char *getTypeLongString() const { return _type_long; }
 153
 154 protected:
 155         Coverage _coverage;     // quarters: 0 -> clear ... 4 -> overcast
 156         double _altitude;       // 1000 m
 157         const char *_type;      // CU
 158         const char *_type_long; // cumulus
 159 };
 160
 161
 162 class SGMetar {
 163 public:
 164         SGMetar(const std::string& m);
 165         ~SGMetar();
 166
 167         enum ReportType {
 168                 NONE,
 169                 AUTO,
 170                 COR,
 171                 RTD
 172         };
 173
 174         enum Intensity {
 175                 NIL = 0,
 176                 LIGHT = 1,
 177                 MODERATE = 2,
 178                 HEAVY = 3
 179         };
 180
 181         struct Weather {
 182                 Weather() { intensity = NIL; vincinity = false; }
 183                 Intensity intensity;
 184                 bool      vincinity;
 185                 std::vector<std::string> descriptions;
 186                 std::vector<std::string> phenomena;
 187         };
 188
 189         inline const char *getData()            const { return _data; }
 190         inline const char *getUnusedData()      const { return _m; }
 191         inline       bool getProxy()            const { return _x_proxy; }
 192         inline const char *getId()              const { return _icao; }
 193         inline int      getYear()               const { return _year; }
 194         inline int      getMonth()              const { return _month; }
 195         inline int      getDay()                const { return _day; }
 196         inline int      getHour()               const { return _hour; }
 197         inline int      getMinute()             const { return _minute; }
 198         inline int      getReportType()         const { return _report_type; }
 199
 200         inline int      getWindDir()            const { return _wind_dir; }
 201         inline double   getWindSpeed_mps()      const { return _wind_speed; }
 202         inline double   getWindSpeed_kmh()      const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_KMH; }
 203         inline double   getWindSpeed_kt()       const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_KT; }
 204         inline double   getWindSpeed_mph()      const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_MPH; }
 205
 206         inline double   getGustSpeed_mps()      const { return _gust_speed; }
 207         inline double   getGustSpeed_kmh()      const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_KMH; }
 208         inline double   getGustSpeed_kt()       const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_KT; }
 209         inline double   getGustSpeed_mph()      const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_MPH; }
 210
 211         inline int      getWindRangeFrom()      const { return _wind_range_from; }
 212         inline int      getWindRangeTo()        const { return _wind_range_to; }
 213
 214         inline const SGMetarVisibility& getMinVisibility()      const { return _min_visibility; }
 215         inline const SGMetarVisibility& getMaxVisibility()      const { return _max_visibility; }
 216         inline const SGMetarVisibility& getVertVisibility()     const { return _vert_visibility; }
 217         inline const SGMetarVisibility *getDirVisibility()      const { return _dir_visibility; }
 218
 219         inline double   getTemperature_C()      const { return _temp; }
 220         inline double   getTemperature_F()      const { return _temp == SGMetarNaN ? SGMetarNaN : 1.8 * _temp + 32; }
 221         inline double   getDewpoint_C()         const { return _dewp; }
 222         inline double   getDewpoint_F()         const { return _dewp == SGMetarNaN ? SGMetarNaN : 1.8 * _dewp + 32; }
 223         inline double   getPressure_hPa()       const { return _pressure == SGMetarNaN ? SGMetarNaN : _pressure / 100; }
 224         inline double   getPressure_inHg()      const { return _pressure == SGMetarNaN ? SGMetarNaN : _pressure * SG_PA_TO_INHG; }
 225
 226         inline int      getRain()               const { return _rain; }
 227         inline int      getHail()               const { return _hail; }
 228         inline int      getSnow()               const { return _snow; }
 229         inline bool     getCAVOK()              const { return _cavok; }
 230
 231         double          getRelHumidity()        const;
 232
 233         inline const std::vector<SGMetarCloud>& getClouds()     const   { return _clouds; }
 234         inline const std::map<std::string, SGMetarRunway>& getRunways() const   { return _runways; }
 235         inline const std::vector<std::string>& getWeather()             const   { return _weather; }
 236         inline const std::vector<struct Weather> getWeather2()  const   { return _weather2; }
 237
 238 protected:
 239         std::string     _url;
 240         int     _grpcount;
 241         bool    _x_proxy;
 242         char    *_data;
 243         char    *_m;
 244         char    _icao[5];
 245         int     _year;
 246         int     _month;
 247         int     _day;
 248         int     _hour;
 249         int     _minute;
 250         int     _report_type;
 251         int     _wind_dir;
 252         double  _wind_speed;
 253         double  _gust_speed;
 254         int     _wind_range_from;
 255         int     _wind_range_to;
 256         double  _temp;
 257         double  _dewp;
 258         double  _pressure;
 259         int     _rain;
 260         int     _hail;
 261         int     _snow;
 262         bool    _cavok;
 263         std::vector<struct Weather> _weather2;
 264
 265         SGMetarVisibility               _min_visibility;
 266         SGMetarVisibility               _max_visibility;
 267         SGMetarVisibility               _vert_visibility;
 268         SGMetarVisibility               _dir_visibility[8];
 269         std::vector<SGMetarCloud>               _clouds;
 270         std::map<std::string, SGMetarRunway>    _runways;
 271         std::vector<std::string>                        _weather;
 272
 273         bool    scanPreambleDate();
 274         bool    scanPreambleTime();
 275         void    useCurrentDate();
 276
 277         bool    scanType();
 278         bool    scanId();
 279         bool    scanDate();
 280         bool    scanModifier();
 281         bool    scanWind();
 282         bool    scanVariability();
 283         bool    scanVisibility();
 284         bool    scanRwyVisRange();
 285         bool    scanSkyCondition();
 286         bool    scanWeather();
 287         bool    scanTemperature();
 288         bool    scanPressure();
 289         bool    scanRunwayReport();
 290         bool    scanWindShear();
 291         bool    scanTrendForecast();
 292         bool    scanColorState();
 293         bool    scanRemark();
 294         bool    scanRemainder();
 295
 296         int     scanNumber(char **str, int *num, int min, int max = 0);
 297         bool    scanBoundary(char **str);
 298         const struct Token *scanToken(char **str, const struct Token *list);
 299         void    normalizeData();
 300 };
 301
 302 #endif // _METAR_HXX