vtkPolyData.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkPolyData.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.

=========================================================================*/
#ifndef vtkPolyData_h
#define vtkPolyData_h

#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkPointSet.h"

#include "vtkCellTypes.h" // Needed for inline methods
#include "vtkCellLinks.h" // Needed for inline methods
#include "vtkCellArray.h" // Needed for inline methods

class vtkVertex;
class vtkPolyVertex;
class vtkLine;
class vtkPolyLine;
class vtkTriangle;
class vtkQuad;
class vtkPolygon;
class vtkTriangleStrip;
class vtkEmptyCell;
struct vtkPolyDataDummyContainter;

class VTKCOMMONDATAMODEL_EXPORT vtkPolyData : public vtkPointSet
{
public:
  static vtkPolyData *New();

  vtkTypeMacro(vtkPolyData,vtkPointSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  int GetDataObjectType() override {return VTK_POLY_DATA;}

  void CopyStructure(vtkDataSet *ds) override;


  vtkIdType GetNumberOfCells() override;
  using vtkDataSet::GetCell;
  vtkCell *GetCell(vtkIdType cellId) override;
  void GetCell(vtkIdType cellId, vtkGenericCell *cell) override;
  int GetCellType(vtkIdType cellId) override;
  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
  void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
                        vtkIdList *cellIds) override;

  void CopyCells(vtkPolyData *pd, vtkIdList *idList,
                 vtkPointLocator *locator = nullptr);

  void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override;

  void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override;

  void ComputeBounds() override;

  void Squeeze() override;

  int GetMaxCellSize() override;

  void SetVerts (vtkCellArray* v);

  vtkCellArray *GetVerts();

  void SetLines (vtkCellArray* l);

  vtkCellArray *GetLines();

  void SetPolys (vtkCellArray* p);

  vtkCellArray *GetPolys();

  void SetStrips (vtkCellArray* s);

  vtkCellArray *GetStrips();


  vtkIdType GetNumberOfVerts();
  vtkIdType GetNumberOfLines();
  vtkIdType GetNumberOfPolys();
  vtkIdType GetNumberOfStrips();

  void Allocate(vtkIdType numCells=1000, int extSize=1000);

  void Allocate(vtkPolyData *inPolyData, vtkIdType numCells=1000,
                int extSize=1000);

  vtkIdType InsertNextCell(int type, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);

  vtkIdType InsertNextCell(int type, vtkIdList *pts);

  void Reset();

  void BuildCells();

  bool NeedToBuildCells() { return this->Cells == nullptr; }

  void BuildLinks(int initialSize=0);

  void DeleteCells();

  void DeleteLinks();

  void GetPointCells(vtkIdType ptId, unsigned short& ncells,
                     vtkIdType* &cells) VTK_SIZEHINT(cells, ncells);

  void GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1, vtkIdType p2,
                            vtkIdList *cellIds);

  unsigned char GetCellPoints(vtkIdType cellId,
      vtkIdType& npts, vtkIdType* &pts) VTK_SIZEHINT(pts, npts);

  unsigned char GetCell(vtkIdType cellId, vtkIdType* &pts);

  int IsTriangle(int v1, int v2, int v3);

  int IsEdge(vtkIdType p1, vtkIdType p2);

  int IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId);

  void ReplaceCell(vtkIdType cellId, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);

  void ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId,
                        vtkIdType newPtId);

  void ReverseCell(vtkIdType cellId);


  void DeletePoint(vtkIdType ptId);
  void DeleteCell(vtkIdType cellId);

  void RemoveDeletedCells();


  vtkIdType InsertNextLinkedPoint(int numLinks);
  vtkIdType InsertNextLinkedPoint(double x[3], int numLinks);

  vtkIdType InsertNextLinkedCell(int type, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);

  void ReplaceLinkedCell(vtkIdType cellId, int npts, const vtkIdType pts[]) VTK_SIZEHINT(pts, npts);

  void RemoveCellReference(vtkIdType cellId);

  void AddCellReference(vtkIdType cellId);

  void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId);

  void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId);

  void ResizeCellList(vtkIdType ptId, int size);

  void Initialize() override;


  virtual int GetPiece();
  virtual int GetNumberOfPieces();

  virtual int GetGhostLevel();

  unsigned long GetActualMemorySize() override;


  void ShallowCopy(vtkDataObject *src) override;
  void DeepCopy(vtkDataObject *src) override;

  void RemoveGhostCells();


  static vtkPolyData* GetData(vtkInformation* info);
  static vtkPolyData* GetData(vtkInformationVector* v, int i=0);

  enum
  {
    ERR_NO_SUCH_FIELD = -4,
    ERR_INCORRECT_FIELD = -3,
    ERR_NON_MANIFOLD_STAR = -2,
    REGULAR_POINT = -1,
    MINIMUM = 0,
    SADDLE = 1,
    MAXIMUM = 2
  };

  int GetScalarFieldCriticalIndex (vtkIdType pointId,
                                   vtkDataArray *scalarField);
  int GetScalarFieldCriticalIndex (vtkIdType pointId, int fieldId);
  int GetScalarFieldCriticalIndex (vtkIdType pointId, const char* fieldName);

  virtual vtkMTimeType GetMeshMTime();

  vtkMTimeType GetMTime() override;

