vtkDataArray.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkDataArray_h
#define vtkDataArray_h
 
#include "vtkAbstractArray.h"
#include "vtkCommonCoreModule.h"          // For export macro
#include "vtkVTK_USE_SCALED_SOA_ARRAYS.h" // For #define of VTK_USE_SCALED_SOA_ARRAYS
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDoubleArray;
class vtkIdList;
class vtkInformationStringKey;
class vtkInformationDoubleVectorKey;
class vtkLookupTable;
class vtkPoints;
 
class VTKCOMMONCORE_EXPORT vtkDataArray : public vtkAbstractArray
{
public:
  vtkTypeMacro(vtkDataArray, vtkAbstractArray);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkDataArray* FastDownCast(vtkAbstractArray* source);
 
  int IsNumeric() const override { return 1; }
 
  int GetElementComponentSize() const override { return this->GetDataTypeSize(); }
 
  // Reimplemented virtuals (doc strings are inherited from superclass):
 
  void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) override;
  vtkIdType InsertNextTuple(vtkIdType srcTupleIdx, vtkAbstractArray* source) override;
  void InsertTuples(vtkIdList* dstIds, vtkIdList* srcIds, vtkAbstractArray* source) override;
  void InsertTuples(
    vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray* source) override;
  void InsertTuplesStartingAt(
    vtkIdType dstStart, vtkIdList* srcIds, vtkAbstractArray* source) override;
  void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) override;
  void GetTuples(vtkIdList* tupleIds, vtkAbstractArray* output) override;
  void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray* output) override;
  void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdList* ptIndices, vtkAbstractArray* source,
    double* weights) override;
  void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx1, vtkAbstractArray* source1,
    vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) override;
 
  virtual double* GetTuple(vtkIdType tupleIdx)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples()) = 0;
 
  virtual void GetTuple(vtkIdType tupleIdx, double* tuple)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples()) = 0;
 
 
  double GetTuple1(vtkIdType tupleIdx) VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
  double* GetTuple2(vtkIdType tupleIdx) VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
    VTK_SIZEHINT(2);
  double* GetTuple3(vtkIdType tupleIdx) VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
    VTK_SIZEHINT(3);
  double* GetTuple4(vtkIdType tupleIdx) VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
    VTK_SIZEHINT(4);
  double* GetTuple6(vtkIdType tupleIdx) VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
    VTK_SIZEHINT(6);
  double* GetTuple9(vtkIdType tupleIdx) VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
    VTK_SIZEHINT(9);
 
 
  virtual void SetTuple(vtkIdType tupleIdx, const float* tuple)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
  virtual void SetTuple(vtkIdType tupleIdx, const double* tuple)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
 
 
  void SetTuple1(vtkIdType tupleIdx, double value)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
  void SetTuple2(vtkIdType tupleIdx, double val0, double val1)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
  void SetTuple3(vtkIdType tupleIdx, double val0, double val1, double val2)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
  void SetTuple4(vtkIdType tupleIdx, double val0, double val1, double val2, double val3)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
  void SetTuple6(vtkIdType tupleIdx, double val0, double val1, double val2, double val3,
    double val4, double val5) VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
  void SetTuple9(vtkIdType tupleIdx, double val0, double val1, double val2, double val3,
    double val4, double val5, double val6, double val7, double val8)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples());
 
 
  virtual void InsertTuple(vtkIdType tupleIdx, const float* tuple) VTK_EXPECTS(0 <= tupleIdx) = 0;
  virtual void InsertTuple(vtkIdType tupleIdx, const double* tuple) VTK_EXPECTS(0 <= tupleIdx) = 0;
 
 
  void InsertTuple1(vtkIdType tupleIdx, double value) VTK_EXPECTS(0 <= tupleIdx);
  void InsertTuple2(vtkIdType tupleIdx, double val0, double val1) VTK_EXPECTS(0 <= tupleIdx);
  void InsertTuple3(vtkIdType tupleIdx, double val0, double val1, double val2)
    VTK_EXPECTS(0 <= tupleIdx);
  void InsertTuple4(vtkIdType tupleIdx, double val0, double val1, double val2, double val3)
    VTK_EXPECTS(0 <= tupleIdx);
  void InsertTuple6(vtkIdType tupleIdx, double val0, double val1, double val2, double val3,
    double val4, double val5) VTK_EXPECTS(0 <= tupleIdx);
  void InsertTuple9(vtkIdType tupleIdx, double val0, double val1, double val2, double val3,
    double val4, double val5, double val6, double val7, double val8) VTK_EXPECTS(0 <= tupleIdx);
 
 
  virtual vtkIdType InsertNextTuple(const float* tuple) = 0;
  virtual vtkIdType InsertNextTuple(const double* tuple) = 0;
 
 
  void InsertNextTuple1(double value);
  void InsertNextTuple2(double val0, double val1);
  void InsertNextTuple3(double val0, double val1, double val2);
  void InsertNextTuple4(double val0, double val1, double val2, double val3);
  void InsertNextTuple6(
    double val0, double val1, double val2, double val3, double val4, double val5);
  void InsertNextTuple9(double val0, double val1, double val2, double val3, double val4,
    double val5, double val6, double val7, double val8);
 
 
  virtual void RemoveTuple(vtkIdType tupleIdx)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples()) = 0;
  virtual void RemoveFirstTuple() { this->RemoveTuple(0); }
  virtual void RemoveLastTuple();
 
  virtual double GetComponent(vtkIdType tupleIdx, int compIdx) VTK_EXPECTS(0 <= tupleIdx &&
    tupleIdx < GetNumberOfTuples()) VTK_EXPECTS(0 <= compIdx && compIdx < GetNumberOfComponents());
 
  virtual void SetComponent(vtkIdType tupleIdx, int compIdx, double value)
    VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
      VTK_EXPECTS(0 <= compIdx && compIdx < GetNumberOfComponents());
 
  virtual void InsertComponent(vtkIdType tupleIdx, int compIdx, double value)
    VTK_EXPECTS(0 <= tupleIdx) VTK_EXPECTS(0 <= compIdx && compIdx < GetNumberOfComponents());
 
  virtual void GetData(
    vtkIdType tupleMin, vtkIdType tupleMax, int compMin, int compMax, vtkDoubleArray* data);
 
 
  void DeepCopy(vtkAbstractArray* aa) override;
  virtual void DeepCopy(vtkDataArray* da);
 
  virtual void ShallowCopy(vtkDataArray* other);
 
  virtual void FillComponent(int compIdx, double value)
    VTK_EXPECTS(0 <= compIdx && compIdx < GetNumberOfComponents());
 
  virtual void Fill(double value);
 
  virtual void CopyComponent(int dstComponent, vtkDataArray* src, int srcComponent);
 
  virtual void* WriteVoidPointer(vtkIdType valueIdx, vtkIdType numValues) = 0;
 
  unsigned long GetActualMemorySize() const override;
 
  void CreateDefaultLookupTable();
 
 
  void SetLookupTable(vtkLookupTable* lut);
  vtkGetObjectMacro(LookupTable, vtkLookupTable);
 
 
  void GetRange(double range[2], int comp) { this->ComputeRange(range, comp); }
  void GetRange(double range[2], int comp, const unsigned char* ghosts, unsigned char ghostsToSkip)
  {
    this->ComputeRange(range, comp, ghosts, ghostsToSkip);
  }
 
 
  double* GetRange(int comp) VTK_SIZEHINT(2)
  {
    this->GetRange(this->Range, comp);
    return this->Range;
  }
 
  double* GetRange() VTK_SIZEHINT(2) { return this->GetRange(0); }
 
  void GetRange(double range[2]) { this->GetRange(range, 0); }
 
 
  void GetFiniteRange(double range[2], int comp) { this->ComputeFiniteRange(range, comp); }
  void GetFiniteRange(
    double range[2], int comp, const unsigned char* ghosts, unsigned char ghostsToSkip)
  {
    this->ComputeFiniteRange(range, comp, ghosts, ghostsToSkip);
  }
 
 
  double* GetFiniteRange(int comp) VTK_SIZEHINT(2)
  {
    this->GetFiniteRange(this->FiniteRange, comp);
    return this->FiniteRange;
  }
 
  double* GetFiniteRange() VTK_SIZEHINT(2) { return this->GetFiniteRange(0); }
 
  void GetFiniteRange(double range[2]) { this->GetFiniteRange(range, 0); }
 
 
  void GetDataTypeRange(double range[2]);
  double GetDataTypeMin();
  double GetDataTypeMax();
  static void GetDataTypeRange(int type, double range[2]);
  static double GetDataTypeMin(int type);
  static double GetDataTypeMax(int type);
 
  virtual double GetMaxNorm();
 
  VTK_NEWINSTANCE
  static vtkDataArray* CreateDataArray(int dataType);
 
  static vtkInformationDoubleVectorKey* COMPONENT_RANGE();
 
  static vtkInformationDoubleVectorKey* L2_NORM_RANGE();
 
  static vtkInformationDoubleVectorKey* L2_NORM_FINITE_RANGE();
 
  void Modified() override;
 
  static vtkInformationStringKey* UNITS_LABEL();
 
  int CopyInformation(vtkInformation* infoFrom, vtkTypeBool deep = 1) override;
 
  int GetArrayType() const override { return DataArray; }
 
