vtkCellIterator.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkCellIterator.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

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

       }

     vtkIdList *pointIds = it->GetPointIds();
     /* Do screening on the point ids, maybe figure out scalar range and skip
        cells that do not lie in a certain range? */

     vtkPoints *points = it->GetPoints();
     /* Do work using the cell points, or ... */

     vtkGenericCell *cell = ...;
     it->GetCell(cell);
     /* ... do work with a vtkCell. */
     }
   it->Delete();
 }
 ~~~

 The example above pulls in bits of information as needed to filter out cells
 that aren't relevent. The least expensive lookups are performed first
 (cell type, then point ids, then points/full cell) to prevent wasted cycles
 fetching unnecessary data. Also note that at the end of the loop, the
 iterator must be deleted as these iterators are vtkObject subclasses.

    @par      Tests:
              @ref c2_vtk_t_vtkCellIterator "vtkCellIterator (Tests)"
*/

#ifndef vtkCellIterator_h
#define vtkCellIterator_h

#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
#include "vtkNew.h" // For vtkNew
#include "vtkIdList.h" // For inline methods

class vtkGenericCell;
class vtkPoints;

class VTKCOMMONDATAMODEL_EXPORT vtkCellIterator : public vtkObject
{
public:
  virtual void PrintSelf(ostream &os, vtkIndent indent);
  vtkAbstractTypeMacro(vtkCellIterator, vtkObject)

  void InitTraversal();

  void GoToNextCell();

  virtual bool IsDoneWithTraversal() = 0;

  int GetCellType();

  virtual vtkIdType GetCellId() = 0;

  vtkIdList *GetPointIds();

  vtkPoints *GetPoints();

  vtkIdList *GetFaces();

  void GetCell(vtkGenericCell *cell);

  vtkIdType GetNumberOfPoints();

  vtkIdType GetNumberOfFaces();

protected:
  vtkCellIterator();
  ~vtkCellIterator();

  virtual void ResetToFirstCell() = 0;

  virtual void IncrementToNextCell() = 0;

  virtual void FetchCellType() = 0;

  virtual void FetchPointIds() = 0;

  virtual void FetchPoints() = 0;

  virtual void FetchFaces() { }

  int CellType;
  vtkPoints *Points;
  vtkIdList *PointIds;
  vtkIdList *Faces;

private:
  vtkCellIterator(const vtkCellIterator &); // Not implemented.
  void operator=(const vtkCellIterator &);   // Not implemented.

  enum
    {
    UninitializedFlag = 0x0,
    CellTypeFlag = 0x1,
    PointIdsFlag = 0x2,
    PointsFlag = 0x4,
    FacesFlag = 0x8
    };

  void ResetCache()
  {
    this->CacheFlags = UninitializedFlag;
    this->ResetContainers();
  }

  void SetCache(unsigned char flags)
  {
    this->CacheFlags |= flags;
  }

  bool CheckCache(unsigned char flags)
  {
    return (this->CacheFlags & flags) == flags;
  }

  void ResetContainers();

  vtkNew<vtkPoints> PointsContainer;
  vtkNew<vtkIdList> PointIdsContainer;
  vtkNew<vtkIdList> FacesContainer;
  unsigned char CacheFlags;
};

//------------------------------------------------------------------------------
inline void vtkCellIterator::InitTraversal()
{
  this->ResetToFirstCell();
  this->ResetCache();
}

//------------------------------------------------------------------------------
inline void vtkCellIterator::GoToNextCell()
{
  this->IncrementToNextCell();
  this->ResetCache();
}

//------------------------------------------------------------------------------
inline int vtkCellIterator::GetCellType()
{
  if (!this->CheckCache(CellTypeFlag))
    {
    this->FetchCellType();
    this->SetCache(CellTypeFlag);
    }
  return this->CellType;
}

//------------------------------------------------------------------------------
inline vtkIdList* vtkCellIterator::GetPointIds()
{
  if (!this->CheckCache(PointIdsFlag))
    {
    this->FetchPointIds();
    this->SetCache(PointIdsFlag);
    }
  return this->PointIds;
}

//------------------------------------------------------------------------------
inline vtkPoints* vtkCellIterator::GetPoints()
{
  if (!this->CheckCache(PointsFlag))
    {
    this->FetchPoints();
    this->SetCache(PointsFlag);
    }
  return this->Points;
}

//------------------------------------------------------------------------------
inline vtkIdList *vtkCellIterator::GetFaces()
{
  if (!this->CheckCache(FacesFlag))
    {
    this->FetchFaces();
    this->SetCache(FacesFlag);
    }
  return this->Faces;
}

//------------------------------------------------------------------------------
inline vtkIdType vtkCellIterator::GetNumberOfPoints()
{
  if (!this->CheckCache(PointIdsFlag))
    {
    this->FetchPointIds();
    this->SetCache(PointIdsFlag);
    }
  return this->PointIds->GetNumberOfIds();
}

//------------------------------------------------------------------------------
inline vtkIdType vtkCellIterator::GetNumberOfFaces()
{
  if (!this->CheckCache(FacesFlag))
    {
    this->FetchFaces();
    this->SetCache(FacesFlag);
    }
  return this->Faces->GetNumberOfIds() != 0 ? this->Faces->GetId(0) : 0;
}

#endif //vtkCellIterator_h