CSOList.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 "CSO.h"
#include "CSOScopeEvents.h"
#include "CSOEvent.h"
#include "CSORules/CSOListRules.h"
 
ML_START_NAMESPACE
 
 
typedef void csoNotificationCB(void* data, int notificationFlag);
 
 
class CSOUndoRedoManager;
class CSOManager;
class CSOGroup;
 
class CSOLoad;
class ModuleBackgroundTask;
 
// Define that can be used to detect if the CSOList is ref counted:
#define ML_CSOLIST_REFCOUNTED 1
 
// Declare CSOListPtr smart pointer
ML_REFCOUNTED_PTR(CSOList)
 
 
class MLCSO_EXPORT CSOList : public RefCountedBase
{
 
public:
 
  CSOList();
  CSOList(bool shouldRegisterCSOList);
  CSOList(const CSOList& csoList);
 
protected:
  ~CSOList() override;
 
  void setupCSOList();
 
public:
 
  /* DATA STRUCTURES */
 
  struct CSONotificationCBData
  {
    CSONotificationCBData()
    {
      notificationCB = nullptr;
      notificationCBData = nullptr;
      notificationFlag = NOTIFICATION_NONE;
    }
    csoNotificationCB* notificationCB; 
    void* notificationCBData;          
    int notificationFlag;              
  };
 
  /* METHODS */
 
 
  void clone(const CSOList& csoList, bool useUndoRedo=false);
  void merge(const CSOList& csoList, bool mergeGroupWithSameLabel, CSOIdToCSOIdMap& origToThisGroupIdMap, CSOIdToCSOIdMap& origToThisCSOIdMap, bool useUndoRedo=false);
  void merge(const CSOList& csoList, const CSOGroupMergeHandling mergeMode, CSOIdToCSOIdMap& origToThisGroupIdMap, CSOIdToCSOIdMap& origToThisCSOIdMap, bool useUndoRedo = false);
 
 
  bool saveTo(std::string& filename, bool binary, std::string& message, ModuleBackgroundTask* task=nullptr) const;
  bool saveTo(std::ostream& outStream, bool binary, ModuleBackgroundTask* task=nullptr) const;
  bool loadFrom(std::string& filename, std::string& message, ModuleBackgroundTask* task=nullptr);
  bool loadFrom(std::istream& inStream, bool binary, std::string& message, ModuleBackgroundTask* task = nullptr);
 
 
  void addNotificationObserver(csoNotificationCB* callback, void* userData);
  void removeNotificationObserver(csoNotificationCB* callback, void* userData);
  void notifyObservers(int notificationFlag);
  static void removeNotificationObserverFromAllCSOLists(csoNotificationCB* callback, void* userData);
  void registerCSOListForNotificationObservers();
 
 
  void updateDisplays();
 
 
  inline CSOUndoRedoManager* getUndoRedoManager() { return _csoUndoRedoManager; }
  inline CSOManager* getManager()                 { return _csoManager; }
 
  inline void setUndoRedoManager(CSOUndoRedoManager* undoRedoManager) { _csoUndoRedoManager = undoRedoManager; }
  void setManager(CSOManager* manager);
 
 
  unsigned int getCurrentCSOId();
 
  void updateCurrentCSOId(unsigned int newId);
 
  unsigned int getCurrentGroupId();
  inline void setCurrentCSOId(unsigned int id)   { _currentLastCSOId = id;   }
  inline void setCurrentGroupId(unsigned int id) { _currentLastGroupId = id; }
 
  void updateCurrentGroupId(const unsigned int newId);
 
 
  bool isSelected(const CSO* cso) const;
  bool isSelected(const CSOGroup* group) const;
 
  void addSelected(CSO* cso);
  void addSelected(CSOGroup* group);
 
  bool setSelected(CSO* cso);
  bool setSelected(CSOGroup* group);
 
  void clearSelectedCSOs();
  void clearSelectedGroups();
  void clearSelectedSeedPoints();
 
