Attributes.hpp

#ifndef LGL_ATTRIBUTES_HPP
#define LGL_ATTRIBUTES_HPP

#include <iostream>
#include <map>
#include <math.h>

// Max entropy for probabilities in interval [0.0  1.0] is = -log(0.5) so:
#define MAX_ENTROPY_BINARY 0.693147180559945 
// Max entropy for tri-probabilities in interval [0.0  1.0] 
#define MAX_ENTROPY_TRI    1.09861228866811
// Max entropy for tetra-probabilities in interval [0.0  1.0] 
#define MAX_ENTROPY_TETRA  1.38629436111989 
#define ATT_MIN_VAL 0.0000000001
#define ATT_MAX_VAL 0.9999999990

namespace jafar {
  namespace lgl {

    enum attributeKey { 
      ATT_BEGIN=0,
      T_FREE=ATT_BEGIN, // anti = OCCUPIED
      T_ROUGH,
      T_LIMIT=T_ROUGH,
      T_OBSTACLE,
      ATT_END=T_OBSTACLE,
      ATT_MAX
    };
    typedef enum attributeKey attributeKey;

    enum attributeClass { 
      CLASS_BEGIN=0,
      T_SYMBOL=CLASS_BEGIN,
      T_CLASS,
      CLASS_MAX
    };

    typedef enum attributeClass attributeClass;

    
    struct Attributes { //{{{

      double certainty[ATT_MAX];
      bool hasbeenset[ATT_MAX];
      double  infotropy[CLASS_MAX];

      Attributes()
      { //{{{
        reset();
      } //}}}

      Attributes(attributeKey _at, double inval_)
      { //{{{
        reset();
        // Restricting values
        if (inval_ > 1.0 || inval_ < 0.0) { inval_ = 0.0; }
        // Initialize the key attribute _at
        set(_at, inval_);

      } //}}}

      void set(attributeKey _at, double inval_, bool reset=true)
      { //{{{
        // For other attributes
        if (!reset) 
        {
          if (hasbeenset[_at])
          {
            // Do nothing
            return;
          }
        }

        // Out of proba boundaries: shout not happen
        if (inval_ > 1.0 || inval_ < 0.0) 
        {
          certainty[_at] = 0.0;
          hasbeenset[_at] = false;
        } else {
          // Adjusting the input value
          /*
          if (inval_ == 0.0 && (_at >= T_FREE && _at <= T_OBSTACLE))
          {
            inval_ = ATT_MIN_VAL;
          }*/

          // Setting certainty 
          certainty[_at] = inval_;
          hasbeenset[_at] = true;
          /* 
          if (inval_ != 0.0) 
          {
            hasbeenset[_at] = true;
          } else {
            hasbeenset[_at] = false;
          }
          */
        }
      } //}}}

      void normalizeCertainties(attributeKey fromK, attributeKey toK)
      { //{{{
        // ONLY FOR T_ classes
        // Probability accumulation buffer and Normalizer
        double NPacc    = 0.0;
        for(int k = fromK; k <= toK; k++)
        {
          if (hasbeenset[(attributeKey)k])
          {
            NPacc = NPacc + certainty[(attributeKey) k];
          } else {
            certainty[(attributeKey) k] = ATT_MIN_VAL;
            NPacc = NPacc + certainty[(attributeKey) k];
          }
        }

        if (NPacc == 1.0)
        {
          // No nomarlization needed
          return;
        }

        if (NPacc > 0.0)
        {
          // Normalization
          NPacc = 1.0 / NPacc;
          for(int k = fromK; k <= toK; k++)
          {
            certainty[(attributeKey) k] = certainty[(attributeKey) k] * NPacc;
            hasbeenset[(attributeKey) k] = true;
          }
        } else {
          // Equi-distribution
          // Certainties are set to Zero when no input or when input is out of probability bounds [0:1]
          NPacc = 1.0 / (1.0 + (double)(toK - fromK));
          for(int k = fromK; k <= toK; k++)
          {
            certainty[(attributeKey) k] = NPacc;
            hasbeenset[(attributeKey) k] = true;
          }
        }
      } //}}}

      void distributeCertainties()
      { //{{{
        // ONLY FOR T_classes
        // Probability accumulation buffer
        double Pacc    = 0.0;
        // Number of state not set
        double Nnotset = 0.0;
        for(int k = T_FREE; k <= T_LIMIT; k++)
        {
          if (hasbeenset[(attributeKey) k])
          {
            Pacc = Pacc + certainty[(attributeKey) k];
          } else {
            Nnotset = Nnotset + 1.0;
          }
        }

        // Set the T_OBSTACLE value
        certainty[T_OBSTACLE] = (1.0 - Pacc - Nnotset * ATT_MIN_VAL);

        // The information source is considered consistant with \sum P_i = 1
        if (Nnotset == 0.0)
        {
          hasbeenset[T_OBSTACLE] = true;
        }

        // Distributing on left classes
        if (certainty[T_OBSTACLE] >= 0.0 && Nnotset > 0.0)
        {
          hasbeenset[T_OBSTACLE] = true;
          // Setting equi-rest for other traversability state
          Pacc = ATT_MIN_VAL;// (1.0 - Pacc)/Nnotset; //equi-rest
          for(int k = T_FREE; k <= T_LIMIT; k++)
          {
            if (! hasbeenset[(attributeKey)k])
            {
              certainty[(attributeKey)k]  = Pacc;
              hasbeenset[(attributeKey)k] = true;
            }
          }
        } else {
          if (certainty[T_OBSTACLE] < 0.0)
          {
            // Big problem and one solution is
            certainty[T_OBSTACLE] = 0.0;
            hasbeenset[T_OBSTACLE] = true;
            for(int k = T_FREE; k < ATT_MAX; k++)
            {
              if (! hasbeenset[(attributeKey)k])
              {
                certainty[(attributeKey)k]  = 0.0;
                hasbeenset[(attributeKey)k] = true;
              }
            }
            normalizeCertainties(ATT_BEGIN, (attributeKey)(ATT_MAX-1));
          } //else { all is ok. all other classes were already set}
        }

        updateEntropy(T_CLASS);
        updateEntropy(T_SYMBOL);
      } //}}}

