MeVisLab/Standard/Sources/ML/MLCSO/CSOBase/CSOGroup.h

Go to the documentation of this file.

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

//----------------------------------------------------------------------------------

#ifndef __CSOGroup_H
#define __CSOGroup_H

#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
{

public:

  CSOGroup();
  CSOGroup(CSOList* csoList);
  CSOGroup(const CSOGroup &group, int groupId=-1);
  ~CSOGroup();

  inline CSOGroupRules& getRules() { return _rules; }


  void addCSO(CSO* cso);
  void removeCSO(CSO* cso);
  void removeAllCSO();
  bool contains(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]; }


  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(int 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 CSOLineStyle getPathPointStyle() const { return static_cast<CSOLineStyle>(_attributes.pathPointStyle); }
  void setPathPointStyle(CSOLineStyle style);
  inline void setPathPointStyle(int style) { setPathPointStyle(static_cast<CSOLineStyle>(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();
  const CSOBoundingBox& getVoxelBoundingBox(const Matrix4& worldToVoxelMatrix);

  void groupChanged();

  bool saveAttributes(std::ostream& outStream, bool useAscii=false);
  void loadAttributes(std::istream& inStream, short version, bool swapBytes, bool useAscii=false);


#ifdef ML_DEPRECATED



  inline ML_DEPRECATED unsigned int numCSO() const  { return numCSOs(); }
  inline ML_DEPRECATED CSOLineStyle getLineStyle() const { return getPathPointStyle(); }
  inline ML_DEPRECATED void setLineStyle(CSOLineStyle 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;
  }
#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;

  Matrix4 _lastRecentWorldToVoxelMatrix;

  bool _hasValidWorldBoundingBox;
  bool _hasValidVoxelBoundingBox;


  CSOBoundingBox _worldBoundingBox;
  CSOBoundingBox _voxelBoundingBox;
};



ML_END_NAMESPACE



#endif // __CSOGroup_H