VTK  9.0.3
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 //
57 #ifndef vtkAbstractArray_h
58 #define vtkAbstractArray_h
59 
60 #include "vtkCommonCoreModule.h" // For export macro
61 #include "vtkObject.h"
62 #include "vtkVariant.h" // for variant arguments
63 
64 class vtkArrayIterator;
65 class vtkDataArray;
66 class vtkIdList;
67 class vtkIdTypeArray;
68 class vtkInformation;
73 class vtkVariantArray;
74 
75 class VTKCOMMONCORE_EXPORT vtkAbstractArray : public vtkObject
76 {
77 public:
78  vtkTypeMacro(vtkAbstractArray, vtkObject);
79  void PrintSelf(ostream& os, vtkIndent indent) override;
80 
89  virtual vtkTypeBool Allocate(vtkIdType numValues, vtkIdType ext = 1000) = 0;
90 
94  virtual void Initialize() = 0;
95 
100  virtual int GetDataType() const = 0;
101 
103 
108  virtual int GetDataTypeSize() const = 0;
109  static int GetDataTypeSize(int type);
111 
119  virtual int GetElementComponentSize() const = 0;
120 
122 
126  vtkSetClampMacro(NumberOfComponents, int, 1, VTK_INT_MAX);
127  int GetNumberOfComponents() const { return this->NumberOfComponents; }
129 
134 
140 
144  bool HasAComponentName() const;
145 
151 
159  virtual void SetNumberOfTuples(vtkIdType numTuples) = 0;
160 
167  virtual bool SetNumberOfValues(vtkIdType numValues);
168 
172  vtkIdType GetNumberOfTuples() const { return (this->MaxId + 1) / this->NumberOfComponents; }
173 
180  inline vtkIdType GetNumberOfValues() const { return (this->MaxId + 1); }
181 
188  virtual void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;
189 
195  virtual void InsertTuple(
196  vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;
197 
203  virtual void InsertTuples(vtkIdList* dstIds, vtkIdList* srcIds, vtkAbstractArray* source) = 0;
204 
210  virtual void InsertTuples(
211  vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray* source) = 0;
212 
219 
225  virtual void GetTuples(vtkIdList* tupleIds, vtkAbstractArray* output);
226 
232  virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray* output);
233 
240  virtual bool HasStandardMemoryLayout() const;
241 
249  virtual void* GetVoidPointer(vtkIdType valueIdx) = 0;
250 
259  virtual void DeepCopy(vtkAbstractArray* da);
260 
268  virtual void InterpolateTuple(
269  vtkIdType dstTupleIdx, vtkIdList* ptIndices, vtkAbstractArray* source, double* weights) = 0;
270 
279  virtual void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx1,
280  vtkAbstractArray* source1, vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) = 0;
281 
287  virtual void Squeeze() = 0;
288 
298  virtual vtkTypeBool Resize(vtkIdType numTuples) = 0;
299 
301 
304  void Reset()
305  {
306  this->MaxId = -1;
307  this->DataChanged();
308  }
310 
314  vtkIdType GetSize() const { return this->Size; }
315 
319  vtkIdType GetMaxId() const { return this->MaxId; }
320 
322  {
326  VTK_DATA_ARRAY_USER_DEFINED
327  };
328 
330 
347  virtual void SetVoidArray(
348  void* vtkNotUsed(array), vtkIdType vtkNotUsed(size), int vtkNotUsed(save)) = 0;
349  virtual void SetVoidArray(void* array, vtkIdType size, int save, int vtkNotUsed(deleteMethod))
350  {
351  this->SetVoidArray(array, size, save);
352  }
354 
361  virtual void SetArrayFreeFunction(void (*callback)(void*)) = 0;
362 
368  virtual void ExportToVoidPointer(void* out_ptr);
369 
378  virtual unsigned long GetActualMemorySize() const = 0;
379 
381 
384  vtkSetStringMacro(Name);
385  vtkGetStringMacro(Name);
387 
391  virtual const char* GetDataTypeAsString(void) const
392  {
393  return vtkImageScalarTypeNameMacro(this->GetDataType());
394  }
395 
406  static vtkAbstractArray* CreateArray(int dataType);
407 
412  virtual int IsNumeric() const = 0;
413 
420 
427  virtual vtkIdType GetDataSize() const
428  {
429  return this->GetNumberOfComponents() * this->GetNumberOfTuples();
430  }
431 
433 
437  virtual void LookupValue(vtkVariant value, vtkIdList* valueIds) = 0;
439 
444  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues());
445 
451  VTK_EXPECTS(0 <= valueIdx) = 0;
452 
457  virtual void SetVariantValue(vtkIdType valueIdx, vtkVariant value)
458  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues()) = 0;
459 
468  virtual void DataChanged() = 0;
469 
475  virtual void ClearLookup() = 0;
476 
529  virtual void GetProminentComponentValues(int comp, vtkVariantArray* values,
530  double uncertainty = 1.e-6, double minimumProminence = 1.e-3);
531 
532  // TODO: Implement these lookup functions also.
533  // virtual void LookupRange(vtkVariant min, vtkVariant max, vtkIdList* ids,
534  // bool includeMin = true, bool includeMax = true) = 0;
535  // virtual void LookupGreaterThan(vtkVariant min, vtkIdList* ids, bool includeMin = false) = 0;
536  // virtual void LookupLessThan(vtkVariant max, vtkIdList* ids, bool includeMax = false) = 0;
537 
548  bool HasInformation() const { return this->Information != nullptr; }
549 
561  virtual int CopyInformation(vtkInformation* infoFrom, int deep = 1);
562 
568 
582 
596 
600  void Modified() override;
601 
608 
617 
618  // Deprecated. Use vtkAbstractArray::MaxDiscreteValues instead.
619  enum
620  {
621  MAX_DISCRETE_VALUES = 32
622  };
623 
625 
629  vtkGetMacro(MaxDiscreteValues, unsigned int);
630  vtkSetMacro(MaxDiscreteValues, unsigned int);
632 
633  enum
634  {
635  AbstractArray = 0,
642 
643  DataArrayTemplate = AoSDataArrayTemplate
644  };
645 
650  virtual int GetArrayType() const { return AbstractArray; }
651 
652 protected:
653  // Construct object with default tuple dimension (number of components) of 1.
655  ~vtkAbstractArray() override;
656 
663 
675  virtual void UpdateDiscreteValueSet(double uncertainty, double minProminence);
676 
677  vtkIdType Size; // allocated size of data
678  vtkIdType MaxId; // maximum index inserted thus far
679  int NumberOfComponents; // the number of components per tuple
680 
681  // maximum number of prominent values before array is considered continuous.
682  unsigned int MaxDiscreteValues;
683 
684  char* Name;
685 
686  bool RebuildArray; // whether to rebuild the fast lookup data structure.
687 
689 
690  class vtkInternalComponentNames;
691  vtkInternalComponentNames* ComponentNames; // names for each component
692 
693 private:
694  vtkAbstractArray(const vtkAbstractArray&) = delete;
695  void operator=(const vtkAbstractArray&) = delete;
696 };
697 
699 
704 template <typename ArrayT>
706 {
707  inline ArrayT* operator()(vtkAbstractArray* array) { return ArrayT::SafeDownCast(array); }
708 };
710 
728 template <typename ArrayT>
730 {
731  // The default vtkArrayDownCast_impl struct uses SafeDownCast, but is
732  // specialized for arrays that support FastDownCast.
733  return vtkArrayDownCast_impl<ArrayT>()(array);
734 }
735 
737 
741 #define vtkArrayDownCast_FastCastMacro(ArrayT) \
742  template <> \
743  struct vtkArrayDownCast_impl<ArrayT> \
744  { \
745  inline ArrayT* operator()(vtkAbstractArray* array) { return ArrayT::FastDownCast(array); } \
746  }
748 
750 
756 #define vtkArrayDownCast_TemplateFastCastMacro(ArrayT) \
757  template <typename ValueT> \
758  struct vtkArrayDownCast_impl<ArrayT<ValueT> > \
759  { \
760  inline ArrayT<ValueT>* operator()(vtkAbstractArray* array) \
761  { \
762  return ArrayT<ValueT>::FastDownCast(array); \
763  } \
764  }
766 
767 #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
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)
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 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
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))
virtual void LookupValue(vtkVariant value, vtkIdList *valueIds)=0
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:50
list of point or cell ids
Definition: vtkIdList.h:31
dynamic, self-adjusting array of vtkIdType
a simple class to control print indentation
Definition: vtkIndent.h:34
Key for integer values in vtkInformation.
Store vtkAlgorithm input/output information.
abstract base class for most VTK objects
Definition: vtkObject.h:63
An array holding vtkVariants.
A atomic type representing the union of many types.
Definition: vtkVariant.h:66
@ 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:338
#define VTK_INT_MAX
Definition: vtkType.h:155
void save(Archiver &ar, const vtkUnicodeString &str, const unsigned int vtkNotUsed(version))
#define VTK_EXPECTS(x)
#define VTK_NEWINSTANCE