WEMPrimitiveValueList.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "MLWEMIncludes.h"
#include "WEMPersistenceHelper.h"
 
ML_START_NAMESPACE
 
 
class MLWEM_EXPORT WEMPrimitiveValueList
{
public:
 
  WEMPrimitiveValueList();
 
  WEMPrimitiveValueList(std::string description);
 
  WEMPrimitiveValueList(const WEMPrimitiveValueList& valueList);
 
  ~WEMPrimitiveValueList();
 
  void copyProperties(const WEMPrimitiveValueList& valueList);
  void copyFrom(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.0; }
  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 resize(unsigned int numValues);
 
  void saveTo(OutStreamWrapper& ostreamWrapper);
  void loadFrom(FileMapWrapper& mapper, short version);
 
  inline double getStdValue() const { return getStandardDeviationValue(); }
  inline double getRMSDValue() const { return getRootMeanSquareDeviationValue(); }
 
  std::vector<double>& values() { return _values; }
 
  const std::vector<double>& constValues() const { return _values; }
 
  void removeLastEntry();
 
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