WEMNode.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 "WEMPrimitive.h"
#include "WEMFace.h"
#include "WEMEdge.h"
#include "WEMPrimitiveValueList.h"
#include "WEMDataStructure/WEMVector.h"
 
ML_START_NAMESPACE
 
 
class WEMTriangle;
class WEMQuad;
class WEMPolygon;
 
 
class MLWEM_EXPORT WEMNode : public WEMPrimitive
{
public:
 
  WEMNode();
  WEMNode(const WEMNode& n);
  WEMNode(WEMNode&&n) noexcept;
  WEMNode& operator=(WEMNode &&n) noexcept;
  ~WEMNode() override;
  void reset();
  void clone(WEMNode* n);
 
  inline const Vector3& getPosition() const { return _position; }
  inline void getPosition(double& x, double& y, double& z) const { x=_position.x; y=_position.y; z=_position.z;}
 
#if ML_DEPRECATED_SINCE(3,5,0)
  inline void getPosition(float& x, float& y, float& z)
  {
    x=static_cast<float>(_position.x);
    y=static_cast<float>(_position.y);
    z=static_cast<float>(_position.z);
  }
#endif
 
  inline void setPosition(const Vector3& position)        { _position = position; invalidateBoundingBoxesOfAdjacentFaces(); }
  inline void setPosition(double x, double y, double z)   { _position.assign(x,y,z); invalidateBoundingBoxesOfAdjacentFaces(); }
  inline void translate(const Vector3& offset)            { _position += offset; invalidateBoundingBoxesOfAdjacentFaces(); }
  void applyMatrix(const Matrix4& transformMatrix);
  inline void scale(const Vector3& scaleFactor)           { _position *= scaleFactor; invalidateBoundingBoxesOfAdjacentFaces(); }
  inline unsigned int getFaceValence() const              { return _faces.num(); }
  inline unsigned int getEdgeValence() const              { return _edges.num(); }
  inline unsigned int getNumFaces() const                 { return getFaceValence(); }
  inline unsigned int getNumEdges() const                 { return getEdgeValence(); }
  inline Vector4 getColor() const                         { return _color; }
  inline void setColor(const Vector4& color)              { _color = color; }
  inline void setColor(float r, float g, float b)         { _color[0] = r; _color[1] = g; _color[2] = b; }
  inline void setColor(float a)                           { _color[3] = a; }
  inline Vector3 getNormal() const                        { return _normal; }
  inline void setNormal(const Vector3& normal)            { _normal = normal; }
  inline void setNormal(float x, float y, float z)        { _normal.assign(x,y,z); }
  void computeNormal();
  inline WEMFace* getFaceAt(unsigned int index)           { return _faces.at(index); }
  inline const WEMFace* getFaceAt(unsigned int index) const { return const_cast<WEMNode*>(this)->getFaceAt(index); }
  inline WEMTriangle* getTriangleAt(unsigned int index)   { return (_faces.at(index)) ? reinterpret_cast<WEMTriangle*>(_faces.at(index)) : nullptr; }
  inline const WEMTriangle* getTriangleAt(unsigned int index) const { return const_cast<WEMNode*>(this)->getTriangleAt(index); }
  inline WEMQuad* getQuadAt(unsigned int index)           { return (_faces.at(index)) ? reinterpret_cast<WEMQuad*>(_faces.at(index)) : nullptr; }
  inline const WEMQuad* getQuadAt(unsigned int index) const { return const_cast<WEMNode*>(this)->getQuadAt(index); }
  inline WEMPolygon* getPolygonAt(unsigned int index)     { return (_faces.at(index)) ? reinterpret_cast<WEMPolygon*>(_faces.at(index)) : nullptr; }
  inline const WEMPolygon* getPolygonAt(unsigned int index) const { return const_cast<WEMNode*>(this)->getPolygonAt(index); }
  inline void addFace(WEMFace* face)                      { _faces.append(face); }
  void remove(WEMFace* face);
  inline WEMEdge* getEdgeAt(unsigned int index)           { return _edges.at(index); }
  inline const WEMEdge* getEdgeAt(unsigned int index) const { return const_cast<WEMNode*>(this)->getEdgeAt(index); }
  inline void addEdge(WEMEdge* edge)                      { _edges.append(edge); }
  void remove(WEMEdge* edge);
  WEMEdge* getEdgeWith(WEMNode* node);
  inline const WEMEdge* getEdgeWith(WEMNode* node) const { return const_cast<WEMNode*>(this)->getEdgeWith(node); }
  inline bool isBoundary()  const                         { return (_edges.num() && (_edges.num() != _faces.num())); }
  void replace(WEMEdge* orig, WEMEdge* replacement);
  void replace(WEMFace* orig, WEMFace* replacement);
  inline void removeEdges() { _edges.clear(); }
  inline void removeFaces() { _faces.clear(); }
  double getLargestDihedralAngle() const;
  double getPrimitiveValue(const WEMPrimitiveValueList* valueList) const;
 
private:
 
  void invalidateBoundingBoxesOfAdjacentFaces();
 
  void resetNode();
 
  Vector3 _position;
  Vector4 _color;
  Vector3 _normal;
  WEMVector<WEMFace, WEM_DEFAULT_VALENCE> _faces;
  WEMVector<WEMEdge, WEM_DEFAULT_VALENCE> _edges;
};
 
 
bool MLWEM_EXPORT nodesAtAlmostIdenticalPositions(const WEMNode &x, const WEMNode &y);
 
 
ML_END_NAMESPACE