MeVisLab/Standard/Sources/ML/MLCSO/CSOTools/CSOPathPointIterator.h

Go to the documentation of this file.

// **InsertLicense** code
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

#ifndef __CSOPathPointIterator_H
#define __CSOPathPointIterator_H

#include "CSOBase/CSO.h"
#include "MLCSOIncludes.h"

ML_START_NAMESPACE 

class MLCSO_EXPORT CSOPathPointIterator
{
public:


  static const unsigned int INVALID_INDEX;


  CSOPathPointIterator();
  CSOPathPointIterator(CSO* cso, unsigned int startPathIndex=0, unsigned int startPointIndex=0);
  CSOPathPointIterator(CSO* cso, CSOPathPoints* pathPoints, unsigned int startPathIndex, unsigned int startPointIndex=0);
  CSOPathPointIterator(CSO* cso, CSOPathPoints* pathPoints, unsigned int startPointIndex=0);
  CSOPathPointIterator(CSO* cso, CSOSeedPoint* startSeedPoint);
  CSOPathPointIterator(const CSOPathPointIterator& rhs);

  ~CSOPathPointIterator() {}


  CSOPathPointIterator&   operator++  ();
  CSOPathPointIterator    operator++  (int dummy);

  CSOPathPointIterator&   operator--  ();
  CSOPathPointIterator    operator--  (int dummy);

  CSOPathPointIterator&   operator+=  (int offset);
  CSOPathPointIterator&   operator-=  (int offset);

  CSOPathPointIterator    operator+   (int offset) const;
  CSOPathPointIterator    operator-   (int offset) const;

  CSOPathPointIterator&   operator=   (const CSOPathPointIterator& rhs);

  bool                    operator==  (const CSOPathPointIterator& rhs) const;
  bool                    operator!=  (const CSOPathPointIterator& rhs) const;
  bool                    operator>   (const CSOPathPointIterator& rhs) const;
  bool                    operator>=  (const CSOPathPointIterator& rhs) const;
  bool                    operator<   (const CSOPathPointIterator& rhs) const;
  bool                    operator<=  (const CSOPathPointIterator& rhs) const;


  inline const CSO*     getCSO          () const    { return _cso; }
  inline CSO*           getCSO          ()          { return _cso; }

  inline unsigned int   getPathIndex    () const    { return _pathIndex;   }
  inline unsigned int   getPointIndex   () const    { return _pointIndex;  }

  // Returns a pointer to the current path point list.
  inline const CSOPathPoints* getPathPoints() const { return _pathPoints;  }
  // Returns a pointer to the current path point list.
  inline CSOPathPoints*       getPathPoints()       { return _pathPoints;  }

  inline Vector3        getPos          () const    { return _pathPoints->getPosAt(_pointIndex); }
  inline const Vector4&    getPosValue     () const    { return _pathPoints->getPosValueAt(_pointIndex);   }
  inline double         getValue        () const    { return _pathPoints->getValueAt(_pointIndex);      }

  inline void           setPos(const Vector3& p)       { _pathPoints->setPosAt(p, _pointIndex);            }
  inline void           setPosValue(const Vector4& p)  { _pathPoints->setPosValueAt(p, _pointIndex);       }
  inline void           setValue(const double& v)   { _pathPoints->setValueAt(static_cast<float>(v), _pointIndex);          }

  inline unsigned int   numPoints               () const { return _numPoints; }
  inline unsigned int   numProcessedPoints      () const { return mlAbs(_pointCounterInc-_pointCounterDec); }
  inline unsigned int   numTotalProcessedPoints () const { return isEnd() ? _pointCounterInc+_pointCounterDec : _pointCounterInc+_pointCounterDec+1; }


  void                  resetCounters() { _pointCounterInc = _pointCounterDec = 0; }


  void                  makeEnd();
  inline bool           isEnd() const { return (_pathIndex == INVALID_INDEX) && (_pointIndex == INVALID_INDEX); }

  CSOPathPointIterator  next()  const;
  CSOPathPointIterator  prev()  const;

private:

  void _copy(const CSOPathPointIterator& rhs);

  bool _valid() const;

  bool _findValidPathPointList();

  CSO* _cso;
  CSOPathPoints* _pathPoints;

  unsigned int _pathIndex;
  unsigned int _pointIndex;

