CSO.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 "CSOBase/CSOGroup.h"
#include "CSOBase/CSOSeedPoint.h"
#include "CSOBase/CSOPathPoints.h"
#include "CSOBase/CSOBoundingBox.h"
 
 
ML_START_NAMESPACE
 
 
// Forward declaration.
class CSOList;
class CSOManager;
 
 
 
class MLCSO_EXPORT CSO
{
 
public:
 
  CSO();
  CSO(CSOList* csoList);
  CSO(const CSO &cso, CSOList* csoList=nullptr, unsigned int csoId = INVALID_CSO_ID);
  virtual ~CSO();
 
 
  /* METHODS */
 
 
 
  void reverseSeedPointOrder();
 
  void resortSeedPointsClockwise();
 
  inline void storeInUndoManager() { setInsertRemoveSeedPointCommand(); }
  void storeVisualAttributesInUndoManager();
 
  CSOManager* getManager() const;
 
  void applyTransformationMatrix(const Matrix4& matrix);
  void moveSeedPointsAndPathPoints(const Vector3& offset, int timepoint);
  void moveSeedPointsAndPathPoints(double dx, double dy, double dz, int timepoint);
  void moveSeedPointsAndPathPoints(const Vector3& offset);
  void moveSeedPointsAndPathPoints(double dx, double dy, double dz);
 
  void setAbsoluteMovementCommand(double fromX, double fromY, double fromZ, double toX, double toY, double toZ, int fromTimePointIndex, int toTimePointIndex);
  void moveSingleSeedPoint(CSOSeedPoint* sPoint, double dx, double dy, double dz);
  void setAbsoluteSeedPointMovementCommand();
  void setSeedPointsAndPathPoints(const CSO* cso);
 
  CSOSeedPoint* appendSeedAndPathPointNoEvent();
  CSOSeedPoint* appendSeedAndPathPointNoEvent(const Vector3& position);
 
  CSOSeedPoint* appendSeedAndPathPoint();
  CSOSeedPoint* appendSeedAndPathPoint(const Vector3& position);
  void setSeedAndPathPoints(unsigned int numSeedPoints, bool isClosed=true);
  void setInitialSeedAndPathPointsNoEvent(unsigned int numSeedPoints, bool isClosed = true);
  CSOPathPoints* insertPathPointsEndStart();
  CSOPathPoints* insertPathPointsEndStartNoEvent();
  CSOSeedPoint* appendSeedPoint();
  CSOPathPoints* appendPathPoints();
  void removeSeedPoint(CSOSeedPoint* sPoint);
  void removeAllSeedAndPathPoints();
  CSOSeedPoint* insertSeedPointAt(CSOPathPoints* toBeSplitPath, const Vector3& toInsertPos);
  void setInsertRemoveSeedPointCommand();
 
  CSOSeedPoint* getSeedPointAt(unsigned int index) const;
  inline CSOSeedPoint* getFirstSeedPoint() const { if (numSeedPoints()) { return _seedPointList[0];                } else { return nullptr; } }
  inline CSOSeedPoint* getLastSeedPoint()  const { if (numSeedPoints()) { return _seedPointList[numSeedPoints()-1];} else { return nullptr; } }
  inline unsigned int numSeedPoints() const { return static_cast<unsigned int>(_seedPointList.size());  }
  bool getSeedPointIndex(CSOSeedPoint* sPoint, unsigned int& index) const;
  inline unsigned int numPathPointLists() const  { return static_cast<unsigned int>(_pathPointsList.size()); }
  void fillPathPointCoordinatesFlattened(std::vector<Vector3>& pathPointCoords) const;
  void fillPathPointCoordinatesFlattened(std::vector<Vector4>& pathPointCoordsAndValues) const;
  inline CSOPathPoints* getPathPointsAt(unsigned int index) const { return _pathPointsList[index]; }
  unsigned int getTotalNumPathPoints() const;
  unsigned int getTotalNumUniquePathPoints() const;
 
  void swapPoints(CSO& other);
 
 
  bool isSelected() const;
 
  void addSelectedSeedPoint(CSOSeedPoint* sPoint);
  void setSelectedSeedPoint(CSOSeedPoint* sPoint);
  void setSeedPointSelectedAt(unsigned int index);
  bool isSelectedSeedPoint(CSOSeedPoint* sPoint) const;
  void clearSelectedSeedPoints();
  unsigned int getNumSelectedSeedPoints() const;
  CSOSeedPoint* getSelectedSeedPointAt(unsigned int index) const;
 
