Elements.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2005 Imetric 3D GmbH                                    *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  is distributed in the hope that it will be useful,      *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef MESH_ELEMENTS_H
#define MESH_ELEMENTS_H

#include <functional>
#include <vector>
#include <climits>
#include <cstring>

#include "Definitions.h"

#include <Base/BoundBox.h>
#include <Base/Vector3D.h>

// Cannot use namespace Base in constructors of MeshPoint
#ifdef _MSC_VER
using Base::Vector3f;
#endif

namespace MeshCore {

class MeshHelpEdge;
class MeshPoint;

class MeshExport MeshHelpEdge
{
public:
  inline bool operator == (const MeshHelpEdge &rclEdge) const;
  unsigned long   _ulIndex[2];  // point indices
};

class MeshExport MeshIndexEdge
{
public:
  unsigned long  _ulFacetIndex;  // Facet index
  unsigned short _ausCorner[2];  // corner point indices of the facet
};

typedef std::pair<unsigned long, unsigned long> MeshEdge;

class MeshExport MeshPoint: public Base::Vector3f
{
public:
  enum TFlagType {INVALID=1, VISIT=2, SEGMENT=4, MARKED=8, SELECTED=16, REV=32, TMP0=64, TMP1=128};

  MeshPoint (void) : _ucFlag(0), _ulProp(0) { }
  inline MeshPoint (const Base::Vector3f &rclPt);
  inline MeshPoint (const MeshPoint &rclPt);
  ~MeshPoint (void) { }

public:
  void SetFlag (TFlagType tF) const
  { const_cast<MeshPoint*>(this)->_ucFlag |= (unsigned char)(tF); }
  void ResetFlag (TFlagType tF) const
  { const_cast<MeshPoint*>(this)->_ucFlag &= ~(unsigned char)(tF); }
  bool IsFlag (TFlagType tF) const
  { return (_ucFlag & (unsigned char)(tF)) == (unsigned char)(tF);  }
  void ResetInvalid (void) const
  { ResetFlag(INVALID); }
  void  SetInvalid (void) const
  { SetFlag(INVALID); }
  bool IsValid (void) const
  { return !IsFlag(INVALID); }
  void SetProperty(unsigned long uP) const
  { const_cast<MeshPoint*>(this)->_ulProp = uP; }

  // Assignment
  inline MeshPoint& operator = (const MeshPoint &rclPt);

  // compare operator
  inline bool operator == (const MeshPoint &rclPt) const;
  inline bool operator == (const Base::Vector3f &rclV) const;
  inline bool operator < (const MeshPoint &rclPt) const;

public:
  unsigned char _ucFlag; 
  unsigned long _ulProp; 
};

class MeshExport MeshGeomEdge
{
public:
  MeshGeomEdge (void) : _bBorder(false) {}

  bool ContainedByOrIntersectBoundingBox (const Base::BoundBox3f &rclBB ) const;
  Base::BoundBox3f GetBoundBox () const;
  bool IntersectBoundingBox (const Base::BoundBox3f &rclBB) const;

public:
  Base::Vector3f _aclPoints[2];  
  bool     _bBorder;       
};

class MeshFacet
{
public:
  enum TFlagType {INVALID=1, VISIT=2, SEGMENT=4, MARKED=8, SELECTED=16, REV=32, TMP0=64, TMP1=128};

public:
  inline MeshFacet (void);
  inline MeshFacet(const MeshFacet &rclF);
  inline MeshFacet(unsigned long p1,unsigned long p2,unsigned long p3,unsigned long n1=ULONG_MAX,unsigned long n2=ULONG_MAX,unsigned long n3=ULONG_MAX);
  ~MeshFacet (void) { }

  void SetFlag (TFlagType tF) const
  { const_cast<MeshFacet*>(this)->_ucFlag |= (unsigned char)(tF); }
  void ResetFlag (TFlagType tF) const
  { const_cast<MeshFacet*>(this)->_ucFlag &= ~(unsigned char)(tF); }
  bool IsFlag (TFlagType tF) const
  { return (_ucFlag & (unsigned char)(tF)) == (unsigned char)(tF); }
  void ResetInvalid (void) const
  { ResetFlag(INVALID); }
  void SetProperty(unsigned long uP) const
  { const_cast<MeshFacet*>(this)->_ulProp = uP; }
  void  SetInvalid (void) const
  { SetFlag(INVALID); }
  bool IsValid (void) const
  { return !IsFlag(INVALID); }

