vtkCellLinks.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkCellLinks.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 vtkCellLinks_h
#define vtkCellLinks_h
 
#include "vtkAbstractCellLinks.h"
#include "vtkCommonDataModelModule.h" // For export macro
 
class vtkDataSet;
class vtkCellArray;
 
class VTKCOMMONDATAMODEL_EXPORT vtkCellLinks : public vtkAbstractCellLinks
{
public:
  class Link
  {
  public:
    vtkIdType ncells;
    vtkIdType* cells;
  };
 
 
  static vtkCellLinks* New();
  vtkTypeMacro(vtkCellLinks, vtkAbstractCellLinks);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void BuildLinks(vtkDataSet* data) override;
 
  void Allocate(vtkIdType numLinks, vtkIdType ext = 1000);
 
  void Initialize() override;
 
  Link& GetLink(vtkIdType ptId) { return this->Array[ptId]; }
 
  vtkIdType GetNcells(vtkIdType ptId) { return this->Array[ptId].ncells; }
 
  vtkIdType* GetCells(vtkIdType ptId) { return this->Array[ptId].cells; }
 
 
  void SelectCells(vtkIdType minMaxDegree[2], unsigned char* cellSelection) override;
 
  vtkIdType InsertNextPoint(int numLinks);
 
  void InsertNextCellReference(vtkIdType ptId, vtkIdType cellId);
 
  void DeletePoint(vtkIdType ptId);
 
  void RemoveCellReference(vtkIdType cellId, vtkIdType ptId);
 
  void AddCellReference(vtkIdType cellId, vtkIdType ptId);
 
  void ResizeCellList(vtkIdType ptId, int size);
 
  void Squeeze() override;
 
  void Reset() override;
 
  unsigned long GetActualMemorySize() override;
 
  void DeepCopy(vtkAbstractCellLinks* src) override;
 
protected:
  vtkCellLinks()
    : Array(nullptr)
    , Size(0)
    , MaxId(-1)
    , Extend(1000)
    , NumberOfPoints(0)
    , NumberOfCells(0)
  {
  }
  ~vtkCellLinks() override;
 
  void IncrementLinkCount(vtkIdType ptId) { this->Array[ptId].ncells++; }
 
  void AllocateLinks(vtkIdType n);
 
  void InsertCellReference(vtkIdType ptId, vtkIdType pos, vtkIdType cellId);
 
  Link* Array;                // pointer to data
  vtkIdType Size;             // allocated size of data
  vtkIdType MaxId;            // maximum index inserted thus far
  vtkIdType Extend;           // grow array by this point
  Link* Resize(vtkIdType sz); // function to resize data
 
  // Some information recorded at build time
  vtkIdType NumberOfPoints;
  vtkIdType NumberOfCells;
 
private:
  vtkCellLinks(const vtkCellLinks&) = delete;
  void operator=(const vtkCellLinks&) = delete;
};
 
//----------------------------------------------------------------------------
inline void vtkCellLinks::InsertCellReference(vtkIdType ptId, vtkIdType pos, vtkIdType cellId)
{
  this->Array[ptId].cells[pos] = cellId;
}
 
//----------------------------------------------------------------------------
inline void vtkCellLinks::DeletePoint(vtkIdType ptId)
{
  this->Array[ptId].ncells = 0;
  delete[] this->Array[ptId].cells;
  this->Array[ptId].cells = nullptr;
}
 
//----------------------------------------------------------------------------
inline void vtkCellLinks::InsertNextCellReference(vtkIdType ptId, vtkIdType cellId)
{
  this->Array[ptId].cells[this->Array[ptId].ncells++] = cellId;
}
 
//----------------------------------------------------------------------------
inline void vtkCellLinks::RemoveCellReference(vtkIdType cellId, vtkIdType ptId)
{
  vtkIdType* cells = this->Array[ptId].cells;
  vtkIdType ncells = this->Array[ptId].ncells;
 
  for (vtkIdType i = 0; i < ncells; i++)
  {
    if (cells[i] == cellId)
    {
      for (vtkIdType j = i; j < (ncells - 1); j++)
      {
        cells[j] = cells[j + 1];
      }
      this->Array[ptId].ncells--;
      break;
    }
  }
}
 
//----------------------------------------------------------------------------
inline void vtkCellLinks::AddCellReference(vtkIdType cellId, vtkIdType ptId)
{
  this->Array[ptId].cells[this->Array[ptId].ncells++] = cellId;
}
 
//----------------------------------------------------------------------------
inline void vtkCellLinks::ResizeCellList(vtkIdType ptId, int size)
{
  vtkIdType newSize = this->Array[ptId].ncells + size;
  vtkIdType* cells = new vtkIdType[newSize];
  memcpy(cells, this->Array[ptId].cells,
    static_cast<size_t>(this->Array[ptId].ncells) * sizeof(vtkIdType));
  delete[] this->Array[ptId].cells;
  this->Array[ptId].cells = cells;
}
 
#endif