MeVisLab/Standard/Sources/ML/MLWEM/WEMBase/WEMPatch.h

Go to the documentation of this file.

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

#ifndef __WEMPatch_H
#define __WEMPatch_H

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

ML_START_NAMESPACE

// Forward declarations
class WEM;


class MLWEM_EXPORT WEMPatch
{
public:
  WEMPatch(unsigned int bs = 8192);
  WEMPatch(WEM* wem, unsigned int bs = 8192);
  WEMPatch(const WEMPatch& wemPatch);
  virtual ~WEMPatch();
  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 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();
  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();


  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();


  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();

  WEMPatch* makeCompatible(WEMRequirements* requirements, TriangulationModes triangulationMode);


  virtual void buildEdgeConnectivity();

  void buildLocalEdgeConnectivity(WEMFace *face);


  virtual void saveTo(std::ostream& outstream, ProgressField *progress=NULL, float ratio=1.0f, float offset=0.0f);
  virtual unsigned int loadFrom(std::istream& instream, short version, bool swapBytes, ProgressField *progressFld=NULL, float ratio=1.0f, float offset=0.0f);
  virtual unsigned int loadFrom(char *map, short version, bool swapBytes, ProgressField *progressFld=NULL, float ratio=1.0f, float offset=0.0f);


  WEMPrimitiveValueList* createOrGetPrimitiveValueList(std::string name);

  WEMPrimitiveValueList* getPrimitiveValueList(std::string name);

  const WEMPrimitiveValueList* getPrimitiveValueList(std::string name) const;

  std::vector<std::string> getRegisteredPrimitiveValueLists() const;


protected:

  virtual void _addFaceUpdatePrimitiveValueLists();

  virtual void _delFaceUpdatePrimitiveValueLists(WEMFace *face);

  virtual void _initMembers(unsigned int bs);
  WEMIndexVector<WEMNode>* _nodes;
  WEMIndexVector<WEMEdge>* _edges;
  unsigned int _blocksize;

  unsigned int _uniqueId;
  WEM* _wem;
  std::string _type;
  int _creatorId;

  WEMAttributes _attributes;
  WEMBoundingBox *_boundingBox;

  std::vector<WEMPrimitiveValueList*> _primitiveValueLists;

private:

  void _storePrimitiveValueListValue(unsigned int i, unsigned int index, double value);

};


ML_END_NAMESPACE

#endif // __WEM_H