CSOGroup.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 "CSOAttributes.h"
#include "CSOBoundingBox.h"
#include "CSORules/CSOGroupRules.h"
 
ML_START_NAMESPACE
 
// forward declarations
class CSO;
class CSOList;
 
 
class MLCSO_EXPORT CSOGroup
{
  // The friend is needed to let the reader and writer have access to
  // the deprecated and private functions
  friend class CSOList;
 
public:
 
  CSOGroup();
  CSOGroup(CSOList* csoList);
  CSOGroup(const CSOGroup &group, int groupId=-1, CSOList* csoList=nullptr);
  ~CSOGroup();
 
  inline CSOGroupRules& getRules() { return _rules; }
 
  bool addCSO(CSO& cso, bool useUndoRedo=true);
  void removeCSO(CSO& cso, bool useUndoRedo=true);
  void removeAllCSO(bool useUndoRedo=true, bool shouldApplyRemoveFromGroupRule=true);
  bool contains(const CSO *cso) const;
  inline unsigned int numCSOs() const   { return static_cast<unsigned int>(_memberCSOIds.size()); }
  CSO* getCSOAt(unsigned int index) const;
  inline unsigned int getCSOIdAt(unsigned int index) const { return _memberCSOIds[index]; }
 
  void _addReferenceToCSO(const CSO& cso);
  void _removeReferenceToCSO(const CSO& cso);
 
  inline unsigned int getId() const { return _uniqueId; }
  inline void setId(unsigned int id) { _uniqueId = id; }
  void setCSOList(CSOList* csoList);
  inline CSOList* getCSOList() const { return _csoList; }
 
  bool isSelected() const;
 
  void setLabel(const std::string& label);
  inline const std::string& getLabel() const { return _attributes.label; }
  void setDescription(const std::string& description);
  inline const std::string& getDescription() const { return _attributes.description; }
 
  inline int getTimePointIndex() const { return _attributes.timePointIndex; }
  void setTimePointIndex(MLint timePointIndex);
  void setShowState(bool state);
  inline bool getShowState() const { return _attributes.showState; }
  void setVoxelizeState(bool state);
  inline bool getVoxelizeState() const { return _attributes.voxelizeState; }
  void setEditableState(bool state);
  inline bool getEditableState() const { return _attributes.editableState; }
  inline CSOPathPointsStyle getPathPointStyle() const { return static_cast<CSOPathPointsStyle>(_attributes.pathPointStyle); }
  void setPathPointStyle(CSOPathPointsStyle style);
  inline void setPathPointStyle(int style) { setPathPointStyle(static_cast<CSOPathPointsStyle>(style)); }
  inline float getPathPointWidth() const { return _attributes.pathPointWidth; }
  void setPathPointWidth(float width);
  inline const Vector3& getPathPointColor() const { return _attributes.pathPointColor; }
  void setPathPointColor(const Vector3& color);
  inline float getPathPointAlpha() const { return _attributes.pathPointAlpha; }
  void setPathPointAlpha(float alpha);
  inline int getSeedPointStyle() const { return _attributes.seedPointStyle; }
  void setSeedPointStyle(int seedPointStyle);
  inline float getSeedPointSize() const { return _attributes.seedPointSize; }
  void setSeedPointSize(float size);
  inline const Vector3& getSeedPointColor() const { return _attributes.seedPointColor; }
  void setSeedPointColor(const Vector3& color);
  inline float getSeedPointAlpha() const { return _attributes.seedPointAlpha; }
  void setSeedPointAlpha(float alpha);
  inline int getVoxelWriteMode() const { return _attributes.voxelWriteMode; }
  void setVoxelWriteMode(int mode);
  inline float getVoxelWriteValue() const { return _attributes.voxelWriteValue; }
  void setVoxelWriteValue(float value);
 
  void setUserData(const std::string& name, Variant value) { _attributes.setUserData(name, value); }
  Variant getUserData(const std::string& name) const { return _attributes.getUserData(name); }
  void getUserDataNames(std::vector< std::string >& names) const { _attributes.getUserDataNames(names); }
  void removeUserData(const std::string& name) { _attributes.removeUserData(name); }
 
  inline bool getUseTimePointIndex() const { return _useTimePointIndex; }
  inline void setUseTimePointIndex(bool state) { _useTimePointIndex = state; }
  inline bool getUseShowState() const { return _useShowState; }
  inline void setUseShowState(bool state) { _useShowState = state; }
  inline bool getUseVoxelizeState() const { return _useVoxelizeState; }
  inline void setUseVoxelizeState(bool state) { _useVoxelizeState = state; }
  inline bool getUseEditableState() const { return _useEditableState; }
  inline void setUseEditableState(bool state) { _useEditableState = state; }
  inline bool getUseSeedPointStyle() const { return _useSeedPointStyle; }
  inline void setUseSeedPointStyle(bool state) { _useSeedPointStyle = state; }
  inline bool getUseSeedPointSize() const { return _useSeedPointSize; }
  inline void setUseSeedPointSize(bool state) { _useSeedPointSize = state; }
  inline bool getUseSeedPointColor() const { return _useSeedPointColor; }
  inline void setUseSeedPointColor(bool state) { _useSeedPointColor = state; }
  inline bool getUseSeedPointAlpha() const { return _useSeedPointAlpha; }
  inline void setUseSeedPointAlpha(bool state) { _useSeedPointAlpha = state; }
  inline bool getUsePathPointStyle() const { return _usePathPointStyle; }
  inline void setUsePathPointStyle(bool state) { _usePathPointStyle = state; }
  inline bool getUsePathPointWidth() const { return _usePathPointWidth; }
  inline void setUsePathPointWidth(bool state) { _usePathPointWidth = state; }
  inline bool getUsePathPointColor() const { return _usePathPointColor; }
  inline void setUsePathPointColor(bool state) { _usePathPointColor = state; }
  inline bool getUsePathPointAlpha() const { return _usePathPointAlpha; }
  inline void setUsePathPointAlpha(bool state) { _usePathPointAlpha = state; }
  inline bool getUseVoxelWriteMode() const { return _useVoxelWriteMode; }
  inline void setUseVoxelWriteMode(bool state) { _useVoxelWriteMode = state; }
  inline bool getUseVoxelWriteValue() const { return _useVoxelWriteValue; }
  inline void setUseVoxelWriteValue(bool state) { _useVoxelWriteValue = state; }
 
