WEM.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 "MLWEMIncludes.h"
#include "WEMAttributes.h"
#include "WEMPatch.h"
#include "WEMTrianglePatch.h"
#include "WEMQuadPatch.h"
#include "WEMPolygonPatch.h"
 
#ifdef WIN32
typedef void* HANDLE;
#endif
 
 
ML_START_NAMESPACE
 
 
struct WEMEventContainer
{
  WEMEventContainer()
  {
    notificationType = WEM_NOTIFICATION_NONE;
    patchId = WEM_PATCH_ID_ALL;
 
    repaintFaces =
    repaintEdges =
    repaintNodes =
    repaintBoundingBoxes = false;
 
    selectionWasClicked = false;
    selectionFaceHit    = 0;
    selectionHitPoint.assign(0,0,0);
  }
 
  int notificationType;
  int patchId;
 
 
  bool repaintFaces;          
  bool repaintEdges;          
  bool repaintNodes;          
  bool repaintBoundingBoxes;  
 
 
  bool selectionWasClicked;   
  int  selectionFaceHit;      
  Vector3 selectionHitPoint;  
};
 
 
typedef void wemNotificationCB(void* data, std::vector<WEMEventContainer> ecList);
 
 
// A define that can be used to detect if the WEM is ref counted:
#define ML_WEM_REFCOUNTED 1
 
// Declare WEMPtr smart pointer
ML_REFCOUNTED_PTR(WEM)
 
 
class MLWEM_EXPORT WEM : public RefCountedBase
{
  ML_CLASS_HEADER(WEM)
 
public:
 
  WEM();
  WEM(const WEM& wem);
 
protected:
  ~WEM() override;
 
public:
 
  struct WEMNotificationCBData
  {
    wemNotificationCB* notificationCB;     
    void* notificationCBData;              
    std::vector<WEMEventContainer> ecList; 
  };
 
 
  void clone(const WEM& wem);
  WEM* deepCopy() const override;
 
 
  bool isValid() const;
 
 
  void addNotificationObserver(wemNotificationCB* callback, void* userData);
  void removeNotificationObserver(wemNotificationCB* callback, void* userData);
  void notifyObservers(std::vector<WEMEventContainer> ecList);
  void notifyObservers(const ml::WEMNotificationType& notificationType);
  static void removeNotificationObserverFromAllWEMs(wemNotificationCB* callback, void* userData);
 
 
  unsigned int getCurrentWEMPatchId();
  inline void setCurrentWEMPatchId(unsigned int id) { _currentLastWEMPatchId = id;   }
 
 
  void addWEMPatch(WEMPatch* wemPatch, bool mergeAllPatches=false);
  WEMTrianglePatch* addWEMPatchCopy(WEMTrianglePatch* wemPatch, bool assignNewId=false);
  WEMQuadPatch* addWEMPatchCopy(WEMQuadPatch* wemPatch, bool assignNewId=false);
  WEMPolygonPatch* addWEMPatchCopy(WEMPolygonPatch* wemPatch, bool assignNewId=false);
 
  bool removeWEMPatch(WEMPatch* wemPatch);
  bool removeWEMPatch(unsigned int id);
  bool removeAll();
  void removeAllNoDelete();
 
 
  WEMPatch* getWEMPatchAt(unsigned int index);
  inline const WEMPatch* getWEMPatchAt(unsigned int index) const { return const_cast<WEM*>(this)->getWEMPatchAt(index); }
  WEMPatch* getWEMPatchById(unsigned int id);
  inline const WEMPatch* getWEMPatchById(unsigned int id) const { return const_cast<WEM*>(this)->getWEMPatchById(id); }
  unsigned int getWEMPatchIndex(WEMPatch* wemPatch) const;
  unsigned int getWEMPatchIndex(unsigned int id) const;
  bool hasWEMPatch(WEMPatch* wemPatch) const;
 
 
  inline unsigned int getNumWEMPatches() const { return static_cast<unsigned int>(_wemPatchList.size()); }
 
 
  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 bool isRepaintNotificationEnabled()         const { return _enableRepaintObserver;     }
  inline bool isFinishedNotificationEnabled()        const { return _enableFinishedObserver;    }
  inline bool isInteractionInitNotificationEnabled() const { return _enableInteractionObserver; }
  inline bool isSelectionNotificationEnabled()       const { return _enableSelectionObserver;   }
 
 
  inline int getId() const { return _uniqueId; }
  inline std::string getName() const { return _name; }
  inline void setName(std::string name) { _name = name; }
 
 
  void saveWEMSurface(const std::string& filename, const WEMPersistenceParameters& persistenceParameters, ProgressField *progressFld = nullptr);
  void saveWEMSurface(std::ostream& outstream, const WEMPersistenceParameters& persistenceParameters, ProgressField *progressFld = nullptr);
 
  bool loadWEMSurface(const std::string& filename, bool generateEdges=true, ProgressField *progressFld=nullptr);
  bool loadWEMSurface(const std::string& filename, MLuint64 filesize, bool generateEdges = true, ProgressField *progressFld = nullptr);
 
 
  bool hasPrimitiveValueListForAllPatches(std::string description) const;
  std::vector<std::string> getRegisteredPrimitiveValueLists() const;
 
 
  void flatten(WEMTrianglePatch *triPatch, WEMRequirements* requirements, TriangulationModes triangulationMode);
 
  void mergeAllPatchesIntoSinglePatch();
 
private:
 
  void _setIdAndName();
 
  static int _getUniqueId();
 
#ifdef WIN32
  void _closeFileHandles(void* hMap, HANDLE hFile, HANDLE dFile);
#else
  void _closeFileHandles(void* hMap, int dFile, MLuint64 filesize);
#endif
 
  int _uniqueId;
 
  std::string _name;
 
  std::vector<WEMPatch*>_wemPatchList;
 
  unsigned int _currentLastWEMPatchId;
 
  std::vector<WEMNotificationCBData>_notificationObservers;
 
  bool _enableRepaintObserver;
  bool _enableFinishedObserver;
  bool _enableInteractionObserver;
  bool _enableSelectionObserver;
 
 
  static int _currentLastId;
 
  static std::vector<WEM*> _registeredWEMs;
 
  static void registerWEM(WEM* wem);
  static void deregisterWEM(WEM* wem);
};
 
 
 
ML_END_NAMESPACE