  // Assignment
  inline MeshFacet& operator = (const MeshFacet &rclF);
  inline void SetVertices(unsigned long,unsigned long,unsigned long);
  inline void SetNeighbours(unsigned long,unsigned long,unsigned long);

  inline void GetEdge (unsigned short usSide, MeshHelpEdge &rclEdge) const;
  inline std::pair<unsigned long, unsigned long> GetEdge (unsigned short usSide) const;
  inline unsigned short Side (unsigned long ulNIndex) const;
  inline unsigned short Side (unsigned long ulP0, unsigned long P1) const;
  inline unsigned short Side (const MeshFacet& rcFace) const;
  inline bool IsEqual (const MeshFacet& rcFace) const;
  inline void Transpose (unsigned long ulOrig, unsigned long ulNew);
  inline void Decrement (unsigned long ulIndex);
  inline void ReplaceNeighbour (unsigned long ulOrig, unsigned long ulNew);
  bool HasNeighbour (unsigned short usSide) const
  { return (_aulNeighbours[usSide] != ULONG_MAX); }
  inline unsigned short CountOpenEdges() const;
  inline bool HasOpenEdge() const;
  inline bool HasSameOrientation(const MeshFacet&) const;
  inline bool IsDegenerated() const;
  void FlipNormal (void)
  {
    std::swap(_aulPoints[1], _aulPoints[2]);
    std::swap(_aulNeighbours[0], _aulNeighbours[2]);
  }

public:
  unsigned char _ucFlag; 
  unsigned long _ulProp; 
  unsigned long _aulPoints[3];     
  unsigned long _aulNeighbours[3]; 
};

class MeshExport MeshGeomFacet 
{
public:

  MeshGeomFacet (void); 
  MeshGeomFacet (const Base::Vector3f &v1,const Base::Vector3f &v2,const Base::Vector3f &v3);
  ~MeshGeomFacet (void) { }

public:
  bool IsPointOf (const Base::Vector3f &rclPoint, float fDistance) const;
  bool IsPointOf (const Base::Vector3f &rclPoint) const;
  bool IsPointOfFace (const Base::Vector3f& rclP, float fDistance) const;
  bool Weights(const Base::Vector3f& rclP, float& w0, float& w1, float& w2) const;
  inline float DistancePlaneToPoint (const Base::Vector3f &rclPoint) const;
  void ProjectPointToPlane (Base::Vector3f &rclPoint) const;
  void ProjectFacetToPlane (MeshGeomFacet &rclFacet) const;
  bool IsDegenerated() const;
  bool IsDeformed() const;
  void Enlarge (float fDist);
  inline void CalcNormal (void);
  inline void ArrangeNormal (const Base::Vector3f &rclN);
  inline void AdjustCirculationDirection (void);
  void NormalInvalid (void) { _bNormalCalculated = false; }
  bool IsFlag (MeshFacet::TFlagType tF) const
  { return (_ucFlag & (unsigned char)(tF)) == (unsigned char)(tF); }
  void SetFlag (MeshFacet::TFlagType tF)
  { _ucFlag |= (unsigned char)(tF); }
  void ResetFlag (MeshFacet::TFlagType tF)
  { _ucFlag &= ~(unsigned char)(tF); }
  inline Base::Vector3f GetGravityPoint (void) const;
  inline Base::Vector3f GetNormal (void) const;
  inline void SetNormal (const Base::Vector3f &rclNormal);
  inline Base::BoundBox3f GetBoundBox (void) const;
  inline float Perimeter() const;
  inline float Area () const;
  float MaximumAngle () const;
  inline bool ContainedByOrIntersectBoundingBox (const Base::BoundBox3f &rcBB) const;
  bool IntersectBoundingBox ( const Base::BoundBox3f &rclBB ) const;
  bool IntersectWithFacet(const MeshGeomFacet &rclFacet) const;
  int IntersectWithFacet (const MeshGeomFacet& facet, Base::Vector3f& rclPt0, Base::Vector3f& rclPt1) const;
  float DistanceToLineSegment (const Base::Vector3f &rcP1, const Base::Vector3f &rcP2) const;
  float DistanceToPoint (const Base::Vector3f &rcPt) const
  { Base::Vector3f res; return DistanceToPoint(rcPt, res); }
  float DistanceToPoint  ( const Base::Vector3f &rclPt, Base::Vector3f& rclNt ) const;
  bool IntersectWithLine (const Base::Vector3f &rclPt, const Base::Vector3f &rclDir, Base::Vector3f &rclRes) const;
  bool Foraminate (const Base::Vector3f &rclPt, const Base::Vector3f &rclDir, Base::Vector3f &rclRes, float fMaxAngle = F_PI) const;
  bool IntersectWithPlane (const Base::Vector3f &rclBase, const Base::Vector3f &rclNormal, Base::Vector3f &rclP1, Base::Vector3f &rclP2) const;
  inline bool IntersectWithPlane (const Base::Vector3f &rclBase, const Base::Vector3f &rclNormal) const;
  bool IntersectPlaneWithLine (const Base::Vector3f &rclBase, const Base::Vector3f &rclNormal, Base::Vector3f &rclRes ) const;
  float VolumeOfPrism (const MeshGeomFacet& rclF) const;
  void SubSample (float fStep, std::vector<Base::Vector3f> &rclPoints) const;
  float CenterOfInscribedCircle(Base::Vector3f& rclCenter) const;
  float CenterOfCircumCircle(Base::Vector3f& rclCenter) const;
  unsigned short NearestEdgeToPoint(const Base::Vector3f& rclPt) const;
  void NearestEdgeToPoint(const Base::Vector3f& rclPt, float& fDistance, unsigned short& side) const;
  bool IsPointOfSphere(const Base::Vector3f& rP) const;
  bool IsPointOfSphere(const MeshGeomFacet& rFacet) const;

protected:
  Base::Vector3f  _clNormal; 
  bool  _bNormalCalculated; 
public:
  Base::Vector3f  _aclPoints[3]; 
  unsigned char _ucFlag; 
  unsigned long _ulProp; 
};

typedef  std::vector<MeshPoint>  TMeshPointArray;
class MeshExport MeshPointArray: public TMeshPointArray
{
public:
  // Iterator interface
  typedef std::vector<MeshPoint>::iterator        _TIterator;
  typedef std::vector<MeshPoint>::const_iterator  _TConstIterator;

