Iterator.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_ITERATOR_H
#define MESH_ITERATOR_H

#include "MeshKernel.h"
#include "Elements.h"
#include <Base/Matrix.h>
#include <Base/Vector3D.h>
#include <climits>

namespace MeshCore {

class MeshKernel;
class MeshGeomFacet;
class MeshPoint;
class MeshGeomEdge;
class MeshIndexEdge;
class MeshHelpEdge;

class MeshFacetIterator
{
public:

  inline MeshFacetIterator (const MeshKernel &rclM);
  inline MeshFacetIterator (const MeshKernel &rclM, unsigned long ulPos);
  inline MeshFacetIterator (const MeshFacetIterator &rclI);


  inline void Transform( const Base::Matrix4D& rclTrf );


  const MeshGeomFacet& operator*(void)
  { return Dereference(); }
  const MeshGeomFacet* operator->(void)
  { return &Dereference(); }
  const MeshFacetIterator& operator ++ (void)
  { _clIter++; return *this; }
  const MeshFacetIterator& operator -- (void)
  { _clIter--; return *this; }
  const MeshFacetIterator& operator += (int k)
  { _clIter += k; return *this; }
  const MeshFacetIterator& operator -= (int k)
  { _clIter -= k; return *this; }
  inline MeshFacetIterator& operator = (const MeshFacetIterator &rpI);
  bool operator < (const MeshFacetIterator &rclI) const
  { return _clIter < rclI._clIter; }
  bool operator > (const MeshFacetIterator &rclI) const
  { return _clIter > rclI._clIter; }
  bool operator == (const MeshFacetIterator &rclI) const
  { return _clIter == rclI._clIter; }
  void Begin (void)
  { _clIter = _rclFAry.begin(); }
  void End (void)
  { _clIter = _rclFAry.end(); }
  unsigned long Position (void) const
  { return _clIter - _rclFAry.begin(); }
  bool EndReached (void) const
  { return !(_clIter < _rclFAry.end()); }
  void  Init (void)
  { Begin(); }
  bool More (void) const
  { return !EndReached(); }
  void  Next (void)
  { operator++(); }
  inline bool Set (unsigned long ulIndex);
  inline MeshFacet GetIndices (void) const
  { return *_clIter; }
  inline const MeshFacet& GetReference (void) const
  { return *_clIter; }
  inline void GetNeighbours (MeshFacetIterator &rclN0, MeshFacetIterator &rclN1, MeshFacetIterator &rclN2) const;
  inline void SetToNeighbour (unsigned short usN);
  inline unsigned long GetProperty (void) const;
  inline bool IsValid (void) const
  { return (_clIter >= _rclFAry.begin()) && (_clIter < _rclFAry.end()); }

  void SetFlag (MeshFacet::TFlagType tF) const
  { this->_clIter->SetFlag(tF); }
  void ResetFlag (MeshFacet::TFlagType tF) const
  { this->_clIter->ResetFlag(tF); }
  bool IsFlag (MeshFacet::TFlagType tF) const
  { return this->_clIter->IsFlag(tF); }
  void SetProperty(unsigned long uP) const
  { this->_clIter->SetProperty(uP); }

protected:
  inline const MeshGeomFacet& Dereference (void);

protected:
  const MeshKernel&     _rclMesh;
  const MeshFacetArray& _rclFAry;
  const MeshPointArray& _rclPAry;
  MeshFacetArray::_TConstIterator _clIter;
  MeshGeomFacet _clFacet;
  bool _bApply;
  Base::Matrix4D _clTrf;

  // friends
  friend class MeshKernel;
};

class MeshExport MeshPointIterator
{
public:
  inline MeshPointIterator (const MeshKernel &rclM);
  inline MeshPointIterator (const MeshKernel &rclM, unsigned long ulPos);
  inline MeshPointIterator (const MeshPointIterator &rclI);
 

  inline void Transform( const Base::Matrix4D& rclTrf );
 

