WEMPatch.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 "WEMNode.h"
#include "WEMEdge.h"
#include "WEMBoundingBox.h"
#include "WEMAttributes.h"
#include "WEMRequirements.h"
#include "WEMPrimitiveValueList.h"
#include "WEMDataStructure/WEMIndexVector.h"
#include "WEMDataStructure/WEMVector.h"
#include "WEMPersistenceHelper.h"
 
ML_START_NAMESPACE
 
 
class WEM;
class WEMPatch;
class WEMPatchPersistence;
 
struct CentroidIndex
{
  unsigned int index;
  double centroidZ;
 
  bool operator < (const CentroidIndex& c) const
  {
    return centroidZ < c.centroidZ;
  }
};
 
 
struct WEMPrimitiveCount
{
  WEMPrimitiveCount(WEMPatch* patch);
  unsigned int getNumPrimitives(PrimitiveValueListTypes pvlType) const;
 
  unsigned int numNodes{};
  unsigned int numEdges{};
  unsigned int numFaces{};
};
 
 
 
class MLWEM_EXPORT WEMPatch
{
public:
  WEMPatch(unsigned int bs = 8192);
  WEMPatch(WEM* wem, unsigned int bs = 8192);
  WEMPatch(const WEMPatch& wemPatch);
  WEMPatch(WEMPatch &&other) noexcept;
  WEMPatch &operator=(WEMPatch &&other) noexcept;
  virtual ~WEMPatch();
  virtual WEMPatch* copy() = 0;
  void dispose();
  void addPatch(WEMPatch* wemPatch);
 
  inline unsigned int getBlocksize() const { return _blocksize; }
  virtual PatchTypes getPatchType() const = 0;
  virtual inline unsigned int getNumFaces() const { return 0; }
 
  inline bool isTrianglePatch() const { return getPatchType() == WEM_PATCH_TRIANGLES; }
  inline bool isQuadPatch() const { return getPatchType() == WEM_PATCH_QUADS; }
 
 
  inline unsigned int getNumNodes() const { return _nodes.num(); }
  inline WEMIndexVector<WEMNode>* getNodes() { return &_nodes; }
  inline const WEMIndexVector<WEMNode>* getNodes() const { return const_cast<WEMPatch*>(this)->getNodes(); }
  inline WEMNode* getNodeAt(unsigned int index) { return _nodes.at(index); }
  inline const WEMNode* getNodeAt(unsigned int index) const { return const_cast<WEMPatch*>(this)->getNodeAt(index); }
  WEMNode* addNode();
  WEMNode* addNodeNoUpdatePrimitiveValueLists();
  void delNode(WEMNode* node);
  void addNodeValues(WEMNode* target, WEMNode* source, double modifier);
  void averageNodeValues(WEMNode* target, WEMNode* source1, WEMNode* source2);
  void extendNodeValueLists(unsigned int number, double value);
 
 
  inline unsigned int getNumEdges() const { return _edges.num(); }
  inline WEMIndexVector<WEMEdge>* getEdges() { return &_edges; }
  inline const WEMIndexVector<WEMEdge>* getEdges() const { return const_cast<WEMPatch*>(this)->getEdges(); }
  inline WEMEdge* getEdgeAt(unsigned int index) { return _edges.at(index); }
  inline const WEMEdge* getEdgeAt(unsigned int index) const { return const_cast<WEMPatch*>(this)->getEdgeAt(index); }
  inline WEMEdge* addEdge() { return _edges.append(); }
  inline void delEdge(WEMEdge* edge) { _edges.remove(edge); }
  inline bool hasEdges() const { return (_edges.num() > 0); }
  void addEdgeValues(WEMEdge* target, WEMEdge* source, double modifier);
  void extendEdgeValueLists(unsigned int number, double value);
 
 
  virtual WEMFace* getFaceAt(unsigned int index) = 0;
  virtual const WEMFace* getFaceAt(unsigned int index) const = 0;
 
  virtual WEMFace* addFace() = 0;
  void addFaceValues(WEMFace* target, WEMFace* source, double modifier);
  void extendFaceValueLists(unsigned int number, double value);
 
 
  void setNodeTraversalState(bool state);
  void setEdgeTraversalState(bool state);
  void setFaceTraversalState(bool state);
  void computeNormals();
  void flipNormals();
  void applyMatrix(const Matrix4& transformationMatrix);
 
 
  double getArea() const;
  double getVolume() const;
  bool pointsOutwards() const;
 
 
  inline WEMBoundingBox* getBoundingBox() { return &_boundingBox; }
  inline const WEMBoundingBox* getBoundingBox() const { return const_cast<WEMPatch*>(this)->getBoundingBox(); }
  void computeBoundingBox();
  void centerByBoundingBox();
 