protected:
  friend class vtkPoints;
  friend class vtkFieldData;
 
 
  virtual void ComputeRange(double range[2], int comp);
  virtual void ComputeRange(
    double range[2], int comp, const unsigned char* ghosts, unsigned char ghostsToSkip = 0xff);
 
 
  virtual void ComputeFiniteRange(double range[2], int comp);
  virtual void ComputeFiniteRange(
    double range[2], int comp, const unsigned char* ghosts, unsigned char ghostsToSkip = 0xff);
 
 
  virtual bool ComputeScalarRange(double* ranges);
  virtual bool ComputeScalarRange(
    double* ranges, const unsigned char* ghosts, unsigned char ghostsToSkip = 0xff);
 
 
  virtual bool ComputeVectorRange(double range[2]);
  virtual bool ComputeVectorRange(
    double range[2], const unsigned char* ghosts, unsigned char ghostsToSkip = 0xff);
 
 
  virtual bool ComputeFiniteScalarRange(double* ranges);
  virtual bool ComputeFiniteScalarRange(
    double* ranges, const unsigned char* ghosts, unsigned char ghostsToSkip = 0xff);
 
 
  virtual bool ComputeFiniteVectorRange(double range[2]);
  virtual bool ComputeFiniteVectorRange(
    double range[2], const unsigned char* ghosts, unsigned char ghostsToSkip = 0xff);
 
  // Construct object with default tuple dimension (number of components) of 1.
  vtkDataArray();
  ~vtkDataArray() override;
 
  vtkLookupTable* LookupTable;
  double Range[2];
  double FiniteRange[2];
 
private:
  double* GetTupleN(vtkIdType i, int n);
 
  vtkDataArray(const vtkDataArray&) = delete;
  void operator=(const vtkDataArray&) = delete;
};
 
//------------------------------------------------------------------------------
inline vtkDataArray* vtkDataArray::FastDownCast(vtkAbstractArray* source)
{
  if (source)
  {
    switch (source->GetArrayType())
    {
      case AoSDataArrayTemplate:
      case SoADataArrayTemplate:
      case ImplicitArray:
      case TypedDataArray:
      case DataArray:
      case MappedDataArray:
        return static_cast<vtkDataArray*>(source);
      default:
        break;
    }
  }
  return nullptr;
}
 
vtkArrayDownCast_FastCastMacro(vtkDataArray);
VTK_ABI_NAMESPACE_END
 
// These are used by vtkDataArrayPrivate.txx, but need to be available to
// vtkGenericDataArray.h as well.
namespace vtkDataArrayPrivate
{
VTK_ABI_NAMESPACE_BEGIN
struct AllValues
{
};
struct FiniteValues
{
};
VTK_ABI_NAMESPACE_END
}
 
#endif