  // constructor
  MeshPointArray (void) { }
  // constructor
  MeshPointArray (unsigned long ulSize) : TMeshPointArray(ulSize) { }
  // Destructor
  ~MeshPointArray (void) { }


  void SetFlag (MeshPoint::TFlagType tF) const;
  void ResetFlag (MeshPoint::TFlagType tF) const;
  void ResetInvalid (void) const;
  void SetProperty (unsigned long ulVal) const;

  // Assignment
  MeshPointArray& operator = (const MeshPointArray &rclPAry);
  unsigned long Get (const MeshPoint &rclPoint);
  unsigned long GetOrAddIndex (const MeshPoint &rclPoint);
};

typedef std::vector<MeshFacet>  TMeshFacetArray;

class MeshExport MeshFacetArray: public TMeshFacetArray
{
public:
    // Iterator interface
    typedef std::vector<MeshFacet>::iterator        _TIterator;
    typedef std::vector<MeshFacet>::const_iterator  _TConstIterator;


    MeshFacetArray (void) { }
    MeshFacetArray (unsigned long ulSize) : TMeshFacetArray(ulSize) { }
    ~MeshFacetArray (void) { }


    void SetFlag (MeshFacet::TFlagType tF) const;
    void ResetFlag (MeshFacet::TFlagType tF) const;
    void ResetInvalid (void) const;
    void SetProperty (unsigned long ulVal) const;

    // Assignment
    MeshFacetArray& operator = (const MeshFacetArray &rclFAry);

