gsVertex.h

Go to the documentation of this file.

#pragma once

#include <gsUtils/gsMesh/gsMeshElement.h>
#include <gsCore/gsLinearAlgebra.h>

namespace gismo
{

template <class T>
class gsVertex  : public gsMeshElement<T>, public gsVector3d<T>
{
public:
    typedef memory::shared_ptr< gsVertex > Ptr;

    typedef memory::unique_ptr< gsVertex > uPtr;

    typedef typename gsVector3d<T>::Scalar       scalar_t;
    typedef gsMeshElement<T>                     MeshElement;
    typedef typename MeshElement::gsFaceHandle   gsFaceHandle;
    typedef typename MeshElement::gsVertexHandle gsVertexHandle;

public:
    gsVertex() : MeshElement(), gsVector3d<T>() { }

    template<typename OtherDerived>
    gsVertex(const gsEigen::MatrixBase<OtherDerived>& other) :
    MeshElement(), gsVector3d<T>(other) { }

    gsVertex(scalar_t x, scalar_t y, scalar_t z = 0) :
    MeshElement(), gsVector3d<T>(x,y,z),sharp(0), numEdges(0), data()
    { }

    gsVertex( gsVector3d<T> const & u) :
    MeshElement(), gsVector3d<T>(u),sharp(0), numEdges(0), data()
    { }

    gsVertex( gsVector<T> const & u) :
    MeshElement(), gsVector3d<T>(),sharp(0),numEdges(0), data()
    {
        // vertex is always a 3-cooordinate vector.
        const index_t r = u.rows();
        GISMO_ASSERT(r<=3, "Invalid input in gsVertex constructor");

        if ( r < 3 )
            this->tail(3-r).setZero();

        this->head(r) = u;
    }

    virtual ~gsVertex() { };


    void setCoords(gsVector<T> const & coord)
    {
        this->gsVector3d<T>::operator=(coord);
    }

    gsVertex & operator=(const gsVertex & other)
    {
        this->gsVector3d<T>::operator=(other);
        return *this;
    }
    
    //GISMO_CLONE_FUNCTION(gsVertex)
    uPtr clone() const { return uPtr(new gsVertex(*this)); }

    void move(scalar_t dx, scalar_t dy, scalar_t dz)
    {
        this->x() += dx;
        this->y() += dy;
        this->z() += dz;
    }

    inline void addFace(gsFaceHandle const& f)
    { faces.push_back( f ); }

    inline T   x () const { return (*this)(0); }
    inline T   y () const { return (*this)(1); }
    inline T   z () const { return (*this)(2); }
    inline T & x () { return (*this)(0); }
    inline T & y () { return (*this)(1); }
    inline T & z () { return (*this)(2); }

    std::ostream &print(std::ostream &os) const
    {
        os << "Vertex( " << this->x() << " " << this->y() << " " << this->z() << " )\n";
        return os;
    }

public:

    std::vector<gsVertexHandle> nVertices;
    //gsVector3d<T> coords;
    bool sharp;

    std::vector<gsFaceHandle> faces;
    int numEdges;

    T data;
};

  template<class T>
  static bool Xless( typename gsVertex<T>::gsVertexHandle const & a,
                     typename gsVertex<T>::gsVertexHandle const & b )
  {return a->x()< b->x() || ( a->x()==b->x() && a->y()<b->y() )
      || ( a->x()==b->x() && a->y()==b->y() && a->z()<b->z()); }

  template<class T>
  static bool Yless( typename gsVertex<T>::gsVertexHandle const & a,
                     typename gsVertex<T>::gsVertexHandle const & b )
  {return a->y()< b->y() || ( a->y()==b->y() && a->x()<b->x() ); }
  template<class T>
  static bool Zless( typename gsVertex<T>::gsVertexHandle const & a,
                     typename gsVertex<T>::gsVertexHandle const & b )
  {return a->z()< b->z(); }

// Lexicographic comparison for vertex handles

template<class T>
struct lexCompareVHandle
{
    bool operator() (typename gsVertex<T>::gsVertexHandle const & lhs,
                     typename gsVertex<T>::gsVertexHandle const & rhs) const
      {return lhs->x()< rhs->x() || ( lhs->x()==rhs->x() && lhs->y()<rhs->y() )
      || ( lhs->x()==rhs->x() && lhs->y()==rhs->y() && lhs->z()<rhs->z()); }
};

template<class T>
T length(gsVertex<T> const & vert)
{
    //return (sqrt(vert.x()*vert.x()+vert.y()*vert.y()+vert.z()*vert.z()));
    return vert.norm();
}

template<class T>
bool operator < (typename gsVertex<T>::gsVertexHandle const & lhs,
                typename gsVertex<T>::gsVertexHandle const & rhs)
{
    return !(lhs->x() < rhs->x() || (lhs->x() == rhs->x() && lhs->y() < rhs->y())
        || (lhs->x() == rhs->x() && lhs->y() == rhs->y() && lhs->z() < rhs->z()));
}
template<class T>
bool operator > (typename gsVertex<T>::gsVertexHandle const & lhs,
        typename gsVertex<T>::gsVertexHandle const & rhs)
{
    return !(lhs->x() > rhs->x() || (lhs->x() == rhs->x() && lhs->y() > rhs->y())
        || (lhs->x() == rhs->x() && lhs->y() == rhs->y() && lhs->z() > rhs->z()));
}
//template<class T>
//bool operator == (typename gsVertex<T> const & lhs,
//        typename gsVertex<T> const & rhs)
//{
//  return (lhs->x()== rhs->x()&& lhs->y()==rhs->y()&& lhs->z()==rhs->z())
//    ;}

template<class T>
bool operator == (gsVertex<T> const & lhs,gsVertex<T> const & rhs)
{
    return (lhs.x()==rhs.x())&&
           (lhs.y()==rhs.y())&&
           (lhs.z()==rhs.z());
//    return lhs.gsEigen::template Matrix<T,3,1>::operator==(rhs); /slower
}

template<class T>
bool operator < (gsVertex<T> const & lhs,gsVertex<T> const & rhs)
{
    return (lhs.x()> rhs.x() || ( lhs.x()==rhs.x() && lhs.y()>rhs.y() )
            || ( lhs.x()==rhs.x() && lhs.y()==rhs.y() && lhs.z()>rhs.z()));
}

template<class T>
bool operator > (gsVertex<T> const & lhs,gsVertex<T> const & rhs)
{
    return (lhs.x() < rhs.x() ||
        (lhs.x() == rhs.x() && lhs.y() < rhs.y()) ||
        (lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() < rhs.z()));
}

template<class T>
bool operator != (gsVertex<T> const & lhs, gsVertex<T> const & rhs)
{
    //return lhs.gsEigen::template Matrix<T,3,1>::operator!=(rhs);
    return !(lhs.x()== rhs.x()&& lhs.y()==rhs.y()&& lhs.z()==rhs.z());
}

} // namespace gismo