  const MeshPoint& operator*(void) const
  { return Dereference(); }
  const MeshPoint* operator->(void) const
  { return &Dereference(); }
  const MeshPointIterator& operator ++ (void)
        { _clIter++; return *this; }
  const MeshPointIterator& operator -- (void)
        { _clIter--; return *this; }
  inline MeshPointIterator& operator = (const MeshPointIterator &rpI);
  bool operator < (const MeshPointIterator &rclI) const
  { return _clIter < rclI._clIter; }
  bool operator > (const MeshPointIterator &rclI) const
  { return _clIter > rclI._clIter; }
  bool operator == (const MeshPointIterator &rclI) const
  { return _clIter == rclI._clIter; }
  void Begin (void)
  { _clIter = _rclPAry.begin(); }
  void End (void)
  { _clIter = _rclPAry.end(); }
  unsigned long Position (void) const
  { return _clIter - _rclPAry.begin(); }
  bool EndReached (void) const
  { return !(_clIter < _rclPAry.end()); }
  void  Init (void)
  { Begin(); }
  bool More (void) const
  { return !EndReached(); }
  void  Next (void)
  { operator++(); }
  inline bool Set (unsigned long ulIndex);
  inline bool IsValid (void) const
  { return (_clIter >= _rclPAry.begin()) && (_clIter < _rclPAry.end()); }

  void SetFlag (MeshPoint::TFlagType tF) const
  { this->_clIter->SetFlag(tF); }
  void ResetFlag (MeshPoint::TFlagType tF) const
  { this->_clIter->ResetFlag(tF); }
  bool IsFlag (MeshPoint::TFlagType tF) const
  { return this->_clIter->IsFlag(tF); }
  void SetProperty(unsigned long uP) const
  { this->_clIter->SetProperty(uP); }

protected:
  inline const MeshPoint& Dereference (void) const;

protected:
  const MeshKernel& _rclMesh;
  const MeshPointArray& _rclPAry;
  MeshPoint _clPoint;
  MeshPointArray::_TConstIterator _clIter;
  bool _bApply;
  Base::Matrix4D _clTrf;

  // friends
  friend class MeshKernel;
};

class MeshFastFacetIterator
{
public:
  inline MeshFastFacetIterator (const MeshKernel &rclM);
  virtual ~MeshFastFacetIterator () {}

  void Init (void) { _clIter = _rclFAry.begin(); }
  inline void Next (void);
  bool More (void) { return _clIter != _rclFAry.end(); }

