vtkDataSet.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkDataSet.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 vtkDataSet_h
#define vtkDataSet_h

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

class vtkCell;
class vtkCellData;
class vtkCellIterator;
class vtkCellTypes;
class vtkGenericCell;
class vtkIdList;
class vtkPointData;
class vtkUnsignedCharArray;
class vtkCallbackCommand;

class VTKCOMMONDATAMODEL_EXPORT vtkDataSet : public vtkDataObject
{
public:
  vtkTypeMacro(vtkDataSet,vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void CopyStructure(vtkDataSet *ds) = 0;

  virtual void CopyAttributes(vtkDataSet *ds);

  virtual vtkIdType GetNumberOfPoints() = 0;

  virtual vtkIdType GetNumberOfCells() = 0;

  virtual double *GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) = 0;

  virtual void GetPoint(vtkIdType id, double x[3]);

  VTK_NEWINSTANCE
  virtual vtkCellIterator* NewCellIterator();

  virtual vtkCell *GetCell(vtkIdType cellId) = 0;
  virtual vtkCell *GetCell(int vtkNotUsed(i), int vtkNotUsed(j), int vtkNotUsed(k))
  {
    vtkErrorMacro("ijk indices are only valid with structured data!");
    return nullptr;
  }

  virtual void GetCell(vtkIdType cellId, vtkGenericCell *cell) = 0;

  virtual void GetCellBounds(vtkIdType cellId, double bounds[6]);

  virtual int GetCellType(vtkIdType cellId) = 0;

  virtual void GetCellTypes(vtkCellTypes *types);

  virtual void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) = 0;

  virtual void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) = 0;

  virtual void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
                                vtkIdList *cellIds);


  vtkIdType FindPoint(double x, double y, double z)
  {
    double xyz[3];
    xyz[0] = x; xyz[1] = y; xyz[2] = z;
    return this->FindPoint (xyz);
  }
  virtual vtkIdType FindPoint(double x[3]) = 0;

  virtual vtkIdType FindCell(double x[3], vtkCell *cell, vtkIdType cellId,
                             double tol2, int& subId, double pcoords[3],
                             double *weights) = 0;

  virtual vtkIdType FindCell(double x[3], vtkCell *cell,
                             vtkGenericCell *gencell, vtkIdType cellId,
                             double tol2, int& subId, double pcoords[3],
                             double *weights) = 0;

  virtual vtkCell *FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId,
                                  double tol2, int& subId, double pcoords[3],
                                  double *weights);

  vtkMTimeType GetMTime() override;

  vtkCellData *GetCellData() {return this->CellData;};

  vtkPointData *GetPointData() {return this->PointData;};

  virtual void Squeeze();

  virtual void ComputeBounds();

  double *GetBounds() VTK_SIZEHINT(6);

  void GetBounds(double bounds[6]);

  double *GetCenter() VTK_SIZEHINT(3);

  void GetCenter(double center[3]);

  double GetLength();

  void Initialize() override;

  virtual void GetScalarRange(double range[2]);

  double *GetScalarRange() VTK_SIZEHINT(2);

  virtual int GetMaxCellSize() = 0;

  unsigned long GetActualMemorySize() override;

  int GetDataObjectType() override {return VTK_DATA_SET;}


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

  enum FieldDataType
  {
    DATA_OBJECT_FIELD=0,
    POINT_DATA_FIELD=1,
    CELL_DATA_FIELD=2
  };

  int CheckAttributes();


  virtual void GenerateGhostArray(int zeroExt[6])
  {
    this->GenerateGhostArray(zeroExt, false);
  }
  virtual void GenerateGhostArray(int zeroExt[6], bool cellOnly);


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

  vtkFieldData* GetAttributesAsFieldData(int type) override;

  vtkIdType GetNumberOfElements(int type) override;

  bool HasAnyGhostCells();
  bool HasAnyGhostPoints();
  virtual bool HasAnyBlankCells()
  {
    return 0;
  }
  virtual bool HasAnyBlankPoints()
  {
    return 0;
  }

  vtkUnsignedCharArray* GetPointGhostArray();
  void UpdatePointGhostArrayCache();

  vtkUnsignedCharArray* AllocatePointGhostArray();

  vtkUnsignedCharArray* GetCellGhostArray();
  void UpdateCellGhostArrayCache();

  vtkUnsignedCharArray* AllocateCellGhostArray();

protected:
  // Constructor with default bounds (0,1, 0,1, 0,1).
  vtkDataSet();
  ~vtkDataSet() override;

  virtual void ComputeScalarRange();

  bool IsAnyBitSet(vtkUnsignedCharArray *a, int bitFlag);

  vtkCellData *CellData;   // Scalars, vectors, etc. associated w/ each cell
  vtkPointData *PointData;   // Scalars, vectors, etc. associated w/ each point
  vtkCallbackCommand *DataObserver; // Observes changes to cell/point data
  vtkTimeStamp ComputeTime; // Time at which bounds, center, etc. computed
  double Bounds[6];  // (xmin,xmax, ymin,ymax, zmin,zmax) geometric bounds
  double Center[3];

  // Cached scalar range
  double ScalarRange[2];

  // Time at which scalar range is computed
  vtkTimeStamp ScalarRangeComputeTime;


  vtkUnsignedCharArray* PointGhostArray;
  vtkUnsignedCharArray* CellGhostArray;
  bool PointGhostArrayCached;
  bool CellGhostArrayCached;


private:
  void InternalDataSetCopy(vtkDataSet *src);
  static void OnDataModified(
    vtkObject* source, unsigned long eid, void* clientdata, void *calldata);

  friend class vtkImageAlgorithmToDataSetFriendship;

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

inline void vtkDataSet::GetPoint(vtkIdType id, double x[3])
{
  double *pt = this->GetPoint(id);
  x[0] = pt[0]; x[1] = pt[1]; x[2] = pt[2];
}

#endif