      void updateEntropy(attributeClass _ac) 
      {/*{{{*/
        double tmp = 0.0;
        infotropy[_ac] = 0.0;
        // Full calculus of entropy on the given class - ready for multi states
        if(_ac == T_CLASS)
        {
          // Composing the full tri-state entropy
          for (int k = T_FREE; k <= T_OBSTACLE; k++)
          {
            if ((certainty[(attributeKey)k] <= ATT_MAX_VAL)
              &&
                (certainty[(attributeKey)k] >= ATT_MIN_VAL))
            {
              tmp = - certainty[(attributeKey)k] * log (certainty[(attributeKey)k]);
            } else {
              if ((certainty[(attributeKey)k] > ATT_MAX_VAL))
              {
                tmp = - ATT_MAX_VAL * log (ATT_MAX_VAL);
              } else {
                tmp = - ATT_MIN_VAL * log (ATT_MIN_VAL);
              }

            }
            infotropy[_ac] = infotropy[_ac] + tmp;
          }
          infotropy[_ac] = infotropy[_ac];// / MAX_ENTROPY_TRI;
        }

        // Specific entropy based on the symbolic of each terrain
        // classe. We have two symbols "traversable" and "obstructed"
        // and we calculate an enntropy between them.
        if(_ac == T_SYMBOL)
        {
          // Composing the bi-state entropy
          for (int k = T_FREE; k <= T_LIMIT; k++)
          {
            tmp = tmp + certainty[(attributeKey)k];
          }
          if (tmp >= ATT_MIN_VAL && tmp <= ATT_MAX_VAL)
          {
            tmp = - tmp * log (tmp);
          } else {
            if ( tmp > ATT_MAX_VAL)
            {
              tmp = - ATT_MAX_VAL * log (ATT_MAX_VAL);
            } else {
              tmp = - ATT_MIN_VAL * log (ATT_MIN_VAL);
            }

          }
          // Calculating free/obst entropy
          if (certainty[T_OBSTACLE] >= ATT_MIN_VAL && certainty[T_OBSTACLE] <= ATT_MAX_VAL)
          {
            infotropy[_ac] = tmp
            - certainty[T_OBSTACLE] * log (certainty[T_OBSTACLE]);
          } else {
            if (certainty[T_OBSTACLE] > ATT_MIN_VAL)
            {
              infotropy[_ac] = tmp - ATT_MAX_VAL * log (ATT_MAX_VAL);
            } else {
              infotropy[_ac] = tmp - ATT_MIN_VAL * log (ATT_MIN_VAL);
            }
          }
          infotropy[_ac] = infotropy[_ac];// / MAX_ENTROPY_BINARY;
        }
      }/*}}}*/

      bool hasBeenSet(attributeKey _at)
      {//{{{
        return hasbeenset[_at];
      }//}}}

      void reset()
      { //{{{
        for (int k = ATT_BEGIN; k < ATT_MAX; k++)
        {
          certainty[(attributeKey)k] = 0.0;
          hasbeenset[(attributeKey)k] = false;
        }
        infotropy[T_SYMBOL] = 0.0;
        infotropy[T_CLASS] = 0.0;
      } //}}}

      void print(attributeKey _at)
      {/*{{{*/
        std::cout << "- Attribute (" << _at << ", " << certainty[_at] << ")" << std::endl;
      }/*}}}*/

      // ---- Operators
      Attributes& operator=(const Attributes& rhs)
      { //{{{
        for (int m = T_SYMBOL; m < CLASS_MAX; m++)
        {
          infotropy[(attributeClass)m]  = rhs.infotropy[(attributeClass)m];
        }

        for (int k = ATT_BEGIN; k < ATT_MAX; k++)
        {
          certainty[(attributeKey)k]  = rhs.certainty[(attributeKey)k];
          hasbeenset[(attributeKey)k] = rhs.hasbeenset[(attributeKey)k];
        }

        return (*this);
      } //}}}

      friend std::ostream& operator<<(std::ostream& out, const Attributes &att)
      { // {{{
        for (int k = ATT_BEGIN; k < ATT_MAX; k++)
        {
          out << (att.hasbeenset[(attributeKey)k]?"t[":"f[") << att.certainty[(attributeKey)k] << "]";
        }
        return out;
      } // }}}
  }; //}}}

    typedef struct Attributes Attributes;

  }
}

#endif /* LGL_ATTRIBUTES_HPP */