vtkAbstractArray.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 vtkAbstractArray_h
#define vtkAbstractArray_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkObject.h"
#include "vtkVariant.h"       // for variant arguments
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkArrayIterator;
class vtkDataArray;
class vtkIdList;
class vtkIdTypeArray;
class vtkInformation;
class vtkInformationDoubleVectorKey;
class vtkInformationIntegerKey;
class vtkInformationInformationVectorKey;
class vtkInformationVariantVectorKey;
class vtkVariantArray;
 
class VTKCOMMONCORE_EXPORT VTK_MARSHALAUTO vtkAbstractArray : public vtkObject
{
public:
  vtkTypeMacro(vtkAbstractArray, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  using ArrayTypeTag = std::integral_constant<int, vtkArrayTypes::VTK_ABSTRACT_ARRAY>;
  using DataTypeTag = std::integral_constant<int, VTK_OPAQUE>;

  void PrintValues(ostream& os);

  VTK_DEPRECATED_IN_9_7_0("Use ReserveValues/Tuples() to allocate or Initialize() to deallocate.")
  virtual vtkTypeBool Allocate(vtkIdType numValues, vtkIdType ext = 1000);

  virtual vtkTypeBool ReserveTuples(vtkIdType numTuples) = 0;

  vtkTypeBool ReserveValues(vtkIdType numValues);

  virtual void Initialize();

  virtual int GetDataType() const { return vtkAbstractArray::DataTypeTag::value; };


  virtual int GetDataTypeSize() const = 0;
  static int GetDataTypeSize(int type);

  virtual int GetElementComponentSize() const = 0;


  vtkSetClampMacro(NumberOfComponents, int, 1, VTK_INT_MAX);
  int GetNumberOfComponents() const { return this->NumberOfComponents; }

  void SetComponentName(vtkIdType component, const char* name);

  const char* GetComponentName(vtkIdType component) const;

  bool HasAComponentName() const;

  int CopyComponentNames(vtkAbstractArray* da);

  virtual bool CopyComponent(int dstComponent, vtkAbstractArray* src, int srcComponent) = 0;

  virtual void SetNumberOfTuples(vtkIdType numTuples)
  {
    this->SetNumberOfValues(this->NumberOfComponents * numTuples);
  }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  virtual bool SetNumberOfValues(vtkIdType numValues);

  vtkIdType GetNumberOfTuples() const { return (this->MaxId + 1) / this->NumberOfComponents; }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkIdType GetNumberOfValues() const { return (this->MaxId + 1); }

  virtual void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;

  virtual void InsertTuple(
    vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;

  virtual void InsertTuples(vtkIdList* dstIds, vtkIdList* srcIds, vtkAbstractArray* source) = 0;

  virtual void InsertTuplesStartingAt(
    vtkIdType dstStart, vtkIdList* srcIds, vtkAbstractArray* source) = 0;

  virtual void InsertTuples(
    vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray* source) = 0;

  virtual vtkIdType InsertNextTuple(vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;

  virtual void GetTuples(vtkIdList* tupleIds, vtkAbstractArray* output);

  virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray* output);

  virtual bool HasStandardMemoryLayout() const;

  virtual void* GetVoidPointer(vtkIdType valueIdx) = 0;

  virtual void DeepCopy(vtkAbstractArray* da);

  virtual void ShallowCopy(vtkAbstractArray* src);

  virtual void InterpolateTuple(
    vtkIdType dstTupleIdx, vtkIdList* ptIndices, vtkAbstractArray* source, double* weights) = 0;

  virtual void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx1,
    vtkAbstractArray* source1, vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) = 0;

  virtual void Squeeze() = 0;

  VTK_DEPRECATED_IN_9_7_0("Use ReserveTuples, Squeeze or Initialize")
  virtual vtkTypeBool Resize(vtkIdType numTuples);


  void Reset()
  {
    this->MaxId = -1;
    this->DataChanged();
  }


  vtkIdType GetCapacity() const { return this->Capacity; }

  vtkIdType GetMaxId() const { return this->MaxId; }
 
  enum DeleteMethod
  {
    VTK_DATA_ARRAY_FREE,
    VTK_DATA_ARRAY_DELETE,
    VTK_DATA_ARRAY_ALIGNED_FREE,
    VTK_DATA_ARRAY_USER_DEFINED
  };


  virtual void SetVoidArray(
    void* vtkNotUsed(array), vtkIdType vtkNotUsed(size), int vtkNotUsed(save)) = 0;
  virtual void SetVoidArray(void* array, vtkIdType size, int save, int vtkNotUsed(deleteMethod))
  {
    this->SetVoidArray(array, size, save);
  }


  virtual void SetArrayFreeFunction(void (*callback)(void*)) = 0;

  VTK_DEPRECATED_IN_9_7_0("Use DeepCopy with an vtkAOSDataArrayTemplate array")
  virtual void ExportToVoidPointer(void* out_ptr);

  virtual unsigned long GetActualMemorySize() const = 0;


  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);

  virtual const char* GetDataTypeAsString() const
  {
    return vtkImageScalarTypeNameMacro(this->GetDataType());
  }

  VTK_NEWINSTANCE
  static vtkAbstractArray* CreateArray(int dataType);

  virtual int IsNumeric() const = 0;

  virtual bool IsIntegral() const;

  VTK_DEPRECATED_IN_9_7_0("Use vtk::DataArrayValueRange, or the array directly")
  VTK_NEWINSTANCE virtual vtkArrayIterator* NewIterator() = 0;