    void Erase (_TIterator pIter);
    void TransposeIndices (unsigned long ulOrig, unsigned long ulNew);
    void DecrementIndices (unsigned long ulIndex);
};

inline MeshPoint::MeshPoint (const Base::Vector3f &rclPt)
#ifdef _MSC_VER
: Vector3f(rclPt),
#else
: Base::Vector3f(rclPt),
#endif
  _ucFlag(0),
  _ulProp(0)
{
}

inline MeshPoint::MeshPoint (const MeshPoint &rclPt)
#ifdef _MSC_VER
: Vector3f(rclPt),
#else
: Base::Vector3f(rclPt),
#endif
  _ucFlag(rclPt._ucFlag),
  _ulProp(rclPt._ulProp)
{
}

inline MeshPoint& MeshPoint::operator = (const MeshPoint &rclPt)
{
#ifdef _MSC_VER
    Vector3f::operator=(rclPt);
#else
    Base::Vector3f::operator=(rclPt);
#endif
    _ucFlag = rclPt._ucFlag;
    _ulProp = rclPt._ulProp;
    return *this;
}

inline bool MeshPoint::operator == (const MeshPoint &rclPt) const
{
    return Base::DistanceP2(*this, rclPt) < MeshDefinitions::_fMinPointDistanceP2;
}

inline bool MeshPoint::operator == (const Base::Vector3f &rclV) const
{
    return Base::DistanceP2(*this, rclV) < MeshDefinitions::_fMinPointDistanceP2;
}

inline bool MeshPoint::operator < (const MeshPoint &rclPt) const
{
    if (fabs ( this->x - rclPt.x ) >= MeshDefinitions::_fMinPointDistanceD1)
        return this->x < rclPt.x;
    if (fabs ( this->y - rclPt.y ) >= MeshDefinitions::_fMinPointDistanceD1)
        return this->y < rclPt.y;
    if (fabs ( this->z - rclPt.z ) >= MeshDefinitions::_fMinPointDistanceD1)
        return this->z < rclPt.z;
    return false; // points are considered to be equal
}

inline float MeshGeomFacet::DistancePlaneToPoint (const Base::Vector3f &rclPoint) const
{
    // internal normal is forced to have length equal to 1
    return float(fabs(rclPoint.DistanceToPlane(_aclPoints[0], GetNormal())));
}

inline void MeshGeomFacet::CalcNormal (void)
{
    _clNormal = (_aclPoints[1] - _aclPoints[0]) % (_aclPoints[2] - _aclPoints[0]);
    _clNormal.Normalize();
    _bNormalCalculated = true;
}

inline Base::Vector3f MeshGeomFacet::GetNormal (void) const
{
    if (_bNormalCalculated == false)
        const_cast<MeshGeomFacet*>(this)->CalcNormal();
    return _clNormal;
}

inline void MeshGeomFacet::SetNormal (const Base::Vector3f &rclNormal)
{
    if (rclNormal.Sqr() == 0.0f)
        return;
    _clNormal = rclNormal;
    _clNormal.Normalize();
    _bNormalCalculated = true;
}

inline void MeshGeomFacet::ArrangeNormal (const Base::Vector3f &rclN)
{
    // force internal normal to be computed if not done yet
    if ((rclN * GetNormal()) < 0.0f)
        _clNormal = -_clNormal;
}

inline Base::Vector3f MeshGeomFacet::GetGravityPoint (void) const
{
    return (1.0f / 3.0f) * (_aclPoints[0] + _aclPoints[1] + _aclPoints[2]);
}

inline void MeshGeomFacet::AdjustCirculationDirection (void)
{
    Base::Vector3f clN = (_aclPoints[1] - _aclPoints[0]) % (_aclPoints[2] - _aclPoints[0]);
    if ((clN * _clNormal) < 0.0f)
        std::swap(_aclPoints[1], _aclPoints[2]);
}

inline Base::BoundBox3f MeshGeomFacet::GetBoundBox (void) const
{
    return Base::BoundBox3f(_aclPoints, 3);
}

inline float MeshGeomFacet::Perimeter() const
{
    float perimeter=0.0f;
    perimeter += Base::Distance(_aclPoints[0], _aclPoints[1]);
    perimeter += Base::Distance(_aclPoints[1], _aclPoints[2]);
    perimeter += Base::Distance(_aclPoints[2], _aclPoints[0]);
    return perimeter;
}

inline float MeshGeomFacet::Area () const
{
    return ((_aclPoints[1] - _aclPoints[0]) % 
            (_aclPoints[2] - _aclPoints[0])).Length() / 2.0f;
}

inline bool MeshGeomFacet::ContainedByOrIntersectBoundingBox ( const Base::BoundBox3f &rclBB ) const
{
     // Test, ob alle Eckpunkte des Facets sich auf einer der 6 Seiten der BB befinden
    if ((GetBoundBox() && rclBB) == false)
        return false;

    // Test, ob Facet-BB komplett in BB liegt
    if (rclBB.IsInBox(GetBoundBox()))
        return true;

    // Test, ob einer der Eckpunkte in BB liegt
    for (int i=0;i<3;i++) {
        if (rclBB.IsInBox(_aclPoints[i]))
            return true;
    }

    // "echter" Test auf Schnitt
    if (IntersectBoundingBox(rclBB))
        return true;

    return false;
}

inline bool MeshGeomFacet::IntersectWithPlane (const Base::Vector3f &rclBase, const Base::Vector3f &rclNormal) const
{
    bool bD0 = (_aclPoints[0].DistanceToPlane(rclBase, rclNormal) > 0.0f); 
    return !((bD0 == (_aclPoints[1].DistanceToPlane(rclBase, rclNormal) > 0.0f)) &&
             (bD0 == (_aclPoints[2].DistanceToPlane(rclBase, rclNormal) > 0.0f)));
}

inline MeshFacet::MeshFacet (void)
: _ucFlag(0),
  _ulProp(0)
{
    memset(_aulNeighbours, 0xff, sizeof(ULONG_MAX) * 3);
    memset(_aulPoints, 0xff, sizeof(ULONG_MAX) * 3);
}

inline MeshFacet::MeshFacet(const MeshFacet &rclF)
: _ucFlag(rclF._ucFlag),
  _ulProp(rclF._ulProp)
{
    _aulPoints[0] = rclF._aulPoints[0];
    _aulPoints[1] = rclF._aulPoints[1];
    _aulPoints[2] = rclF._aulPoints[2];

    _aulNeighbours[0] = rclF._aulNeighbours[0];
    _aulNeighbours[1] = rclF._aulNeighbours[1];
    _aulNeighbours[2] = rclF._aulNeighbours[2];
}

inline MeshFacet::MeshFacet(unsigned long p1,unsigned long p2,unsigned long p3,
                            unsigned long n1,unsigned long n2,unsigned long n3)
: _ucFlag(0),
  _ulProp(0)
{
    _aulPoints[0] = p1;
    _aulPoints[1] = p2;
    _aulPoints[2] = p3;

    _aulNeighbours[0] = n1;
    _aulNeighbours[1] = n2;
    _aulNeighbours[2] = n3;
}

inline MeshFacet& MeshFacet::operator = (const MeshFacet &rclF)
{
    _ucFlag          = rclF._ucFlag;
    _ulProp          = rclF._ulProp;

    _aulPoints[0]    = rclF._aulPoints[0];
    _aulPoints[1]    = rclF._aulPoints[1];
    _aulPoints[2]    = rclF._aulPoints[2];

    _aulNeighbours[0] = rclF._aulNeighbours[0];
    _aulNeighbours[1] = rclF._aulNeighbours[1];
    _aulNeighbours[2] = rclF._aulNeighbours[2];

    return *this;
}

void MeshFacet::SetVertices(unsigned long p1,unsigned long p2,unsigned long p3)
{
    _aulPoints[0] = p1;
    _aulPoints[1] = p2;
    _aulPoints[2] = p3;
}

void MeshFacet::SetNeighbours(unsigned long n1,unsigned long n2,unsigned long n3)
{
    _aulNeighbours[0] = n1;
    _aulNeighbours[1] = n2;
    _aulNeighbours[2] = n3;
}

inline void MeshFacet::GetEdge (unsigned short usSide, MeshHelpEdge &rclEdge) const
{
    rclEdge._ulIndex[0] = _aulPoints[usSide];
    rclEdge._ulIndex[1] = _aulPoints[(usSide+1) % 3];
}

inline std::pair<unsigned long, unsigned long> MeshFacet::GetEdge (unsigned short usSide) const
{
    return std::pair<unsigned long, unsigned long>(_aulPoints[usSide], _aulPoints[(usSide+1)%3]);
}

inline void MeshFacet::Transpose (unsigned long ulOrig, unsigned long ulNew)
{
    if (_aulPoints[0] == ulOrig)
        _aulPoints[0] = ulNew;
    else if (_aulPoints[1] == ulOrig)
        _aulPoints[1] = ulNew;
    else if (_aulPoints[2] == ulOrig)
        _aulPoints[2] = ulNew;
}

inline void MeshFacet::Decrement (unsigned long ulIndex)
{
    if (_aulPoints[0] > ulIndex) _aulPoints[0]--;
    if (_aulPoints[1] > ulIndex) _aulPoints[1]--;
    if (_aulPoints[2] > ulIndex) _aulPoints[2]--;
}

inline void MeshFacet::ReplaceNeighbour (unsigned long ulOrig, unsigned long ulNew)
{
    if (_aulNeighbours[0] == ulOrig)
        _aulNeighbours[0] = ulNew;
    else if (_aulNeighbours[1] == ulOrig)
        _aulNeighbours[1] = ulNew;
    else if (_aulNeighbours[2] == ulOrig)
        _aulNeighbours[2] = ulNew;
}

inline unsigned short MeshFacet::CountOpenEdges() const
{
    unsigned short ct=0;
    for (unsigned short i=0; i<3; i++)
    { if ( !HasNeighbour(i) ) ct++; }
    return ct;
}

inline bool MeshFacet::HasOpenEdge() const
{
    return (CountOpenEdges() != 0);
}

inline bool MeshFacet::HasSameOrientation(const MeshFacet& f) const
{
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (_aulPoints[i] == f._aulPoints[j]) {
                if ((_aulPoints[(i+1)%3] == f._aulPoints[(j+1)%3]) ||
                    (_aulPoints[(i+2)%3] == f._aulPoints[(j+2)%3])) {
                    return false;
                }
            }
        }
    }

    return true;
}