  void translate(const Vector3& offset);
 
 
  inline double getLUTMin() const
  {
    const WEMPrimitiveValueList* pvl = getPrimitiveValueList("LUT");
    if (pvl) { return pvl->getMinValue(); }
    else     { return 0;                  }
  }
  inline double getLUTMax() const
  {
    const WEMPrimitiveValueList* pvl = getPrimitiveValueList("LUT");
    if (pvl) { return pvl->getMaxValue(); }
    else     { return 0;                  }
  }
 
 
  void        setType(std::string type)        { _type = type;       }
  std::string getType() const                  { return _type;       }
  void        setCreatorId(int id)             { _creatorId = id;    }
  int         getCreatorId() const             { return _creatorId;  }
 
 
  inline void setWEM(WEM* wem) { _wem = wem; }
  inline WEM* getWEM() { return _wem; }
  inline const WEM* getWEM() const { return const_cast<WEMPatch*>(this)->getWEM(); }
 
 
  inline void setLabel(std::string label)                     { _attributes.label = label;              }
  inline std::string getLabel() const                         { return _attributes.label;               }
 
  inline void setDescription(std::string desc)                { _attributes.description = desc;         }
  inline std::string getDescription() const                   { return _attributes.description;         }
 
 
  inline unsigned int getId() const  { return _uniqueId; }
 
  inline void setId(unsigned int newId) { _uniqueId = newId; }
 
 
  void deleteOrphanNodes();
 
 
  void triangulate(WEMTrianglePatch* wemPatch, TriangulationModes triangulationMode);
 
  void mirror();
 
  virtual void sortFacesByZPosition() = 0;
 
  WEMPatch* makeCompatible(WEMRequirements* requirements, TriangulationModes triangulationMode);
 
 
  virtual void buildEdgeConnectivity();
 
  void buildLocalEdgeConnectivity(WEMFace *face);
 
  void removeAllEdges();
 
 
  void saveTo(OutStreamWrapper& ostreamWrapper, const WEMPersistenceParameters& writeParameters, WEMProgressUpdater& progressUpdater);
 
  unsigned int loadFrom(FileMapWrapper& mapper, const WEMPersistenceParameters& persistenceParameters, const WEMReadParameters& parameters, WEMProgressUpdater& progressUpdater);
 
 
  WEMPrimitiveValueList* createOrGetPrimitiveValueList(const std::string& name);
 
  WEMPrimitiveValueList* getPrimitiveValueList(const std::string& name);
 
  const WEMPrimitiveValueList* getPrimitiveValueList(const std::string& name) const;
 
  std::vector<std::string> getRegisteredPrimitiveValueLists() const;
 
  const std::vector<WEMPrimitiveValueList*>& getPrimitiveValueLists() const { return _primitiveValueLists; }
 
  bool removePrimitiveValueList(const std::string& name);
 
  bool hasSingleColoredPVL();
  bool hasAllFacesSingleColored();
  unsigned int getNumSingleColoredFaces();
  bool isSingleColored(WEMFace* face);
  bool isSingleColored(WEMEdge* edge);
  bool isSingleColored(WEMNode* node);
 
  bool irregularSurfaceDetected() const { return _irregularSurfaceDetected; };
 
protected:
 
  virtual void _addFaceUpdatePrimitiveValueLists();
 
  virtual void _delFaceUpdatePrimitiveValueLists(WEMFace *face);
 
  void _getReorderedIndicesForFaces(std::vector<unsigned int>& reorderedIndices);
 
  unsigned int _blocksize;
  WEMIndexVector<WEMNode> _nodes;
  WEMIndexVector<WEMEdge> _edges;
  WEM *_wem{};
  unsigned int _uniqueId{};
  std::string _type;
  int _creatorId;
 
  WEMAttributes _attributes;
  WEMBoundingBox _boundingBox;
 
  std::vector<WEMPrimitiveValueList*> _primitiveValueLists;
 
private:
 
  void _storePrimitiveValueListValue(unsigned int i, unsigned int index, double value);
  void _handlePVLs(WEMPatch* wemPatch, const WEMPrimitiveCount& targetPC, const WEMPrimitiveCount& sourcePC);
  bool _irregularSurfaceDetected{};
  friend class WEMPatchPersistence;
};
 
 
ML_END_NAMESPACE