  virtual vtkIdType GetDataSize() const
  {
    return this->GetNumberOfComponents() * this->GetNumberOfTuples();
  }


  virtual vtkIdType LookupValue(vtkVariant value) = 0;
  virtual void LookupValue(vtkVariant value, vtkIdList* valueIds) = 0;

  virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
    VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues());

  virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)
    VTK_EXPECTS(0 <= valueIdx) = 0;

  virtual void SetVariantValue(vtkIdType valueIdx, vtkVariant value)
    VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues()) = 0;

  virtual void DataChanged() = 0;

  virtual void ClearLookup() = 0;

  virtual void GetProminentComponentValues(int comp, vtkVariantArray* values,
    double uncertainty = 1.e-6, double minimumProminence = 1.e-3);
 
  // TODO: Implement these lookup functions also.
  // virtual void LookupRange(vtkVariant min, vtkVariant max, vtkIdList* ids,
  //  bool includeMin = true, bool includeMax = true) = 0;
  // virtual void LookupGreaterThan(vtkVariant min, vtkIdList* ids, bool includeMin = false) = 0;
  // virtual void LookupLessThan(vtkVariant max, vtkIdList* ids, bool includeMax = false) = 0;

  vtkInformation* GetInformation();
  bool HasInformation() const { return this->Information != nullptr; }

  virtual int CopyInformation(vtkInformation* infoFrom, vtkTypeBool deep = 1);

  static vtkInformationIntegerKey* GUI_HIDE();

  static vtkInformationInformationVectorKey* PER_COMPONENT();

  static vtkInformationInformationVectorKey* PER_FINITE_COMPONENT();

  void Modified() override;

  static vtkInformationVariantVectorKey* DISCRETE_VALUES();

  static vtkInformationDoubleVectorKey* DISCRETE_VALUE_SAMPLE_PARAMETERS();
 
  enum
  {
    MAX_DISCRETE_VALUES = 32
  };


  vtkGetMacro(MaxDiscreteValues, unsigned int);
  vtkSetMacro(MaxDiscreteValues, unsigned int);

  virtual int GetArrayType() const { return vtkAbstractArray::ArrayTypeTag::value; }


  static const char* GetArrayTypeAsString(int arrayType);
  const char* GetArrayTypeAsString() const
  {
    return vtkAbstractArray::GetArrayTypeAsString(this->GetArrayType());
  }


  VTK_DEPRECATED_IN_9_7_0("Use GetCapacity() instead")
  vtkIdType GetSize() const { return this->GetCapacity(); }
 
protected:
  // Construct object with default tuple dimension (number of components) of 1.
  vtkAbstractArray();
  ~vtkAbstractArray() override;

  virtual void SetInformation(vtkInformation*);

  virtual void UpdateDiscreteValueSet(double uncertainty, double minProminence);
 
  vtkIdType& Size VTK_DEPRECATED_IN_9_7_0("Use Capacity instead");
 
  vtkIdType Capacity;     // allocated capacity of the array
  vtkIdType MaxId;        // maximum index inserted thus far
  int NumberOfComponents; // the number of components per tuple
 
  // maximum number of prominent values before array is considered continuous.
  unsigned int MaxDiscreteValues;
 
  char* Name;
 
  bool RebuildArray; // whether to rebuild the fast lookup data structure.
 
  vtkInformation* Information;
 
  class vtkInternalComponentNames;
  vtkInternalComponentNames* ComponentNames; // names for each component
 
private:
  vtkAbstractArray(const vtkAbstractArray&) = delete;
  void operator=(const vtkAbstractArray&) = delete;
};


template <typename ArrayT>
struct vtkArrayDownCast_impl
{
  ArrayT* operator()(vtkAbstractArray* array) { return ArrayT::SafeDownCast(array); }
};


template <typename ArrayT>
ArrayT* vtkArrayDownCast(vtkAbstractArray* array)
{
  // The default vtkArrayDownCast_impl struct uses SafeDownCast, but is
  // specialized for arrays that support FastDownCast.
  return vtkArrayDownCast_impl<ArrayT>()(array);
}
 
VTK_ABI_NAMESPACE_END


#define vtkArrayDownCast_FastCastMacro(ArrayT)                                                     \
  template <>                                                                                      \
  struct vtkArrayDownCast_impl<ArrayT>                                                             \
  {                                                                                                \
    inline ArrayT* operator()(vtkAbstractArray* array)                                             \
    {                                                                                              \
      return ArrayT::FastDownCast(array);                                                          \
    }                                                                                              \
  }



#define vtkArrayDownCast_TemplateFastCastMacro(ArrayT)                                             \
  template <typename ValueT>                                                                       \
  struct vtkArrayDownCast_impl<ArrayT<ValueT>>                                                     \
  {                                                                                                \
    inline ArrayT<ValueT>* operator()(vtkAbstractArray* array)                                     \
    {                                                                                              \
      return ArrayT<ValueT>::FastDownCast(array);                                                  \
    }                                                                                              \
  }



#define vtkArrayDownCast_Template2FastCastMacro(ArrayT)                                            \
  template <typename ValueT, int ArrayType>                                                        \
  struct vtkArrayDownCast_impl<ArrayT<ValueT, ArrayType>>                                          \
  {                                                                                                \
    inline ArrayT<ValueT, ArrayType>* operator()(vtkAbstractArray* array)                          \
    {                                                                                              \
      return ArrayT<ValueT, ArrayType>::FastDownCast(array);                                       \
    }                                                                                              \
  }

#endif