inline bool MeshFacet::IsDegenerated() const
{
    if (_aulPoints[0] == _aulPoints[1])
        return true;
    if (_aulPoints[1] == _aulPoints[2])
        return true;
    if (_aulPoints[2] == _aulPoints[0])
        return true;
    return false;
}

inline unsigned short MeshFacet::Side (unsigned long ulNIndex) const
{
    if (_aulNeighbours[0] == ulNIndex)
        return 0;
    else if (_aulNeighbours[1] == ulNIndex)
        return 1;
    else if (_aulNeighbours[2] == ulNIndex)
        return 2;
    else
        return USHRT_MAX;
}

inline unsigned short MeshFacet::Side (unsigned long ulP0, unsigned long ulP1) const
{
    if (_aulPoints[0] == ulP0) {
        if (_aulPoints[1] == ulP1)
            return 0;  // Kante 0-1 ==> 0
        else if (_aulPoints[2] == ulP1)
            return 2;  // Kante 0-2 ==> 2
    }
    else if (_aulPoints[1] == ulP0) {
        if (_aulPoints[0] == ulP1)
            return 0; // Kante 1-0 ==> 0
        else if (_aulPoints[2] == ulP1)
            return 1; // Kante 1-2 ==> 1
    }
    else if (_aulPoints[2] == ulP0) {
        if (_aulPoints[0] == ulP1)
            return 2; // Kante 2-0 ==> 2
        else if (_aulPoints[1] == ulP1)
            return 1; // Kante 2-1 ==> 1
    }

    return USHRT_MAX;
}