protected:
  vtkPolyData();
  ~vtkPolyData() override;

  // constant cell objects returned by GetCell called.
  vtkVertex *Vertex;
  vtkPolyVertex *PolyVertex;
  vtkLine *Line;
  vtkPolyLine *PolyLine;
  vtkTriangle *Triangle;
  vtkQuad *Quad;
  vtkPolygon *Polygon;
  vtkTriangleStrip *TriangleStrip;
  vtkEmptyCell *EmptyCell;

  // points inherited
  // point data (i.e., scalars, vectors, normals, tcoords) inherited
  vtkCellArray *Verts;
  vtkCellArray *Lines;
  vtkCellArray *Polys;
  vtkCellArray *Strips;

  // dummy static member below used as a trick to simplify traversal
  static vtkPolyDataDummyContainter DummyContainer;

  // supporting structures for more complex topological operations
  // built only when necessary
  vtkCellTypes *Cells;
  vtkCellLinks *Links;

private:
  // Hide these from the user and the compiler.

  void GetCellNeighbors(vtkIdType cellId, vtkIdList& ptIds, vtkIdList& cellIds)
    {this->GetCellNeighbors(cellId, &ptIds, &cellIds);}

  void Cleanup();

private:
  vtkPolyData(const vtkPolyData&) = delete;
  void operator=(const vtkPolyData&) = delete;
};

inline void vtkPolyData::GetPointCells(vtkIdType ptId, unsigned short& ncells,
                                       vtkIdType* &cells)
{
  ncells = this->Links->GetNcells(ptId);
  cells = this->Links->GetCells(ptId);
}

inline int vtkPolyData::IsTriangle(int v1, int v2, int v3)
{
  unsigned short int n1;
  int i, j, tVerts[3];
  vtkIdType *cells, *tVerts2, n2;

  tVerts[0] = v1;
  tVerts[1] = v2;
  tVerts[2] = v3;

  for (i=0; i<3; i++)
  {
    this->GetPointCells(tVerts[i], n1, cells);
    for (j=0; j<n1; j++)
    {
      this->GetCellPoints(cells[j], n2, tVerts2);
      if ( (tVerts[0] == tVerts2[0] || tVerts[0] == tVerts2[1] ||
            tVerts[0] == tVerts2[2]) &&
           (tVerts[1] == tVerts2[0] || tVerts[1] == tVerts2[1] ||
            tVerts[1] == tVerts2[2]) &&
           (tVerts[2] == tVerts2[0] || tVerts[2] == tVerts2[1] ||
            tVerts[2] == tVerts2[2]) )
      {
        return 1;
      }
    }
  }
  return 0;
}

inline int vtkPolyData::IsPointUsedByCell(vtkIdType ptId, vtkIdType cellId)
{
  vtkIdType *pts, npts;

  this->GetCellPoints(cellId, npts, pts);
  for (vtkIdType i=0; i < npts; i++)
  {
    if ( pts[i] == ptId )
    {
      return 1;
    }
  }

  return 0;
}

inline void vtkPolyData::DeletePoint(vtkIdType ptId)
{
  this->Links->DeletePoint(ptId);
}

inline void vtkPolyData::DeleteCell(vtkIdType cellId)
{
  this->Cells->DeleteCell(cellId);
}

inline void vtkPolyData::RemoveCellReference(vtkIdType cellId)
{
  vtkIdType *pts, npts;

  this->GetCellPoints(cellId, npts, pts);
  for (vtkIdType i=0; i<npts; i++)
  {
    this->Links->RemoveCellReference(cellId, pts[i]);
  }
}

inline void vtkPolyData::AddCellReference(vtkIdType cellId)
{
  vtkIdType *pts, npts;

  this->GetCellPoints(cellId, npts, pts);
  for (vtkIdType i=0; i<npts; i++)
  {
    this->Links->AddCellReference(cellId, pts[i]);
  }
}

inline void vtkPolyData::ResizeCellList(vtkIdType ptId, int size)
{
  this->Links->ResizeCellList(ptId,size);
}

inline void vtkPolyData::ReplaceCellPoint(vtkIdType cellId, vtkIdType oldPtId,
                                          vtkIdType newPtId)
{
  int i;
  vtkIdType *verts, nverts;

  this->GetCellPoints(cellId,nverts,verts);
  for ( i=0; i < nverts; i++ )
  {
    if ( verts[i] == oldPtId )
    {
      verts[i] = newPtId; // this is very nasty! direct write!
      return;
    }
  }
}

inline unsigned char vtkPolyData::GetCellPoints(
    vtkIdType cellId, vtkIdType& npts, vtkIdType* &pts)
{
  unsigned char type = this->Cells->GetCellType(cellId);
  vtkCellArray *cells;
  switch (type)
  {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
      cells = this->Verts;
      break;

    case VTK_LINE: case VTK_POLY_LINE:
      cells = this->Lines;
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      cells = this->Polys;
      break;

    case VTK_TRIANGLE_STRIP:
      cells = this->Strips;
      break;

    default:
      cells = nullptr;
      npts = 0;
      pts = nullptr;
      return 0;
  }
  int loc = this->Cells->GetCellLocation(cellId);
  cells->GetCell(loc, npts, pts);
  return type;
}

inline unsigned char vtkPolyData::GetCell(
    vtkIdType cellId, vtkIdType* &cell)
{
  unsigned char type = this->Cells->GetCellType(cellId);
  vtkCellArray *cells;
  switch (type)
  {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
      cells = this->Verts;
      break;

    case VTK_LINE: case VTK_POLY_LINE:
      cells = this->Lines;
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      cells = this->Polys;
      break;

    case VTK_TRIANGLE_STRIP:
      cells = this->Strips;
      break;

    default:
      cells = nullptr;
      cell = nullptr;
      return 0;
  }
  int loc = this->Cells->GetCellLocation(cellId);
  cell = cells->GetData()->GetPointer(loc);
  return type;
}

#endif