  bool addToGroup(CSOGroup& group, bool useUndoRedo=true);
  void removeFromGroup(CSOGroup &group, bool useUndoRedo=true);
  bool isInGroup(const CSOGroup* group) const;
  // Returns whether this CSO is in a same Group as the given CSO.
  bool isInSameGroupsAs(CSO* cso) const;
  bool isInGroup(unsigned int groupId) const;
  inline unsigned int numGroups() const { return static_cast<unsigned int>(_csoGroupIds.size()); }
  CSOGroup* getGroupAt(unsigned int index) const;
  inline unsigned int getGroupIdAt(unsigned int index) const { return _csoGroupIds[index]; }
  void removeFromAllGroups();
 
  void _addReferenceToGroup(const CSOGroup& group);
  void _removeReferenceToGroup(const CSOGroup &group);
 
  inline void setType(const std::string& type) { _type = type; }
  inline const std::string& getType() const { return _type; }
  inline void setSubType(const std::string& subtype) { _subtype = subtype; }
  inline const std::string& getSubType() const { return _subtype; }
  inline void setCreatorId(int id) { _creatorId = id; }
  inline int getCreatorId() const { return _creatorId; }
 
  inline void setUserData(const std::string& name, Variant value) { _attributes.setUserData(name, value); }
  inline Variant getUserData(const std::string& name) const { return _attributes.getUserData(name); }
  inline void getUserDataNames(std::vector< std::string >& names) const { _attributes.getUserDataNames(names); }
  inline void removeUserData(const std::string& name) { _attributes.removeUserData(name); }
 
  const CSOBoundingBox& getWorldBoundingBox() const;
  CSOBoundingBox getVoxelBoundingBox(const Matrix4& worldToVoxelMatrix, size_t hashKey) const;
  CSOBoundingBox getVoxelBoundingBoxSeedPoints(const Matrix4& worldToVoxelMatrix, size_t hashKey) const;
  inline bool isInPlane() const { Vector3 dummy; return isInPlane(dummy); }
  bool isInPlane(Vector3& planeNormal) const;
  inline const Vector3& getPlaneNormal() const { _computeIsInPlane(); return _planeNormal; }
  inline void computePlaneNormal() { _computeIsInPlane(); }
  inline void setIsInPlane(bool status) { _isInPlane = status; }
  inline void setPlaneNormal(const Vector3& planeNormal) { _planeNormal = planeNormal; _hasValidPlaneStatus = true; }
  inline void invalidatePlaneNormal() { _hasValidPlaneStatus = false; }
  double getLength() const;
  inline double getArea() const { _computeArea(); return _area; }
  inline void invalidateArea() { _hasValidArea = false; }
  bool isSelfIntersecting() const;
  void setIsClosed(bool isClosed);
  inline bool isClosed() const { return _isClosed; }
  bool isPoint() const;
  bool isEmpty() const;
  inline void setIsFinished(bool isFinished) { _isFinished = isFinished; }
  inline bool getIsFinished() const { return _isFinished; }
  inline void setNeedsInterpolation(bool needsInterpolation) { _needsInterpolation = needsInterpolation; }
  inline bool getNeedsInterpolation() const { return _needsInterpolation; }
  void determineNeedsInterpolation();
  void setNeedInterpolationAllSeedPoints(bool needsInterpolation);
  inline void setNeedInterpolation(CSOSeedPoint* seedPoint) { if (seedPoint != nullptr) { seedPoint->setNeedsInterpolation(true); _needsInterpolation = true; } }
  void pathChanged();
 
  void setCSOList(CSOList* csoList);
  inline CSOList* getCSOList() const { return _csoList; }
  inline unsigned int getId() const  { return _uniqueId; }
 
  void setLabel(const std::string& label);
  inline const std::string& getLabel() const { return _attributes.label; }
  void setDescription(std::string description);
  inline const std::string& getDescription() const { return _attributes.description; }
 
