CSOAttributes.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 "MLCSOIncludes.h"
#include "CSODefines.h"
#include "CSOPathPoints.h"
 
 
#include <mlVariant.h>
 
 
ML_START_NAMESPACE
 
class CSO;
class CSOGroup;
 
 
template < typename T >
bool CSOWriteValueToStream(std::ostream& out, const T& value, bool asBinary)
{
  Variant v(value);
  v.write(out, asBinary);
  if (!asBinary) { out << std::endl; }
  return !out.bad();
}
 
template <>
inline bool CSOWriteValueToStream<Variant>(std::ostream& out, const Variant& value, bool asBinary)
{
  value.write(out, asBinary);
  if (!asBinary) { out << std::endl; }
  return !out.bad();
}
 
template <>
inline bool CSOWriteValueToStream<CSOPathPoints>(std::ostream& out, const CSOPathPoints& value, bool asBinary)
{
  Variant numPathPoints(value.numPathPoints());
  numPathPoints.write(out, asBinary);
  if (!asBinary) { Variant::writeValue(out, " ", asBinary); }
 
  for (unsigned int k = 0; k < static_cast<unsigned int>(numPathPoints.toInt()); ++k)
  {
    Vector3 pos = value.getPosAt(k);
    for (unsigned int i = 0; i < 3; ++i)
    {
      Variant::writeValue(out, pos[i], asBinary);
      if (!asBinary) { Variant::writeValue(out, " ", asBinary); }
    }
  }
  if (!asBinary) { out << std::endl; }
  return !out.bad();
}
 
 
template < typename T >
bool CSOReadValueFromStream(std::istream& in, T& value, bool asBinary)
{
  Variant v;
  v.read(in, asBinary);
  if (!asBinary) { in.ignore(); }
  if (v.isValid())
  {
    value = v.asType<T>();
    return !in.bad();
  }
  else
  {
    return false;
  }
}
 
template <>
inline bool CSOReadValueFromStream<Variant>(std::istream& in, Variant& value, bool asBinary)
{
  value.read(in, asBinary);
  if (!asBinary) { in.ignore(); }
  return !in.bad();
}
 
template <>
inline bool CSOReadValueFromStream<CSOPathPoints>(std::istream& in, CSOPathPoints& value, bool asBinary)
{
  Variant numPathPoints;
  numPathPoints.read(in, asBinary);
  if (!numPathPoints.isValid())
  {
    return false;
  }
 
  for (unsigned int k = 0; k < static_cast<unsigned int>(numPathPoints.toInt()); ++k)
  {
    Vector3 pos;
    for (unsigned int i = 0; i < 3; ++i)
    {
      Variant::readValue(in, pos[i], asBinary);
    }
    value.appendPosition(pos);
  }
  if (!asBinary) { in.ignore(); }
  return !in.bad();
}
 
 
class MLCSO_EXPORT CSOAttributes
{
 
public:
 
  CSOAttributes();
  ~CSOAttributes();
 
  void reset();
 
  bool writeToStream(std::ostream& outStream, bool asBinary) const;
  bool readFromStream(std::istream& inStream, bool asBinary, short version);
 
  bool saveTo(std::ostream& outStream) const;
  bool saveToASCII(std::ostream& outStream) const;
 
  void loadFrom(std::istream& inStream, short version, bool swapBytes);
  void loadFromASCII(std::istream& inStream, short version);
 
  void setCSO(CSO* cso);
  void setCSOGroup(CSOGroup* group);
 
  std::string label;
  std::string description;
 
  int timePointIndex;
  bool showState;
  bool voxelizeState;
  bool editableState;
 
  Vector3 pathPointColor;
  float pathPointAlpha;
  int pathPointStyle;
  float pathPointWidth;
 
  int seedPointStyle;
  float seedPointSize;
  Vector3 seedPointColor;
  float seedPointAlpha;
 
  int voxelWriteMode;
  float voxelWriteValue;
 
  void setUserData(const std::string& name, Variant value);
  Variant getUserData(const std::string& name) const;
  void getUserDataNames(std::vector< std::string >& names) const;
  void removeUserData(const std::string& name);
 
 
private:
 
  void sendAttributesChangedPreEvent();
  void sendAttributesChangedPostEvent();
 
  CSO* _associatedCSO;
  CSOGroup* _associatedCSOGroup;
 
  std::map < std::string, Variant > _variantMap;
};
 
 
ML_END_NAMESPACE