inline unsigned short MeshFacet::Side (const MeshFacet& rFace) const
{
    unsigned short side;
    for (int i=0; i<3;i++){
        side = Side(rFace._aulPoints[i], rFace._aulPoints[(i+1)%3]);
        if (side != USHRT_MAX)
            return side;
    }

    return USHRT_MAX;
}

inline bool MeshFacet::IsEqual (const MeshFacet& rcFace) const
{
    for (int i=0; i<3; i++) {
        if (this->_aulPoints[0] == rcFace._aulPoints[i]) {
            if (this->_aulPoints[1] == rcFace._aulPoints[(i+1)%3] &&
                this->_aulPoints[2] == rcFace._aulPoints[(i+2)%3])
                return true;
            else if (this->_aulPoints[1] == rcFace._aulPoints[(i+2)%3] &&
                     this->_aulPoints[2] == rcFace._aulPoints[(i+1)%3])
                return true;
        }
    }

    return false;
}

template <class TCLASS>
class MeshIsFlag : public std::binary_function<TCLASS, typename TCLASS::TFlagType, bool>
{
public:
    bool operator () (const TCLASS& rclElem, typename TCLASS::TFlagType tFlag) const
    { return rclElem.IsFlag(tFlag); }
};

template <class TCLASS>
class MeshIsNotFlag : public std::binary_function<TCLASS, typename TCLASS::TFlagType, bool>
{
public:
    bool operator () (const TCLASS& rclElem, typename TCLASS::TFlagType tFlag) const
    { return !rclElem.IsFlag(tFlag); }
};

template <class TCLASS>
class MeshSetFlag : public std::binary_function<TCLASS, typename TCLASS::TFlagType, bool>
{
public:
    bool operator () (const TCLASS& rclElem, typename TCLASS::TFlagType tFlag) const
    { rclElem.SetFlag(tFlag); return true; }
};

template <class TCLASS>
class MeshResetFlag : public std::binary_function<TCLASS, typename TCLASS::TFlagType, bool>
{
public:
    bool operator () (const TCLASS& rclElem, typename TCLASS::TFlagType tFlag) const
    { rclElem.ResetFlag(tFlag); return true; }
};

} // namespace MeshCore

#endif // MESH_ELEMENTS_H