  void removeFromSelection(CSO* cso);
  void removeFromSelection(const std::vector<CSO*> &csos);
  void removeFromSelection(CSOGroup* group);
  void removeFromSelection(const std::vector<CSOGroup*> &groups);
 
  inline unsigned int numSelectedCSOs()   const { return static_cast<unsigned int>(_selectedCSOs.size()); }
  inline unsigned int numSelectedGroups() const { return static_cast<unsigned int>(_selectedGroups.size()); }
 
  inline CSO* getSelectedCSOAt(unsigned int index) const
  {
    if (_selectedCSOs.size() > 0) {
      return _selectedCSOs[index];
    } else {
      return nullptr;
    }
  }
  inline CSOGroup* getSelectedGroupAt(unsigned int index) const
  {
    if (_selectedGroups.size() > 0) {
      return _selectedGroups[index];
    } else {
      return nullptr;
    }
  }
  CSOIdVector getSelectedCSOIds();
 
  CSOIdVector getSelectedGroupIds();
 
  Vector3 getCenterOfSelectedCSOs(bool& resultIsValid)   const;
  Vector3 getCenterOfSelectedGroups(bool& resultIsValid) const;
 
  inline CSO* getCSOCurrentlyUnderMouse() const { return _currentlyUnderMouseCSO; }
  void setCSOCurrentlyUnderMouse(CSO* csoUnderMouse);
 
  Vector3 getCenterOfSelectedCSOs() const
  {
    CSO_DEBUG("Using the deprecated method 'CSOList::getCenterOfSelectedCSOs()'; use 'CSOList::getCenterOfSelectedCSOs(bool& resultIsValid)' instead!");
    bool dummy;
    return getCenterOfSelectedCSOs(dummy);
  }
  Vector3 getCenterOfSelectedGroups() const
  {
    CSO_DEBUG("Using the deprecated method 'CSOList::getCenterOfSelectedGroups()'; use 'CSOList::getCenterOfSelectedGroups(bool& resultIsValid)' instead!");
    bool dummy;
    return getCenterOfSelectedGroups(dummy);
  }
 
 
  CSO* addCSO(bool useUndoRedo=true);
  CSO* addCSONoEvent(bool useUndoRedo = true);
  CSO* addCSO(const std::vector<Vector3>& seedPositions, bool closed, bool useUndoRedo);
  CSO* addCSO(unsigned int numSeedPoints, bool closed, bool useUndoRedo);
  CSO* addCSOCopy(CSO* cso, bool useUndoRedo=true, unsigned int csoId = INVALID_CSO_ID);
  CSOGroup* addGroup(bool useUndoRedo=true);
  CSOGroup* addGroup(const std::string& label, bool useUndoRedo=true);
  CSOGroup* addGroupCopy(CSOGroup* group, bool useUndoRedo=true, unsigned int groupId=INVALID_CSO_ID);
 
  CSO* addPoint(const Vector3& position, const std::string& subtype="point");
  CSO* addCircle(const Vector3& midPoint, const Vector3& normal, double radius, double pointDistanceInMM = 1., const std::string& subtype="circle");
  CSO* addArrow(const Vector3& pointAt, const Vector3& direction, double length, double pointDistanceInMM = 1., const std::string& subtype="arrow");
  CSO* addPolygon(const std::vector<Vector3>& points, double pointDistanceInMM = 1., const std::string& subtype="polygon");
  CSO* addPolyline(const std::vector<Vector3>& points, double pointDistanceInMM = 1., const std::string& subtype="polyline");
  CSO* addClosedSpline(const std::vector<Vector3>& points, bool useInterpolation=true, double pointDistanceInMM = 1., const std::string& subtype="spline");
  CSO* addOpenSpline(const std::vector<Vector3>& points, bool useInterpolation=true, double pointDistanceInMM = 1., const std::string& subtype="spline");
 
  bool removeCSO(CSO* cso, bool useUndoRedo=true);
  bool removeCSO(unsigned int id, bool useUndoRedo=true);
  bool removeAllCSO(bool useUndoRedo=true);
  bool removeGroup(CSOGroup* group, bool useUndoRedo=true);
  bool removeGroup(unsigned int id, bool useUndoRedo=true);
  bool removeAllGroups(bool useUndoRedo);
  bool removeGroups(const std::vector<CSOGroup *> &groupsToRemove, bool useUndoRedo=true);
 