  unsigned int _numPathPointLists;
  unsigned int _numPoints;

  unsigned int _startPathIndex;
  unsigned int _startPointIndex;

  unsigned int _pointCounterInc;

  unsigned int _pointCounterDec;

};

class MLCSO_EXPORT CSOPathPointConstIterator
{
public:


  static const unsigned int INVALID_INDEX;


  CSOPathPointConstIterator();
  CSOPathPointConstIterator(const CSO* cso, unsigned int startPathIndex=0, unsigned int startPointIndex=0);
  CSOPathPointConstIterator(const CSO* cso, const CSOPathPoints* pathPoints, unsigned int startPathIndex, unsigned int startPointIndex=0);
  CSOPathPointConstIterator(const CSO* cso, const CSOPathPoints* pathPoints, unsigned int startPointIndex=0);
  CSOPathPointConstIterator(const CSO* cso, const CSOSeedPoint* startSeedPoint);
  CSOPathPointConstIterator(const CSOPathPointConstIterator& rhs);

  ~CSOPathPointConstIterator() {}


  CSOPathPointConstIterator&  operator++  ();
  CSOPathPointConstIterator   operator++  (int dummy);

  CSOPathPointConstIterator&  operator--  ();
  CSOPathPointConstIterator   operator--  (int dummy);

  CSOPathPointConstIterator&  operator+=  (int offset);
  CSOPathPointConstIterator&  operator-=  (int offset);

  CSOPathPointConstIterator   operator+   (int offset) const;
  CSOPathPointConstIterator   operator-   (int offset) const;

  CSOPathPointConstIterator&  operator=   (const CSOPathPointConstIterator& rhs);

  bool                        operator==  (const CSOPathPointConstIterator& rhs) const;
  bool                        operator!=  (const CSOPathPointConstIterator& rhs) const;
  bool                        operator>   (const CSOPathPointConstIterator& rhs) const;
  bool                        operator>=  (const CSOPathPointConstIterator& rhs) const;
  bool                        operator<   (const CSOPathPointConstIterator& rhs) const;
  bool                        operator<=  (const CSOPathPointConstIterator& rhs) const;


  inline const CSO*           getCSO          () const    { return _cso; }

  inline unsigned int         getPathIndex    () const    { return _pathIndex;   }
  inline unsigned int         getPointIndex   () const    { return _pointIndex;  }

  // Returns a pointer to the current path point list.
  inline const CSOPathPoints* getPathPoints   () const    { return _pathPoints;  }

  inline Vector3              getPos          () const    { return _pathPoints->getPosAt(_pointIndex); }
  inline const Vector4&       getPosValue     () const    { return _pathPoints->getPosValueAt(_pointIndex);   }
  inline double               getValue        () const    { return _pathPoints->getValueAt(_pointIndex);      }

  inline unsigned int         numPoints               () const { return _numPoints; }
  inline unsigned int         numProcessedPoints      () const { return mlAbs(_pointCounterInc-_pointCounterDec); }
  inline unsigned int         numTotalProcessedPoints () const { return isEnd() ? _pointCounterInc+_pointCounterDec : _pointCounterInc+_pointCounterDec+1; }


  void                        resetCounters() { _pointCounterInc = _pointCounterDec = 0; }


  void                        makeEnd();
  inline bool                 isEnd() const { return (_pathIndex == INVALID_INDEX) && (_pointIndex == INVALID_INDEX); }

  CSOPathPointConstIterator   next()  const;
  CSOPathPointConstIterator   prev()  const;

private:

  void _copy(const CSOPathPointConstIterator& rhs);

  bool _valid() const;

  bool _findValidPathPointList();

  const CSO* _cso;
  const CSOPathPoints* _pathPoints;

  unsigned int _pathIndex;
  unsigned int _pointIndex;

  unsigned int _numPathPointLists;
  unsigned int _numPoints;

  unsigned int _startPathIndex;
  unsigned int _startPointIndex;

  unsigned int _pointCounterInc;

  unsigned int _pointCounterDec;

};

const CSOPathPointIterator CSOPathPointIteratorEnd  = CSOPathPointIterator();

const CSOPathPointConstIterator CSOPathPointConstIteratorEnd  = CSOPathPointConstIterator();

ML_END_NAMESPACE

#endif // __CSOPathPointIterator_H