niftkBasicVertex.h

Go to the documentation of this file.

/*=============================================================================

NifTK: A software platform for medical image computing.

Copyright (c) University College London (UCL). All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.

See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef niftkBasicVertex_h
#define niftkBasicVertex_h

#include <set>

#include "niftkBasicVec3D.h"
#include "niftkCoreExports.h"

namespace niftk
{

class BasicMesh;

// Used to store an edge -- two vertices which have only one
// triangle in common form an edge of the mesh.
struct Border
{
  int vert1;
  int vert2;
  int triIndex;

  // We need operator< because it's used by the STL's set<> to determine equality
  // (if (not a<b) and (not b>a) then a is equal to b)
  bool operator <(const Border& b) const
  {
    int v1, v2, b1, b2;

    // make sure the smaller vert index is always first.
    if (vert1 < vert2)
    {
      v1 = vert1; v2 = vert2;
    }
    else
    {
      v1 = vert2; v2 = vert1;
    }

    if (b.vert1 < b.vert2)
    {
      b1 = b.vert1; b2 = b.vert2;
    }
    else
    {
      b1 = b.vert2; b2 = b.vert1;
    }

    if (v1 < b1)
      return true;

    if (v1 > b1)
      return false;

    return (v2 < b2); // v1 == b1
  }
};

class NIFTKCORE_EXPORT BasicVertex
{

public:
  BasicVertex();
  BasicVertex(float x1, float y1, float z1);
  BasicVertex(float av[3]);
  BasicVertex(float av[3], float vn[3]);

  BasicVertex(const BasicVertex& v);

  virtual ~BasicVertex();

  BasicVertex& operator=(const BasicVertex& v);
  BasicVertex& operator=(const float av[3]);

  bool operator==(const BasicVertex& v);
  bool operator!=(const BasicVertex& v);

  bool operator<(const BasicVertex &right) const;
  bool operator>(const BasicVertex &right) const;

  friend std::ostream& operator<<(std::ostream& , const BasicVertex& );

  void                     SetCoords(const BasicVec3D& v) { m_Coords = v; };
  inline       BasicVec3D& GetCoords()                    { return m_Coords; }
  inline const BasicVec3D& GetCoords() const              { return m_Coords; }
  const float* GetCoordArray() const;

  void SetCoordX(float x) { m_Coords.SetX(x); }
  void SetCoordY(float y) { m_Coords.SetY(y); }
  void SetCoordZ(float z) { m_Coords.SetZ(z); }

  float GetCoordX() { return m_Coords.GetX(); }
  float GetCoordY() { return m_Coords.GetY(); }
  float GetCoordZ() { return m_Coords.GetZ(); }

  const float GetCoordX() const { return m_Coords.GetX(); }
  const float GetCoordY() const { return m_Coords.GetY(); }
  const float GetCoordZ() const { return m_Coords.GetZ(); }

  void SetNormal(const BasicVec3D& vn)       { m_Normal = vn; };
  inline       BasicVec3D& GetNormal()       { return m_Normal; };
  inline const BasicVec3D& GetNormal() const { return m_Normal; };
  const float* GetNormalArray() const;

  void SetNormalX(float x) { m_Normal.SetX(x); }
  void SetNormalY(float y) { m_Normal.SetY(y); }
  void SetNormalZ(float z) { m_Normal.SetZ(z); }

  float GetNormalX() { return m_Normal.GetX(); }
  float GetNormalY() { return m_Normal.GetY(); }
  float GetNormalZ() { return m_Normal.GetZ(); }

  const float GetNormalX() const { return m_Normal.GetX(); }
  const float GetNormalY() const { return m_Normal.GetY(); }
  const float GetNormalZ() const { return m_Normal.GetZ(); }

  void AddVertNeighbor(int v) { m_VertNeighbors.insert(v); }

  unsigned RemoveVertNeighbor(int v) { return m_VertNeighbors.erase(v); }

  void AddTriNeighbor(int t) { m_TriNeighbors.insert(t); }

  unsigned RemoveTriNeighbor(int t) { return m_TriNeighbors.erase(t); }

  const std::set<int>& GetVertNeighbors() const { return m_VertNeighbors; }
  // \brief Get the whole set of vertex neighbours
  std::set<int>&       GetVertNeighbors()       { return m_VertNeighbors; }

  const std::set<int>& GetTriNeighbors() const  { return m_TriNeighbors; }
  std::set<int>&       GetTriNeighbors()        { return m_TriNeighbors; }

  bool HasVertNeighbor(int v) const { return (m_VertNeighbors.find(v) != m_VertNeighbors.end()); }
  bool HasTriNeighbor(int t)  const { return (m_TriNeighbors.find(t) != m_TriNeighbors.end()); }

  double GetEdgeRemoveCost()         { return m_Cost; };
  void   SetEdgeRemoveCost(double f) { m_Cost = f; };

  int  GetMinCostEdgeVert() const { return m_MinCostNeighbor; };
  void SetMinCostEdgeVert(int i)  { m_MinCostNeighbor = i; }

  double GetCost() const { return m_Cost; }

  int  GetIndex() const { return m_Index; }
  void SetIndex(int i)  { m_Index = i; }

  inline bool IsActive()  const { return m_Active; }
  inline void SetActive(bool b) { m_Active = b; }

  bool IsBorder(BasicMesh& m);

  void GetAllBorderEdges(std::set<Border> &borderSet, BasicMesh& m);

  void CalcQuadric(BasicMesh& m, bool bUseTriArea); // calculate the 4x4 Quadric matrix
  void GetQuadric(double Qret[4][4]);
  void SetQuadric(double Qnew[4][4]);

  double GetQuadricSummedTriArea() { return m_QuadricTriArea; };
  void   SetQuadricSummedTriArea(double newArea) { m_QuadricTriArea = newArea; };

private:
  void InitQuadric();

private:
  BasicVec3D m_Coords;         // X, Y, Z position of this vertex
  BasicVec3D m_Normal;         // vertex normal, used for Gouraud shading

  std::set<int>   m_VertNeighbors;   // connected to this vertex via an edge
  std::set<int>   m_TriNeighbors;    // triangles of which this vertex is a part

  bool       m_Active;             // false if vertex has been removed

  double     m_Cost;               // cost of removing this vertex from Progressive Mesh
  int        m_MinCostNeighbor;    // index of vertex at other end of the min. cost edge

  int        m_Index;
  double     m_QuadricError[4][4]; // Used for Quadric error cost.
  double     m_QuadricTriArea;     // summed area of triangles used to compute quadrics

  mutable float m_V[3];            //mutable floats used for returning values
  mutable float m_VN[3];           //mutable floats used for returning values
};

}

#endif