  bool removeAll(bool useUndoRedo=true);
 
 
  CSO* getCSOAt(unsigned int index) const;
  CSO* getCSOById(unsigned int id) const;
  CSO* getCSOByLabel(const std::string& label) const;
  unsigned int getCSOIndex(CSO* cso) const;
  unsigned int getCSOIndex(unsigned int id) const;
  bool hasCSO(CSO* cso) const;
 
 
  CSOGroup* getGroupById(unsigned int id) const;
  CSOGroup* getGroupByLabel(const std::string& label) const;
  CSOGroup* getGroupAt(unsigned int index) const;
  unsigned int getGroupIndex(CSOGroup* group) const;
  unsigned int getGroupIndex(unsigned int id) const;
  bool hasGroup(CSOGroup* group) const;
 
 
  std::string getUniqueCSOLabel(std::string label, std::string format, bool addIdAlways);
 
  std::string getUniqueGroupLabel(std::string label, std::string format, bool addIdAlways);
 
  inline void resetUniqueCSOLabelIdMap() { _csoLabelUniqueIdMap.clear(); }
 
  inline void resetUniqueGroupLabelIdMap() { _groupLabelUniqueIdMap.clear(); }
 
 
  bool combineCSOandGroup(CSO* cso, CSOGroup* group, bool useUndoRedo=true);
  void breakCSOandGroup(CSO* cso, CSOGroup* group, bool useUndoRedo=true);
  void breakCSOfromAllGroups(CSO* cso, bool useUndoRedo=true);
  void breakAllCSOsFromGroup(CSOGroup* group, bool useUndoRedo=true);
  void _addGroupRelationCommand(CSO* cso, CSOGroup* group);
 
 
  unsigned int numCSOs() const;
  unsigned int numGroups() const;
 
 
  CSOIdVector getAllCSOIds() const;
  CSOIdVector getAllGroupIds() const;
 
 
  void undo();
  void redo();
 
 
  inline void enableUndoRedoManager()      { _csoUndoRedoManagerEnabled = true; }
  void disableUndoRedoManager();
 
 
  void sendOpenEventGroup();
  void sendCloseEventGroup();
 
  void sendModuleEventGroup(CSOEvent* event);
 
  void sendPreEvent(CSOEvent::CSOEventType eventType);
  void sendPreEvent(CSOEvent::CSOEventType eventType, unsigned int csoId);
  void sendPreEvent(CSOEvent::CSOEventType eventType, unsigned int csoId, const CSOIdVector& groupIds);
  void sendPreEvent(CSOEvent::CSOEventType eventType, unsigned int csoId, unsigned int groupId);
  void sendPreEvent(CSOEvent::CSOEventType eventType, const CSOIdVector& csoIds);
  void sendPreEvent(CSOEvent::CSOEventType eventType, const CSOIdVector& csoIds, const CSOIdVector& groupIds);
 
 
  void sendPostEvent(CSOEvent::CSOEventType eventType);
  void sendPostEvent(CSOEvent::CSOEventType eventType, unsigned int csoId);
  void sendPostEvent(CSOEvent::CSOEventType eventType, unsigned int csoId, unsigned int groupId);
  void sendPostEvent(CSOEvent::CSOEventType eventType, const CSOIdVector& csoIds);
  void sendPostEvent(CSOEvent::CSOEventType eventType, unsigned int csoId, const CSOIdVector& groupIds);
  void sendPostEvent(CSOEvent::CSOEventType eventType, const CSOIdVector& csoIds, const CSOIdVector& groupIds);
 
  void muteEvents();
  void unmuteEvents();
  bool isNotMutingEvents();
 
 
  MLuint64 getListChangeId() const { return _listChangeId; }
  MLuint64 getGeometryChangeId() const { return _geometryChangeId; }
  void listChanged();
  void geometryChanged();
 
 
  inline void enableRepaintObserver()      { _enableRepaintObserver     = true;  }
  inline void disableRepaintObserver()     { _enableRepaintObserver     = false; }
 