  void setTimePointIndex(MLint index);
  int getTimePointIndex() const;
  void setShowState(bool state);
  bool getShowState() const;
  void setVoxelizeState(bool state);
  bool getVoxelizeState() const;
  void setEditableState(bool state);
  bool getEditableState() const;
  void setPathPointStyle(CSOPathPointsStyle style);
  inline void setPathPointStyle(int style) { setPathPointStyle(static_cast<CSOPathPointsStyle>(style)); }
  CSOPathPointsStyle getPathPointStyle() const;
  void setPathPointWidth(float width);
  float getPathPointWidth() const;
  void setPathPointColor(const Vector3& color);
  Vector3 getPathPointColor() const;
  void setPathPointAlpha(float alpha);
  float getPathPointAlpha() const;
  void setSeedPointStyle(int style);
  int getSeedPointStyle() const;
  void setSeedPointSize(float size);
  float getSeedPointSize() const;
  void setSeedPointColor(const Vector3& color);
  Vector3 getSeedPointColor() const;
  void setSeedPointAlpha(float alpha);
  float getSeedPointAlpha() const;
 
  void setVoxelWriteMode(int mode);
  int getVoxelWriteMode() const;
  void setVoxelWriteValue(float value);
  float getVoxelWriteValue() const;
 
  void setAllValuesTo(float value);
 
  inline int getPrivateTimePointIndex() const { return _attributes.timePointIndex; }
  inline bool getPrivateShowState() const { return _attributes.showState; }
  inline bool getPrivateVoxelizeState() const { return _attributes.voxelizeState; }
  inline bool getPrivateEditableState() const { return _attributes.editableState; }
  inline int getPrivatePathPointStyle() const { return _attributes.pathPointStyle; }
  inline float   getPrivatePathPointWidth() const { return _attributes.pathPointWidth; }
  inline Vector3 getPrivatePathPointColor() const { return _attributes.pathPointColor; }
  inline float   getPrivatePathPointAlpha() const { return _attributes.pathPointAlpha; }
  inline int     getPrivateSeedPointStyle() const { return _attributes.seedPointStyle; }
  inline float   getPrivateSeedPointSize() const { return _attributes.seedPointSize; }
  inline Vector3 getPrivateSeedPointColor() const { return _attributes.seedPointColor; }
  inline float   getPrivateSeedPointAlpha() const { return _attributes.seedPointAlpha; }
 
  inline int getPrivateVoxelWriteMode() const { return _attributes.voxelWriteMode; }
  inline float getPrivateVoxelWriteValue() const { return _attributes.voxelWriteValue; }
 
 
  inline void setPrivateIsFinished(bool isFinished) { _isFinished = isFinished; }
  inline void setPrivateIsClosed(bool isClosedP) { _isClosed = isClosedP; }
  inline void setPrivateIsInPlane(bool isInPlaneP) { _isInPlane = isInPlaneP; }
  inline void setPrivateBoundingBox(const CSOBoundingBox& bb) { _worldBoundingBox = bb; _hasValidWorldBoundingBox = true; }
  inline void setPrivatePlaneNormal(const Vector3& normal) { _planeNormal = normal; _hasValidPlaneStatus = true; }
  void setId(unsigned int newId);
 
  void setAttributesFrom(const CSO* const cso);
 
  bool saveAttributes(std::ostream& outStream, bool useAscii=false);
 
  void loadAttributes(std::istream& inStream, short version, bool swapBytes, bool useAscii=false);
 
  const CSOAttributes& getAttributes() const { return _attributes;  }
 