  Base::Vector3f _afPoints[3];

protected:
  const MeshKernel&     _rclMesh;
  const MeshFacetArray& _rclFAry;
  const MeshPointArray& _rclPAry;
  MeshFacetArray::_TConstIterator _clIter;

private:
  MeshFastFacetIterator (const MeshFastFacetIterator&);
  void operator = (const MeshFastFacetIterator&);
};

inline MeshFastFacetIterator::MeshFastFacetIterator (const MeshKernel &rclM)
: _rclMesh(rclM),
  _rclFAry(rclM._aclFacetArray),
  _rclPAry(rclM._aclPointArray),
  _clIter(_rclFAry.begin())
{
}

inline void MeshFastFacetIterator::Next (void)
{
  const unsigned long *paulPt = _clIter->_aulPoints;
  Base::Vector3f *pfPt = _afPoints;
  *(pfPt++)      = _rclPAry[*(paulPt++)];
  *(pfPt++)      = _rclPAry[*(paulPt++)];
  *pfPt          = _rclPAry[*paulPt];
}

inline MeshFacetIterator::MeshFacetIterator (const MeshKernel &rclM)
: _rclMesh(rclM),
  _rclFAry(rclM._aclFacetArray),
  _rclPAry(rclM._aclPointArray),
  _clIter(rclM._aclFacetArray.begin()),
  _bApply(false)
{
}

inline MeshFacetIterator::MeshFacetIterator (const MeshKernel &rclM, unsigned long ulPos)
: _rclMesh(rclM),
  _rclFAry(rclM._aclFacetArray),
  _rclPAry(rclM._aclPointArray),
  _clIter(rclM._aclFacetArray.begin() + ulPos),
  _bApply(false)
{
}

inline MeshFacetIterator::MeshFacetIterator (const MeshFacetIterator &rclI)
: _rclMesh(rclI._rclMesh),
  _rclFAry(rclI._rclFAry),
  _rclPAry(rclI._rclPAry),
  _clIter(rclI._clIter),
  _bApply(rclI._bApply),
  _clTrf(rclI._clTrf)
{
}

inline void MeshFacetIterator::Transform( const Base::Matrix4D& rclTrf )
{
  _clTrf = rclTrf;
  Base::Matrix4D tmp;
  // cecks for unit matrix
  _clTrf != tmp ? _bApply = true : _bApply = false;
}

inline const MeshGeomFacet& MeshFacetIterator::Dereference (void)
{
  MeshFacet rclF             = *_clIter;
  const unsigned long *paulPt        = &(_clIter->_aulPoints[0]);
  Base::Vector3f  *pclPt = _clFacet._aclPoints;
  *(pclPt++)       = _rclPAry[*(paulPt++)];
  *(pclPt++)       = _rclPAry[*(paulPt++)];
  *pclPt           = _rclPAry[*paulPt];
  _clFacet._ulProp = rclF._ulProp;
  _clFacet._ucFlag = rclF._ucFlag;
  _clFacet.NormalInvalid();
  if ( _bApply )
  {
    _clFacet._aclPoints[0] = _clTrf * _clFacet._aclPoints[0];
    _clFacet._aclPoints[1] = _clTrf * _clFacet._aclPoints[1];
    _clFacet._aclPoints[2] = _clTrf * _clFacet._aclPoints[2];
  }
  return _clFacet;
}

inline bool MeshFacetIterator::Set (unsigned long ulIndex)
{
  if (ulIndex < _rclFAry.size())
  {
    _clIter    = _rclFAry.begin() + ulIndex;
    return true;
  }
  else
  {
    _clIter    = _rclFAry.end();
    return false;
  }
}

inline MeshFacetIterator& MeshFacetIterator::operator = (const MeshFacetIterator &rpI)
{
  _clIter  = rpI._clIter;
  _bApply = rpI._bApply;
  _clTrf = rpI._clTrf;
  // dirty flat copy of reference
  memcpy((void*)&_rclMesh, &rpI._rclMesh, sizeof(&_rclMesh));
  return *this;
}

inline unsigned long MeshFacetIterator::GetProperty (void) const
{
  return _clIter->_ulProp;
}

inline void MeshFacetIterator::GetNeighbours (MeshFacetIterator &rclN0, MeshFacetIterator &rclN1, MeshFacetIterator &rclN2) const
{
  if (_clIter->_aulNeighbours[0] != ULONG_MAX)
    rclN0.Set(_clIter->_aulNeighbours[0]);
  else
    rclN0.End();

  if (_clIter->_aulNeighbours[1] != ULONG_MAX)
    rclN1.Set(_clIter->_aulNeighbours[1]);
  else
    rclN1.End();

  if (_clIter->_aulNeighbours[2] != ULONG_MAX)
    rclN2.Set(_clIter->_aulNeighbours[2]);
  else
    rclN2.End();
}

inline void MeshFacetIterator::SetToNeighbour (unsigned short usN)
{ 
  if (_clIter->_aulNeighbours[usN] != ULONG_MAX)
    _clIter = _rclFAry.begin() + _clIter->_aulNeighbours[usN];
  else
    End();
}

inline MeshPointIterator::MeshPointIterator (const MeshKernel &rclM)
: _rclMesh(rclM), _rclPAry(_rclMesh._aclPointArray), _bApply(false)
{
  _clIter = _rclPAry.begin();
}

inline MeshPointIterator::MeshPointIterator (const MeshKernel &rclM, unsigned long ulPos)
: _rclMesh(rclM), _rclPAry(_rclMesh._aclPointArray), _bApply(false)
{
  _clIter = _rclPAry.begin() + ulPos;
}

inline MeshPointIterator::MeshPointIterator (const MeshPointIterator &rclI)
: _rclMesh(rclI._rclMesh), _rclPAry(rclI._rclPAry), _clIter(rclI._clIter), _bApply(rclI._bApply), _clTrf(rclI._clTrf)
{
}

inline void MeshPointIterator::Transform( const Base::Matrix4D& rclTrf )
{
  _clTrf = rclTrf;
  Base::Matrix4D tmp;
  // cecks for unit matrix
  _clTrf != tmp ? _bApply = true : _bApply = false;
}

inline const MeshPoint& MeshPointIterator::Dereference (void) const
{ // We change only the value of the point but not the actual iterator
  const_cast<MeshPointIterator*>(this)->_clPoint = *_clIter;
  if ( _bApply )
    const_cast<MeshPointIterator*>(this)->_clPoint = _clTrf * _clPoint;
  return _clPoint; 
}

inline bool MeshPointIterator::Set (unsigned long ulIndex)
{
  if (ulIndex < _rclPAry.size())
  {
    _clIter = _rclPAry.begin() + ulIndex;
    return true;
  }
  else
  {
    _clIter = _rclPAry.end();
    return false;
  }
}

inline MeshPointIterator& MeshPointIterator::operator = (const MeshPointIterator &rpI)
{
  _clIter  = rpI._clIter;
  _bApply = rpI._bApply;
  _clTrf = rpI._clTrf;
  // dirty flat copy of reference
  memcpy((void*)&_rclMesh, &rpI._rclMesh, sizeof(&_rclMesh));
  return *this;
}


} // namespace MeshCore


#endif // MESH_ITERATOR_H