  inline void enableFinishedObserver()     { _enableFinishedObserver    = true;  }
  inline void disableFinishedObserver()    { _enableFinishedObserver    = false; }
 
  inline void enableInteractionObserver()  { _enableInteractionObserver = true;  }
  inline void disableInteractionObserver() { _enableInteractionObserver = false; }
 
  inline void enableSelectionObserver()    { _enableSelectionObserver   = true;  }
  inline void disableSelectionObserver()   { _enableSelectionObserver   = false; }
 
  inline void enableStartNewCSOObserver()  { _enableStartNewCSOObserver = true;  }
  inline void disableStartNewCSOObserver() { _enableStartNewCSOObserver = false; }
 
  inline void enableCSOMovedObserver()     { _enableCSOMovedObserver    = true;  }
  inline void disableCSOMovedObserver()    { _enableCSOMovedObserver    = false; }
 
  inline void enableCSOCurrentlyUnderMouseObserver() { _enableCSOCurrentlyUnderMouseObserver = true; }
  inline void disableCSOCurrentlyUnderMouseObserver() { _enableCSOCurrentlyUnderMouseObserver = false; }
 
 
  inline bool isUndoRedoManagerEnabled()             const { return _csoUndoRedoManagerEnabled; }
  void openUndoRedoGroup(const std::string& description = "Contour Operation");
  void closeUndoRedoGroup();
 
 
  inline bool isRepaintNotificationEnabled()         const { return _enableRepaintObserver;     }
  inline bool isFinishedNotificationEnabled()        const { return _enableFinishedObserver;    }
  inline bool isInteractionInitNotificationEnabled() const { return _enableInteractionObserver; }
  inline bool isSelectionNotificationEnabled()       const { return _enableSelectionObserver;   }
  inline bool isStartNewCSONotificationEnabled()     const { return _enableStartNewCSOObserver; }
  inline bool isCSOMovedNotificationEnabled()        const { return _enableCSOMovedObserver;    }
  inline bool isCSOCurrentlyUnderMouseNotificationEnabled() const { return _enableCSOCurrentlyUnderMouseObserver; }
 
 
  static void alignSeedPathLinks(CSO* cso);
 
 
  static EnumValues<CSOPathPointsStyle> getLineStyleModes();
  static EnumValues<CSOSeedPointStyle>  getSeedPointStyles();
  static EnumValues<CSOVoxelWriteModes> getVoxelWriteModes();
 
  enum NotificationType
  {
    NOTIFICATION_NONE = 0,
    NOTIFICATION_CSO_SELECTION = 1,
    NOTIFICATION_GROUP_SELECTION = 2,
    NOTIFICATION_CSO_FINISHED = 4,
    NOTIFICATION_GROUP_FINISHED = 8,
    NOTIFICATION_REPAINT = 16,
    NOTIFICATION_INTERACTION_INIT = 32,
    NOTIFICATION_START_NEW_CSO = 64,
    NOTIFICATION_CSO_MOVED = 128,
    NOTIFICATION_CSO_UNDER_MOUSE_CHANGED = 256,
    NOTIFICATION_UNDO_REDO_STATE_CHANGED = 512
  };
 
 
  inline CSOListRules& getRules() { return _rules; }
 
  void addStateToTree(TreeNode* /*parent*/) const override;
 
  void readStateFromTree(TreeNode* /*parent*/) override;
 
  // set current version number
  ML_SET_ADDSTATE_VERSION(1);
 
  CSOList* deepCopy() const override { return new CSOList(*this); };
 
#if ML_DEPRECATED_SINCE(3,5,0)
  inline ML_DEPRECATED unsigned int numCSO() const { return numCSOs(); }
#endif
 
  protected:
 
  // nothing so far
 
private:
 
  /* DATA STRUCTURES */
 
  struct IndexPair {
    IndexPair() {
      index0 = index1 = -1;
    }
    int index0, index1;
  };
 
 
  /* MEMBER VARIABLES */
 
