MeVisLab/Standard/Sources/ML/MLWEM/WEMBase/WEMPrimitiveValueList.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

#ifndef __WEMPrimitiveValueList_H
#define __WEMPrimitiveValueList_H

#include "MLWEMIncludes.h"


ML_START_NAMESPACE



class MLWEM_EXPORT WEMPrimitiveValueList
{

public:

  WEMPrimitiveValueList();

  WEMPrimitiveValueList(std::string description);

  WEMPrimitiveValueList(const WEMPrimitiveValueList& valueList);

  ~WEMPrimitiveValueList();

  void copyProperties(const WEMPrimitiveValueList& valueList);

  inline std::string getDescription() const { return _description; }

  inline std::string getUnits()      const  { return _units; }
  inline void setUnits(std::string units) { _units = units; }

  inline PrimitiveValueListTypes getPrimitiveValueListType()      const                 { return _primitiveValueListType; }
  inline void setPrimitiveValueListType(PrimitiveValueListTypes primitiveValueListType) { _primitiveValueListType = primitiveValueListType; }

  bool isValid()const;
  inline unsigned int getNumValues() const { return static_cast<unsigned int>(_values.size()); }

  inline bool isPersistent() const            { return _persistent; }
  inline void setPersistence(bool persistent) { _persistent = persistent; }

  inline MLDataType getDataType() const        { return _dataType; }
  inline void setDataType(MLDataType dataType) { _dataType = dataType; }

  inline double getMinValue() const { return _minValue; }
  inline double getMaxValue() const { return _maxValue; }
  inline double getMeanValue() const { return _meanValue; }
  inline double getStandardDeviationValue() const { return _stdValue; }
  inline double getRootMeanSquareDeviationValue() const { return _rmsdValue; }

  inline void setMinMaxValue(double minValue, double maxValue) { _minValue = minValue; _maxValue = maxValue; _fixedMinMaxValues = true; }
  void computeAndSetMinMaxFixedValues();
  void clampMinValue(double minValue);
  void clampMaxValue(double maxValue);
  
  void updateStatistics();

  inline double getValue(unsigned int index) const { return (index < _values.size()) ? _values[index] : 0.0f; }
  void setValue(unsigned int index, double value);
  inline void appendValue(double value) { _values.push_back(value); }
  inline void setValueFrom(unsigned int index, unsigned int source) { _values[index] = _values[source]; }
  inline void addValueFrom(unsigned int index, unsigned int source, double modifier) { _values[index] += _values[source] * modifier; }

  void resetValues();
  void initializeValues(unsigned int number, double value);
  void multiplyValues(double modifier);
  void extendValues(unsigned int number, double value);

  void saveTo(std::ostream& outstream);
  unsigned int loadFrom(std::istream& instream, short version, bool swapBytes);
  unsigned int loadFrom(char* map, short version, bool swapBytes);



  inline double getStdValue() const { return getStandardDeviationValue(); }
  inline double getRMSDValue() const { return getRootMeanSquareDeviationValue(); }

private:

  std::string _description;

  std::string _units;

  PrimitiveValueListTypes _primitiveValueListType; 

  MLDataType _dataType;

  bool _fixedMinMaxValues;

  double _minValue;
  double _maxValue;  
  double _meanValue;
  double _stdValue;
  double _rmsdValue;

  std::vector<double> _values;

  bool _persistent;

};



ML_END_NAMESPACE


#endif // __WEMPrimitiveValueList_H