VTK  9.1.20220528
vtkAbstractArray.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkAbstractArray.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 //
67 #ifndef vtkAbstractArray_h
68 #define vtkAbstractArray_h
69 
70 #include "vtkCommonCoreModule.h" // For export macro
71 #include "vtkIdList.h" // For InsertTuples
72 #include "vtkObject.h"
73 #include "vtkVariant.h" // for variant arguments
74 
75 class vtkArrayIterator;
76 class vtkDataArray;
77 class vtkIdList;
78 class vtkIdTypeArray;
79 class vtkInformation;
84 class vtkVariantArray;
85 
86 class VTKCOMMONCORE_EXPORT vtkAbstractArray : public vtkObject
87 {
88 public:
89  vtkTypeMacro(vtkAbstractArray, vtkObject);
90  void PrintSelf(ostream& os, vtkIndent indent) override;
91 
100  virtual vtkTypeBool Allocate(vtkIdType numValues, vtkIdType ext = 1000) = 0;
101 
105  virtual void Initialize() = 0;
106 
111  virtual int GetDataType() const = 0;
112 
114 
119  virtual int GetDataTypeSize() const = 0;
120  static int GetDataTypeSize(int type);
122 
130  virtual int GetElementComponentSize() const = 0;
131 
133 
137  vtkSetClampMacro(NumberOfComponents, int, 1, VTK_INT_MAX);
138  int GetNumberOfComponents() const { return this->NumberOfComponents; }
140 
145 
151 
155  bool HasAComponentName() const;
156 
162 
170  virtual void SetNumberOfTuples(vtkIdType numTuples) = 0;
171 
178  virtual bool SetNumberOfValues(vtkIdType numValues);
179 
183  vtkIdType GetNumberOfTuples() const { return (this->MaxId + 1) / this->NumberOfComponents; }
184 
191  inline vtkIdType GetNumberOfValues() const { return (this->MaxId + 1); }
192 
199  virtual void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;
200 
206  virtual void InsertTuple(
207  vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;
208 
214  virtual void InsertTuples(vtkIdList* dstIds, vtkIdList* srcIds, vtkAbstractArray* source) = 0;
215 
222  vtkIdType dstStart, vtkIdList* srcIds, vtkAbstractArray* source) = 0;
223 
229  virtual void InsertTuples(
230  vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray* source) = 0;
231 
238 
244  virtual void GetTuples(vtkIdList* tupleIds, vtkAbstractArray* output);
245 
251  virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray* output);
252 
259  virtual bool HasStandardMemoryLayout() const;
260 
268  virtual void* GetVoidPointer(vtkIdType valueIdx) = 0;
269 
278  virtual void DeepCopy(vtkAbstractArray* da);
279 
287  virtual void InterpolateTuple(
288  vtkIdType dstTupleIdx, vtkIdList* ptIndices, vtkAbstractArray* source, double* weights) = 0;
289 
298  virtual void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx1,
299  vtkAbstractArray* source1, vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) = 0;
300 
306  virtual void Squeeze() = 0;
307 
317  virtual vtkTypeBool Resize(vtkIdType numTuples) = 0;
318 
320 
323  void Reset()
324  {
325  this->MaxId = -1;
326  this->DataChanged();
327  }
329 
333  vtkIdType GetSize() const { return this->Size; }
334 
338  vtkIdType GetMaxId() const { return this->MaxId; }
339 
341  {
345  VTK_DATA_ARRAY_USER_DEFINED
346  };
347 
349 
366  virtual void SetVoidArray(
367  void* vtkNotUsed(array), vtkIdType vtkNotUsed(size), int vtkNotUsed(save)) = 0;
368  virtual void SetVoidArray(void* array, vtkIdType size, int save, int vtkNotUsed(deleteMethod))
369  {
370  this->SetVoidArray(array, size, save);
371  }
373 
380  virtual void SetArrayFreeFunction(void (*callback)(void*)) = 0;
381 
387  virtual void ExportToVoidPointer(void* out_ptr);
388 
397  virtual unsigned long GetActualMemorySize() const = 0;
398 
400 
403  vtkSetStringMacro(Name);
404  vtkGetStringMacro(Name);
406 
410  virtual const char* GetDataTypeAsString(void) const
411  {
412  return vtkImageScalarTypeNameMacro(this->GetDataType());
413  }
414 
425  static vtkAbstractArray* CreateArray(int dataType);
426 
431  virtual int IsNumeric() const = 0;
432 
439 
446  virtual vtkIdType GetDataSize() const
447  {
448  return this->GetNumberOfComponents() * this->GetNumberOfTuples();
449  }
450 
452 
460  virtual void LookupValue(vtkVariant value, vtkIdList* valueIds) = 0;
462 
467  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues());
468 
474  VTK_EXPECTS(0 <= valueIdx) = 0;
475 
480  virtual void SetVariantValue(vtkIdType valueIdx, vtkVariant value)
481  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues()) = 0;
482 
491  virtual void DataChanged() = 0;
492 
498  virtual void ClearLookup() = 0;
499 
552  virtual void GetProminentComponentValues(int comp, vtkVariantArray* values,
553  double uncertainty = 1.e-6, double minimumProminence = 1.e-3);
554 
555  // TODO: Implement these lookup functions also.
556  // virtual void LookupRange(vtkVariant min, vtkVariant max, vtkIdList* ids,
557  // bool includeMin = true, bool includeMax = true) = 0;
558  // virtual void LookupGreaterThan(vtkVariant min, vtkIdList* ids, bool includeMin = false) = 0;
559  // virtual void LookupLessThan(vtkVariant max, vtkIdList* ids, bool includeMax = false) = 0;
560 
571  bool HasInformation() const { return this->Information != nullptr; }
572 
584  virtual int CopyInformation(vtkInformation* infoFrom, int deep = 1);
585 
591 
605 
619 
623  void Modified() override;
624 
631 
640 
641  // Deprecated. Use vtkAbstractArray::MaxDiscreteValues instead.
642  enum
643  {
644  MAX_DISCRETE_VALUES = 32
645  };
646 
648 
652  vtkGetMacro(MaxDiscreteValues, unsigned int);
653  vtkSetMacro(MaxDiscreteValues, unsigned int);
655 
656  enum
657  {
658  AbstractArray = 0,
665 
666  DataArrayTemplate = AoSDataArrayTemplate
667  };
668 
673  virtual int GetArrayType() const { return AbstractArray; }
674 
678  const char* GetArrayTypeAsString() const;
679 
680 protected:
681  // Construct object with default tuple dimension (number of components) of 1.
683  ~vtkAbstractArray() override;
684 
691 
703  virtual void UpdateDiscreteValueSet(double uncertainty, double minProminence);
704 
705  vtkIdType Size; // allocated size of data
706  vtkIdType MaxId; // maximum index inserted thus far
707  int NumberOfComponents; // the number of components per tuple
708 
709  // maximum number of prominent values before array is considered continuous.
710  unsigned int MaxDiscreteValues;
711 
712  char* Name;
713 
714  bool RebuildArray; // whether to rebuild the fast lookup data structure.
715 
717 
718  class vtkInternalComponentNames;
719  vtkInternalComponentNames* ComponentNames; // names for each component
720 
721 private:
722  vtkAbstractArray(const vtkAbstractArray&) = delete;
723  void operator=(const vtkAbstractArray&) = delete;
724 };
725 
727 
732 template <typename ArrayT>
734 {
735  inline ArrayT* operator()(vtkAbstractArray* array) { return ArrayT::SafeDownCast(array); }
736 };
738 
756 template <typename ArrayT>
758 {
759  // The default vtkArrayDownCast_impl struct uses SafeDownCast, but is
760  // specialized for arrays that support FastDownCast.
761  return vtkArrayDownCast_impl<ArrayT>()(array);
762 }
763 
765 
769 #define vtkArrayDownCast_FastCastMacro(ArrayT) \
770  template <> \
771  struct vtkArrayDownCast_impl<ArrayT> \
772  { \
773  inline ArrayT* operator()(vtkAbstractArray* array) { return ArrayT::FastDownCast(array); } \
774  }
776 
778 
784 #define vtkArrayDownCast_TemplateFastCastMacro(ArrayT) \
785  template <typename ValueT> \
786  struct vtkArrayDownCast_impl<ArrayT<ValueT>> \
787  { \
788  inline ArrayT<ValueT>* operator()(vtkAbstractArray* array) \
789  { \
790  return ArrayT<ValueT>::FastDownCast(array); \
791  } \
792  }
794 
795 #endif
Abstract superclass for all arrays.
static vtkInformationInformationVectorKey * PER_COMPONENT()
This key is used to hold a vector of COMPONENT_VALUES (and, for vtkDataArray subclasses,...
virtual void GetTuples(vtkIdList *tupleIds, vtkAbstractArray *output)
Given a list of tuple ids, return an array of tuples.
bool HasInformation() const
Inquire if this array has an instance of vtkInformation already associated with it.
virtual int IsNumeric() const =0
This method is here to make backward compatibility easier.
virtual vtkArrayIterator * NewIterator()=0
Subclasses must override this method and provide the right kind of templated vtkArrayIteratorTemplate...
virtual void Initialize()=0
Release storage and reset array to initial state.
virtual void DeepCopy(vtkAbstractArray *da)
Deep copy of data.
virtual int GetElementComponentSize() const =0
Return the size, in bytes, of the lowest-level element of an array.
virtual void SetInformation(vtkInformation *)
Set an information object that can be used to annotate the array.
virtual void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx1, vtkAbstractArray *source1, vtkIdType srcTupleIdx2, vtkAbstractArray *source2, double t)=0
Insert the tuple at dstTupleIdx in this array to the tuple interpolated from the two tuple indices,...
virtual void UpdateDiscreteValueSet(double uncertainty, double minProminence)
Obtain the set of unique values taken on by each component of the array, as well as by the tuples of ...
virtual vtkTypeBool Allocate(vtkIdType numValues, vtkIdType ext=1000)=0
Allocate memory for this array.
static vtkInformationDoubleVectorKey * DISCRETE_VALUE_SAMPLE_PARAMETERS()
A key used to hold conditions under which cached discrete values were generated; the value is a 2-vec...
virtual unsigned long GetActualMemorySize() const =0
Return the memory in kibibytes (1024 bytes) consumed by this data array.
int GetNumberOfComponents() const
Set/Get the dimension (n) of the components.
vtkIdType GetSize() const
Return the size of the data.
static vtkInformationInformationVectorKey * PER_FINITE_COMPONENT()
This key is used to hold a vector of COMPONENT_VALUES (and, for vtkDataArray subclasses,...
unsigned int MaxDiscreteValues
vtkInternalComponentNames * ComponentNames
static int GetDataTypeSize(int type)
Return the size of the underlying data type.
virtual void SetVoidArray(void *vtkNotUsed(array), vtkIdType vtkNotUsed(size), int vtkNotUsed(save))=0
This method lets the user specify data to be held by the array.
void SetComponentName(vtkIdType component, const char *name)
Set the name for a component.
virtual vtkTypeBool Resize(vtkIdType numTuples)=0
Resize the array to the requested number of tuples and preserve data.
static vtkAbstractArray * CreateArray(int dataType)
Creates an array for dataType where dataType is one of VTK_BIT, VTK_CHAR, VTK_UNSIGNED_CHAR,...
virtual vtkIdType GetDataSize() const
Returns the size of the data in DataTypeSize units.
virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
Retrieve value from the array as a variant.
vtkIdType GetMaxId() const
What is the maximum id currently in the array.
virtual void SetNumberOfTuples(vtkIdType numTuples)=0
Set the number of tuples (a component group) in the array.
vtkIdType GetNumberOfTuples() const
Get the number of complete tuples (a component group) in the array.
virtual void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray *source)=0
Set the tuple at dstTupleIdx in this array to the tuple at srcTupleIdx in the source array.
virtual void ClearLookup()=0
Delete the associated fast lookup data structure on this array, if it exists.
virtual int GetDataTypeSize() const =0
Return the size of the underlying data type.
virtual void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds, vtkAbstractArray *source)=0
Copy the tuples indexed in srcIds from the source array to the tuple locations indexed by dstIds in t...
virtual void InsertTuplesStartingAt(vtkIdType dstStart, vtkIdList *srcIds, vtkAbstractArray *source)=0
Copy the tuples indexed in srcIds from the source array to the tuple locations starting at index dstS...
virtual int CopyInformation(vtkInformation *infoFrom, int deep=1)
Copy information instance.
virtual void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdList *ptIndices, vtkAbstractArray *source, double *weights)=0
Set the tuple at dstTupleIdx in this array to the interpolated tuple value, given the ptIndices in th...
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
const char * GetComponentName(vtkIdType component) const
Get the component name for a given component.
vtkInformation * Information
const char * GetArrayTypeAsString() const
Get the name for the array type as string.
void Reset()
Reset to an empty state, without freeing any memory.
virtual void SetArrayFreeFunction(void(*callback)(void *))=0
This method allows the user to specify a custom free function to be called when the array is dealloca...
vtkInformation * GetInformation()
Get an information object that can be used to annotate the array.
int CopyComponentNames(vtkAbstractArray *da)
Copies the component names from the inputed array to the current array make sure that the current arr...
void Modified() override
Removes out-of-date PER_COMPONENT() and PER_FINITE_COMPONENT() values.
virtual void ExportToVoidPointer(void *out_ptr)
This method copies the array data to the void pointer specified by the user.
virtual bool SetNumberOfValues(vtkIdType numValues)
Specify the number of values (tuples * components) for this object to hold.
virtual void InsertTuples(vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray *source)=0
Copy n consecutive tuples starting at srcStart from the source array to this array,...
virtual void SetVariantValue(vtkIdType valueIdx, vtkVariant value)=0
Set a value in the array from a variant.
virtual const char * GetDataTypeAsString(void) const
Get the name of a data type as a string.
virtual void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray *source)=0
Insert the tuple at srcTupleIdx in the source array into this array at dstTupleIdx.
virtual bool HasStandardMemoryLayout() const
Returns true if this array uses the standard memory layout defined in the VTK user guide,...
vtkIdType GetNumberOfValues() const
Get the total number of values in the array.
bool HasAComponentName() const
Returns if any component has had a name assigned.
static vtkInformationVariantVectorKey * DISCRETE_VALUES()
A key used to hold discrete values taken on either by the tuples of the array (when present in this->...
virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray *output)
Get the tuples for the range of tuple ids specified (i.e., p1->p2 inclusive).
static vtkInformationIntegerKey * GUI_HIDE()
This key is a hint to end user interface that this array is internal and should not be shown to the e...
virtual int GetArrayType() const
Method for type-checking in FastDownCast implementations.
virtual vtkIdType LookupValue(vtkVariant value)=0
Return the value indices where a specific value appears.
virtual int GetDataType() const =0
Return the underlying data type.
~vtkAbstractArray() override
virtual void SetVoidArray(void *array, vtkIdType size, int save, int vtkNotUsed(deleteMethod))
This method lets the user specify data to be held by the array.
virtual void LookupValue(vtkVariant value, vtkIdList *valueIds)=0
Return the value indices where a specific value appears.
virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)=0
Insert a value into the array from a variant.
virtual vtkIdType InsertNextTuple(vtkIdType srcTupleIdx, vtkAbstractArray *source)=0
Insert the tuple from srcTupleIdx in the source array at the end of this array.
virtual void Squeeze()=0
Free any unnecessary memory.
virtual void GetProminentComponentValues(int comp, vtkVariantArray *values, double uncertainty=1.e-6, double minimumProminence=1.e-3)
Populate the given vtkVariantArray with a set of distinct values taken on by the requested component ...
virtual void DataChanged()=0
Tell the array explicitly that the data has changed.
virtual void * GetVoidPointer(vtkIdType valueIdx)=0
Return a void pointer.
Abstract superclass to iterate over elements in an vtkAbstractArray.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:165
list of point or cell ids
Definition: vtkIdList.h:143
dynamic, self-adjusting array of vtkIdType
a simple class to control print indentation
Definition: vtkIndent.h:119
Key for integer values in vtkInformation.
Store vtkAlgorithm input/output information.
abstract base class for most VTK objects
Definition: vtkObject.h:82
An array holding vtkVariants.
A atomic type representing the union of many types.
Definition: vtkVariant.h:159
@ component
Definition: vtkX3D.h:181
@ value
Definition: vtkX3D.h:226
@ type
Definition: vtkX3D.h:522
@ name
Definition: vtkX3D.h:225
@ size
Definition: vtkX3D.h:259
Implementation of vtkArrayDownCast.
ArrayT * operator()(vtkAbstractArray *array)
int vtkTypeBool
Definition: vtkABI.h:69
ArrayT * vtkArrayDownCast(vtkAbstractArray *array)
vtkArrayDownCast is to be used by generic (e.g.
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
int vtkIdType
Definition: vtkType.h:332
#define VTK_INT_MAX
Definition: vtkType.h:155
void save(Archiver &ar, const std::string &str, const unsigned int vtkNotUsed(version))
#define VTK_EXPECTS(x)
#define VTK_NEWINSTANCE