  CSOListRules _rules;
 
  std::vector<CSO*>_csoList;
  std::vector<CSOGroup*>_groupList;
 
  std::vector<CSO*>_selectedCSOs;
  std::vector<CSOGroup*>_selectedGroups;
 
  CSO* _currentlyUnderMouseCSO;
 
  bool _csoUndoRedoManagerEnabled;
  CSOUndoRedoManager* _csoUndoRedoManager;
  CSOManager* _csoManager;
 
 
  unsigned int _currentLastCSOId;
  unsigned int _currentLastGroupId;
 
 
  static std::vector<CSOList*> _registeredCSOLists;
 
  std::vector<CSONotificationCBData>_notificationObservers;
 
  std::map<std::string, int>_csoLabelUniqueIdMap;
 
  std::map<std::string, int>_groupLabelUniqueIdMap;
 
  MLuint64 _listChangeId;
  MLuint64 _geometryChangeId;
  static MLuint64 _uniqueListChangeId;
 
  bool _enableRepaintObserver;
  bool _enableFinishedObserver;
  bool _enableInteractionObserver;
  bool _enableSelectionObserver;
  bool _enableStartNewCSOObserver;
  bool _enableCSOMovedObserver;
  bool _enableCSOCurrentlyUnderMouseObserver;
 
  int _numberOfEventMuteRequests;
 
 
  /* METHODS */
 
  inline bool _canUseUndoRedo(bool shouldUseUndoRedo) const { return shouldUseUndoRedo && _csoUndoRedoManagerEnabled && _csoUndoRedoManager; }
  void _setDefaultValues(CSO* cso);
  void _setDefaultValues(CSOGroup* group);
  void _setDefaultRules(CSOGroup* group);
 
  void _emptyInternalListOfCSOs();
  void _emptyInternalListOfGroups();
 
  CSOIdVector _filterContainedGroups(const std::vector<CSOGroup*> &groups, const std::vector<CSOGroup*>& container);
  CSOIdVector _filterContainedCSOs(const std::vector<CSO*> &csos, const std::vector<CSO*>& container);
 
  bool pathPointListIndexIsInRange(CSO* cso, int index) const;
  bool seedPointIndexIsRange(CSO* cso, int index) const;
 
  void killAll();
 
  bool _fromStreamV1(std::istream& inStream, std::string& message);
  bool _fromStreamV3(std::istream& inStream, std::string& message);
  bool _fromStreamV4(std::istream& inStream, std::string& message);
  bool _fromStreamV5(std::istream& inStream, bool asBinary, std::string& message);
  bool loadFromVersionBefore5(std::istream& inStream, bool binary, short version, bool swapBytes, std::string& message);
  bool _fromStreamV6(std::istream& inStream, bool asBinary, std::string& message, ModuleBackgroundTask* task=nullptr);
 
  void reconstructPathPointListToSeedPointLinks( CSO* cso, std::vector<IndexPair>& pathIndexPairs, std::vector<IndexPair>& seedIndexPairs, const std::string& version, std::string& message);
 
  bool _checkLine(const std::string& line, const std::string& name, std::string& errorMessage);
 
  inline std::string spaces(unsigned int numSpaces) const
  {
    std::stringstream result;
    for (unsigned int i = 0; i < numSpaces; ++i)
    {
      result << " ";
    }
    return result.str();
  }
 
  std::string buildLabel(std::string label, std::string format, int id)
  {
    //Example: buildLabel("cso", " (%i)", 9) returns "cso (0)"
    size_t p = format.find("%i");
    if (p == std::string::npos)
    {
      format.append("%i");
      p = format.find("%i");
    }
    std::stringstream ss;
    ss << id;
    std::string tmp = format.replace(p, 2, ss.str());
    return label.append(tmp);
  }
 
  static void registerCSOList(CSOList* csoList);
  static void deregisterCSOList(CSOList* csoList);
 
  friend class CSOLoad;
 
  ML_CLASS_HEADER(CSOList)
};
 
 
ML_END_NAMESPACE