src/Autopilot/inputvalue.hxx

   1 // inputvalue.hxx - provide input to autopilot components
   2 //
   3 // Written by Torsten Dreyer
   4 // Copyright (C) 2010  Torsten Dreyer - Torsten (at) t3r (dot) de
   5 //
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License as
   8 // published by the Free Software Foundation; either version 2 of the
   9 // License, or (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 //
  20
  21 #ifndef _INPUTVALUE_HXX
  22 #define _INPUTVALUE_HXX 1
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28
  29 #include <simgear/structure/SGExpression.hxx>
  30
  31 namespace FGXMLAutopilot {
  32
  33 typedef SGSharedPtr<class InputValue> InputValue_ptr;
  34 typedef SGSharedPtr<class PeriodicalValue> PeriodicalValue_ptr;
  35
  36 /**
  37  * @brief Model a periodical value like angular values
  38  *
  39  * Most common use for periodical values are angular values.
  40  * If y = f(x) = f(x + n*period), this is a periodical function
  41  */
  42 class PeriodicalValue : public SGReferenced {
  43 private:
  44      InputValue_ptr minPeriod; // The minimum value of the period
  45      InputValue_ptr maxPeriod; // The maximum value of the period
  46 public:
  47      PeriodicalValue( SGPropertyNode_ptr node );
  48      double normalize( double value ) const;
  49      double normalizeSymmetric( double value ) const;
  50 };
  51
  52 /**
  53  * @brief A input value for analog autopilot components
  54  *
  55  * Input values may be constants, property values, transformed with a scale
  56  * and/or offset, clamped to min/max values, be periodical, bound to
  57  * conditions or evaluated from expressions.
  58  */
  59 class InputValue : public SGReferenced {
  60 private:
  61      double             _value;    // The value as a constant or initializer for the property
  62      bool               _abs;      // return absolute value
  63      SGPropertyNode_ptr _property; // The name of the property containing the value
  64      InputValue_ptr _offset;   // A fixed offset, defaults to zero
  65      InputValue_ptr _scale;    // A constant scaling factor defaults to one
  66      InputValue_ptr _min;      // A minimum clip defaults to no clipping
  67      InputValue_ptr _max;      // A maximum clip defaults to no clipping
  68      PeriodicalValue_ptr  _periodical; //
  69      SGSharedPtr<const SGCondition> _condition;
  70      SGSharedPtr<SGExpressiond> _expression;  ///< expression to generate the value
  71
  72 public:
  73     InputValue( SGPropertyNode_ptr node = NULL, double value = 0.0, double offset = 0.0, double scale = 1.0 );
  74
  75     void parse( SGPropertyNode_ptr, double value = 0.0, double offset = 0.0, double scale = 1.0 );
  76
  77     /* get the value of this input, apply scale and offset and clipping */
  78     double get_value() const;
  79
  80     /* set the input value after applying offset and scale */
  81     void set_value( double value );
  82
  83     inline double get_scale() const {
  84       return _scale == NULL ? 1.0 : _scale->get_value();
  85     }
  86
  87     inline double get_offset() const {
  88       return _offset == NULL ? 0.0 : _offset->get_value();
  89     }
  90
  91     inline bool is_enabled() const {
  92       return _condition == NULL ? true : _condition->test();
  93     }
  94
  95 };
  96
  97 /**
  98  * @brief A chained list of InputValues
  99  *
 100  * Many compoments support InputValueLists as input. Each InputValue may be bound to
 101  * a condition. This list supports the get_value() function to retrieve the value
 102  * of the first InputValue in this list that has a condition evaluating to true.
 103  */
 104 class InputValueList : public std::vector<InputValue_ptr> {
 105   public:
 106     InputValueList( double def = 0.0 ) : _def(def) { }
 107
 108     InputValue_ptr get_active() const {
 109       for (const_iterator it = begin(); it != end(); ++it) {
 110         if( (*it)->is_enabled() )
 111           return *it;
 112       }
 113       return NULL;
 114     }
 115
 116     double get_value() const {
 117       InputValue_ptr input = get_active();
 118       return input == NULL ? _def : input->get_value();
 119     }
 120   private:
 121
 122     double _def;
 123
 124 };
 125
 126 }
 127
 128 #endif