WEMTriangle.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 "WEMFace.h"
#include "WEMNode.h"
#include "WEMEdge.h"
 
#include <array>
 
ML_START_NAMESPACE
 
 
class MLWEM_EXPORT WEMTriangle : public WEMFace
{
public:
  WEMTriangle();
  WEMTriangle(const WEMTriangle& t);
  WEMTriangle(WEMTriangle &&t) noexcept;
  WEMTriangle& operator=(WEMTriangle &&t) noexcept;
 
  ~WEMTriangle() override;
 
  void reset();
 
  void clone(WEMTriangle* triangle);
 
  void computeNormal() override;
  inline unsigned int getNumNodes() const override { return 3; }
  int getIndex(WEMNode* node) const override;
  inline WEMNode* getNodeAt(unsigned int index) override { return _nodes[index]; }
  inline const WEMNode* getNodeAt(unsigned int index) const override { return const_cast<WEMTriangle*>(this)->getNodeAt(index); }
  inline void setNode(unsigned int index, WEMNode* node) override { _nodes[index] = node; invalidateBoundingBox(); }
  virtual inline void setNodes(WEMNode* node1, WEMNode* node2, WEMNode* node3) {
    _nodes[0] = node1; _nodes[1] = node2; _nodes[2] = node3;
    invalidateBoundingBox();
  }
  void replace(WEMNode* orig, WEMNode* replacement) override;
  bool contains(WEMNode* node) const override;
  Vector3 getNodePositionAt(unsigned int index) const override { return _nodes[index]->getPosition(); }
 
  int getIndex(WEMEdge* edge) const override;
  inline WEMEdge* getEdgeAt(unsigned int index) override { return _edges[index]; }
  inline const WEMEdge* getEdgeAt(unsigned int index) const override { return const_cast<WEMTriangle*>(this)->getEdgeAt(index); }
  inline void setEdge(unsigned int index, WEMEdge* edge) override { _edges[index] = edge; invalidateBoundingBox(); }
  virtual inline void setEdges(WEMEdge* edge1, WEMEdge* edge2, WEMEdge* edge3)
  {
    _edges[0] = edge1; _edges[1] = edge2; _edges[2] = edge3;
    invalidateBoundingBox();
  }
  void replace(WEMEdge* orig, WEMEdge* replacement) override;
  bool contains(WEMEdge* edge) const override;
  void removeEdges() override;
 
 
  Vector3 getCentroid() const override;
  void getCentroid(Vector3& centroid) const override;
  double getPerimeter() const override;
  double getArea() const override;
  WEMNode* getOther(WEMNode* n1, WEMNode* n2) override;
  inline const WEMNode* getOther(WEMNode* n1, WEMNode* n2) const override { return const_cast<WEMTriangle*>(this)->getOther(n1, n2); }
  WEMEdge* getOther(WEMEdge* e1, WEMEdge* e2) override;
  inline const WEMEdge* getOther(WEMEdge* e1, WEMEdge* e2) const override { return const_cast<WEMTriangle*>(this)->getOther(e1, e2); }
  WEMEdge* getEdgeNotContaining(WEMNode* n) override;
  inline const WEMEdge* getEdgeNotContaining(WEMNode* n) const override { return const_cast<WEMTriangle*>(this)->getEdgeNotContaining(n); }
  double getQuality() const override;
  int isConcave() const override { return 0; }
  virtual bool isFolding(WEMNode *node, const Vector3& position) const;
  virtual bool pointInTriangle(const Vector3& position) const;
  virtual bool rayIntersect(const Vector3& origin, const Vector3& direction) const;
  void mirror() override;
 
  friend bool MLWEM_EXPORT operator==(const WEMTriangle &x, const WEMTriangle &y);
  friend bool MLWEM_EXPORT operator!=(const WEMTriangle &x, const WEMTriangle &y);
 
  // for performance reasons, direct access to the nodes and edges is allowed:
public:
 
  std::array<WEMNode*, 3> _nodes;
  std::array<WEMEdge*, 3> _edges;
 
private:
  void resetTriangle();
};
 
ML_END_NAMESPACE