  CSOAttributes& getWritableAttributes()  { return _attributes; }
 
#if ML_DEPRECATED_SINCE(3,5,0)
  inline ML_DEPRECATED void moveSeedPoints(double dx, double dy, double dz, int timepoint) {
    moveSeedPointsAndPathPoints(dx,dy,dz,timepoint);
  }
  inline ML_DEPRECATED void setLineStyle(CSOLineStyle style) { setPathPointStyle(style); }
  inline ML_DEPRECATED CSOLineStyle getLineStyle() const { return static_cast<CSOLineStyle>(getPathPointStyle()); }
  inline ML_DEPRECATED void setColor(const Vector3& color) { setPathPointColor(color); }
  inline ML_DEPRECATED Vector3 getColor() const { return getPathPointColor(); }
  inline ML_DEPRECATED void setAlpha(float alpha) { setPathPointAlpha(alpha); }
  inline ML_DEPRECATED float getAlpha() const { return getPathPointAlpha(); }
  inline ML_DEPRECATED void setLineWidth(float width) { setPathPointWidth(width); }
  inline ML_DEPRECATED float getLineWidth() const { return getPathPointWidth(); }
  inline ML_DEPRECATED void setMarkerMode(int mode) { setSeedPointStyle(mode); }
  inline ML_DEPRECATED int getMarkerMode() const { return getSeedPointStyle(); }
  inline ML_DEPRECATED void setMarkerColor(const Vector3& color) { setSeedPointColor(color); }
  inline ML_DEPRECATED Vector3 getMarkerColor() const { return getSeedPointColor(); }
  inline ML_DEPRECATED void setMarkerAlpha(float alpha) { setSeedPointAlpha(alpha); }
  inline ML_DEPRECATED float getMarkerAlpha() const { return getSeedPointAlpha();}
  inline ML_DEPRECATED void setMarkerSize(float size) { setSeedPointSize(size); }
  inline ML_DEPRECATED float getMarkerSize() const { return getSeedPointSize(); }
  inline ML_DEPRECATED CSOLineStyle getPrivateLineStyle() const { return static_cast<CSOLineStyle>(getPrivatePathPointStyle()); }
  inline ML_DEPRECATED Vector3 getPrivateColor() const { return getPrivatePathPointColor(); }
  inline ML_DEPRECATED float getPrivateAlpha() const { return getPrivatePathPointAlpha(); }
  inline ML_DEPRECATED float getPrivateLineWidth() const { return getPrivatePathPointWidth(); }
  inline ML_DEPRECATED int getPrivateMarkerMode() const { return getPrivateSeedPointStyle(); }
  inline ML_DEPRECATED Vector3 getPrivateMarkerColor() const { return getPrivateSeedPointColor(); }
  inline ML_DEPRECATED float getPrivateMarkerAlpha() const { return getPrivateSeedPointAlpha(); }
  inline ML_DEPRECATED float getPrivateMarkerSize() const { return getPrivateSeedPointSize(); }
  inline ML_DEPRECATED void removeGroup(CSOGroup& group, bool useUndoRedo = true) { removeFromGroup(group, useUndoRedo); }
  inline ML_DEPRECATED void addGroup(CSOGroup& group, bool useUndoRedo = true) { addToGroup(group, useUndoRedo); }
  inline ML_DEPRECATED void removeAllGroups() { removeFromAllGroups(); }
#endif
 
protected:
 
private:
 
  template <class Method>
  int getOverrideGroupIndexForAttribute(Method method) const; // (defined in source file)
 
  template<class T>
  void _fillPathPointCoordinatesFlattened(std::vector<T>& pathPointCoords) const;
 
  /* MEMBER VARIABLES */
 
  unsigned int _uniqueId;
 
  std::vector<CSOSeedPoint*> _seedPointList;
  std::vector<CSOPathPoints*> _pathPointsList;
 
  friend class CSOList;
 
  CSOList* _csoList{};
 
  std::vector<unsigned int> _csoGroupIds;
 
  std::vector<unsigned int> _selectedSeedPointsIndices;
 
  std::string _type{"TYPE_NOT_SET"};
  std::string _subtype{"SUB_TYPE_NOT_SET"};
  int        _creatorId{};
 
  CSOAttributes _attributes;
 
  mutable bool _hasValidWorldBoundingBox{};
  mutable CSOBoundingBox _worldBoundingBox;
 
  mutable boost::unordered_map < MatrixHashPair, CSOBoundingBox, MatrixHashFunction > _voxelBoundingBoxCache;
  mutable boost::unordered_map < MatrixHashPair, CSOBoundingBox, MatrixHashFunction > _voxelSeedPointBoundingBoxCache;
 
  mutable bool _hasValidPlaneStatus{};
  mutable bool _hasValidArea{};
 
  mutable bool _hasValidSelfIntersectingStatus{};
 
 
  bool _isFinished{};
  bool _isClosed{};
  mutable bool _isInPlane{};
  mutable Vector3 _planeNormal;
 
  bool _needsInterpolation{};
 
  mutable double _area{};
 
  mutable bool _isSelfIntersecting{};
 
 
  /* METHODS */
 
  void _computeIsInPlane() const;
  void _computeArea() const;
  void _resetSeedPathLinks();
};
 
 
ML_END_NAMESPACE