  const CSOBoundingBox& getBoundingBox();
  CSOBoundingBox getVoxelBoundingBox(const Matrix4& worldToVoxelMatrix, size_t hashKey);
 
  void groupChanged();
 
  bool saveAttributes(std::ostream& outStream, bool useAscii=false);
  void loadAttributes(std::istream& inStream, short version, bool swapBytes, bool useAscii=false);
 
 
private:
 
#ifdef ML_DEPRECATED
#define ML_DEPRECATED_TMP ML_DEPRECATED
#undef ML_DEPRECATED
#endif
 
#define ML_DEPRECATED
 
  inline ML_DEPRECATED unsigned int numCSO() const  { return numCSOs(); }
  inline ML_DEPRECATED CSOPathPointsStyle getLineStyle() const { return getPathPointStyle(); }
  inline ML_DEPRECATED void setLineStyle(CSOPathPointsStyle lineStyle) { setPathPointStyle(lineStyle); }
  inline ML_DEPRECATED const Vector3& getColor() const { return getPathPointColor(); }
  inline ML_DEPRECATED void setColor(const Vector3& color) { setPathPointColor(color); }
  inline ML_DEPRECATED float getAlpha() const { return getPathPointAlpha(); }
  inline ML_DEPRECATED void setAlpha(float alpha) { setPathPointAlpha(alpha); }
  inline ML_DEPRECATED float getLineWidth() const { return getPathPointWidth(); }
  inline ML_DEPRECATED void setLineWidth(float lineWidth) { setPathPointWidth(lineWidth); }
  inline ML_DEPRECATED int getMarkerMode() const { return getSeedPointStyle(); }
  inline ML_DEPRECATED void setMarkerMode(int markerMode) { setSeedPointStyle(markerMode); }
  inline ML_DEPRECATED const Vector3& getMarkerColor() const { return getSeedPointColor(); }
  inline ML_DEPRECATED void setMarkerColor(const Vector3& markerColor) { setSeedPointColor(markerColor); }
  inline ML_DEPRECATED float getMarkerAlpha() const { return getSeedPointAlpha(); }
  inline ML_DEPRECATED void setMarkerAlpha(float markerAlpha) { setSeedPointAlpha(markerAlpha); }
  inline ML_DEPRECATED float getMarkerSize() const { return getSeedPointSize(); }
  inline ML_DEPRECATED void setMarkerSize(float markerSize) { setSeedPointSize(markerSize);}
  inline ML_DEPRECATED bool getUseVisuals() const {
    return _usePathPointStyle || _usePathPointWidth || _usePathPointColor || _usePathPointAlpha;
  }
  inline ML_DEPRECATED void setUseVisuals(bool state) {
    _usePathPointAlpha = _usePathPointColor =  _usePathPointStyle = _usePathPointWidth = state;
  }
  inline ML_DEPRECATED bool getUseVoxelWrite() const {
    return _useVoxelWriteValue || _useVoxelWriteMode;
  }
  inline ML_DEPRECATED void setUseVoxelWrite(bool state) {
    _useVoxelWriteMode = _useVoxelWriteValue = state;
  }
  inline ML_DEPRECATED bool getUseMarkerSettings() const {
    return _useSeedPointAlpha || _useSeedPointColor || _useSeedPointSize || _useSeedPointStyle;
  }
  inline ML_DEPRECATED void setUseMarkerSettings(bool state) {
    _useSeedPointAlpha = _useSeedPointColor = _useSeedPointSize = _useSeedPointStyle = state;
  }
#ifdef ML_DEPRECATED_TMP
#define ML_DEPRECATED ML_DEPRECATED_TMP
#undef ML_DEPRECATED_TMP
#endif
private:
 
  unsigned int _uniqueId;
 
  std::vector<unsigned int>_memberCSOIds;
 
  CSOList* _csoList;
 
  CSOAttributes _attributes;
 
  CSOGroupRules _rules;
 
  bool _useTimePointIndex;
  bool _useShowState;
  bool _useVoxelizeState;
  bool _useEditableState;
 
  bool _useSeedPointStyle;
  bool _useSeedPointSize;
  bool _useSeedPointColor;
  bool _useSeedPointAlpha;
 
  bool _usePathPointStyle;
  bool _usePathPointWidth;
  bool _usePathPointColor;
  bool _usePathPointAlpha;
 
  bool _useVoxelWriteMode;
  bool _useVoxelWriteValue;
 
  bool _hasValidWorldBoundingBox;
  CSOBoundingBox _worldBoundingBox;
  boost::unordered_map < size_t, CSOBoundingBox > _voxelBoundingBoxCache;
};
 
ML_END_NAMESPACE