route.hxx

Go to the documentation of this file.

// Copyright (C) 2009 James Turner
// SPDX-License-Identifier: GPL-2.0-or-later
 
#pragma once
 
// std
#include <vector>
#include <map>
#include <iosfwd>
#include <optional>
 
// Simgear
#include <simgear/structure/SGReferenced.hxx>
#include <simgear/structure/SGSharedPtr.hxx>
#include <simgear/props/props.hxx>
 
// forward decls
class FGPositioned;
class SGPath;
class FGAirport;
 
namespace flightgear
{
 
// forward decls
class RouteBase;
class Waypt;
class NavdataVisitor;
class Airway;
 
using AirwayRef = SGSharedPtr<Airway>;
typedef SGSharedPtr<Waypt> WayptRef;
 
typedef enum {
        WPT_MAP           = 1 << 0, 
        WPT_IAF           = 1 << 1, 
        WPT_FAF           = 1 << 2, 
        WPT_OVERFLIGHT    = 1 << 3, 
        WPT_TRANSITION    = 1 << 4, 
        WPT_MISS          = 1 << 5, 
  WPT_DYNAMIC       = 1 << 6,
  WPT_GENERATED     = 1 << 7,
  
  WPT_DEPARTURE     = 1 << 8,
  WPT_ARRIVAL       = 1 << 9,

  WPT_PSEUDO        = 1 << 10,
  WPT_APPROACH      = 1 << 11,

  WPT_VIA           = 1 << 12,
    
    WPT_HIDDEN      = 1 << 13
} WayptFlag;
 
typedef enum {
        RESTRICT_NONE,
        RESTRICT_AT,
        RESTRICT_ABOVE,
        RESTRICT_BELOW,
    RESTRICT_BETWEEN,
  SPEED_RESTRICT_MACH,  
  RESTRICT_DELETE,      
  RESTRICT_COMPUTED,    
  SPEED_COMPUTED_MACH   
} RouteRestriction;
 
typedef enum {
    DEFAULT_UNITS = 0,
    ALTITUDE_FEET,
    ALTITUDE_METER,
    ALTITUDE_FLIGHTLEVEL,
    SPEED_KNOTS,
    SPEED_MACH,
    SPEED_KPH
} RouteUnits;
 
RouteRestriction restrictionFromString(const std::string& t);
 
bool isMachRestrict(RouteRestriction rr);
 
double convertSpeedUnits(RouteUnits aSrc, RouteUnits aDest, double aAltitudeFt, double aValue);
double convertAltitudeUnits(RouteUnits aSrc, RouteUnits aDest, double aValue);

class Waypt : public SGReferenced
{
public:
  virtual ~Waypt();
  
    RouteBase* owner() const
    { return const_cast<RouteBase*>(_owner); }
                
        virtual SGGeod position() const = 0;
        
        virtual FGPositioned* source() const
        { return nullptr; }
        
    double altitudeFt() const;
                
    double speed(RouteUnits aUnits = DEFAULT_UNITS) const;
  
    double altitude(RouteUnits aUnits = DEFAULT_UNITS) const;
 
    double constraintAltitude(RouteUnits aUnits = DEFAULT_UNITS) const;
 
// wrapper - asserts if restriction type is _MACH
  double speedKts() const;
  
// wrapper - asserts if restriction type is not _MACH
  double speedMach() const;
  
        virtual RouteRestriction altitudeRestriction() const
                { return _altRestrict; }
        
        virtual RouteRestriction speedRestriction() const
                { return _speedRestrict; }
        
  void setAltitude(double aAlt, RouteRestriction aRestrict, RouteUnits aUnits = DEFAULT_UNITS);
  void setSpeed(double aSpeed, RouteRestriction aRestrict, RouteUnits aUnits = DEFAULT_UNITS);
  
    void setConstraintAltitude(double aAlt);

        virtual std::string ident() const;
        
        virtual bool flag(WayptFlag aFlag) const;
        
  virtual unsigned int flags() const
  { return _flags; }
  
  void setFlag(WayptFlag aFlag, bool aV = true);
  
  static WayptRef createFromProperties(RouteBase* aOwner, SGPropertyNode_ptr aProp);

  static WayptRef createFromString(RouteBase* aOwner, const std::string& s, const SGGeod& vicinity);
 
  static WayptRef fromLatLonString(RouteBase* aOwner, const std::string& target);
 
 
  void saveAsNode(SGPropertyNode* node) const;
  
  bool matches(Waypt* aOther) const;

  bool matches(FGPositioned* aPos) const;
    
  bool matches(const SGGeod& aPos) const;
  
  virtual std::string type() const = 0;
  
  virtual double magvarDeg() const;
  
  virtual double headingRadialDeg() const;

  virtual std::string icaoDescription() const;
 
protected:
  friend class NavdataVisitor;
  
        Waypt(RouteBase* aOwner);
  
    virtual bool initFromProperties(SGPropertyNode_ptr aProp);

    virtual void writeToProperties(SGPropertyNode_ptr aProp) const;
 
    typedef Waypt*(FactoryFunction)(RouteBase* aOwner);
    static void registerFactory(const std::string aNodeType, FactoryFunction* aFactory);
 
    double _altitude = 0.0;
    std::optional<double> _constraintAltitude;
    
    RouteUnits _altitudeUnits = ALTITUDE_FEET;
 
        double _speed = 0.0;
    RouteUnits _speedUnits = SPEED_KNOTS;
    
        RouteRestriction _altRestrict = RESTRICT_NONE;
        RouteRestriction _speedRestrict = RESTRICT_NONE;
private:

  static WayptRef createInstance(RouteBase* aOwner, const std::string& aTypeName);
 
    const RouteBase* _owner = nullptr;
        unsigned short _flags = 0;
    mutable double _magVarDeg = 0.0; 
};
 
typedef std::vector<WayptRef> WayptVec;
  
class RouteBase : public SGReferenced
{
public:
  virtual ~RouteBase();
    
  virtual std::string ident() const = 0;
  
  static void loadAirportProcedures(const SGPath& aPath, FGAirport* aApt);
  
  static void dumpRouteToKML(const WayptVec& aRoute, const std::string& aName);
  
  static void dumpRouteToKMLLineString(const std::string& aIdent,
    const WayptVec& aRoute, std::ostream& aStream);
private:
 
};
 
} // of namespace flightgear