VTK  9.0.1
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 
133  void SetComponentName(vtkIdType component, const char* name);
134 
139  const char* GetComponentName(vtkIdType component) const;
140 
144  bool HasAComponentName() const;
145 
150  int CopyComponentNames(vtkAbstractArray* da);
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 
218  virtual vtkIdType InsertNextTuple(vtkIdType srcTupleIdx, vtkAbstractArray* source) = 0;
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 
419  virtual vtkArrayIterator* NewIterator() = 0;
420 
427  virtual vtkIdType GetDataSize() const
428  {
429  return this->GetNumberOfComponents() * this->GetNumberOfTuples();
430  }
431 
433 
436  virtual vtkIdType LookupValue(vtkVariant value) = 0;
437  virtual void LookupValue(vtkVariant value, vtkIdList* valueIds) = 0;
439 
443  virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
444  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues());
445 
450  virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)
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 
543  vtkInformation* GetInformation();
548  bool HasInformation() const { return this->Information != nullptr; }
549 
561  virtual int CopyInformation(vtkInformation* infoFrom, int deep = 1);
562 
567  static vtkInformationIntegerKey* GUI_HIDE();
568 
581  static vtkInformationInformationVectorKey* PER_COMPONENT();
582 
595  static vtkInformationInformationVectorKey* PER_FINITE_COMPONENT();
596 
600  void Modified() override;
601 
607  static vtkInformationVariantVectorKey* DISCRETE_VALUES();
608 
616  static vtkInformationDoubleVectorKey* DISCRETE_VALUE_SAMPLE_PARAMETERS();
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 
662  virtual void SetInformation(vtkInformation*);
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  }
747 
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  }
765 
766 
767 #endif
abstract base class for most VTK objects
Definition: vtkObject.h:62
vtkIdType GetNumberOfValues() const
Get the total number of values in the array.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual const char * GetDataTypeAsString(void) const
Get the name of a data type as a string.
vtkIdType GetNumberOfTuples() const
Get the number of complete tuples (a component group) in the array.
An array holding vtkVariants.
Store vtkAlgorithm input/output information.
int GetNumberOfComponents() const
Set/Get the dimension (n) of the components.
Abstract superclass for all arrays.
Implementation of vtkArrayDownCast.
#define VTK_INT_MAX
Definition: vtkType.h:155
dynamic, self-adjusting array of vtkIdType
int vtkIdType
Definition: vtkType.h:338
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph *>::edge_descriptor e, vtkGraph *)
vtkIdType GetMaxId() const
What is the maximum id currently in the array.
A atomic type representing the union of many types.
Definition: vtkVariant.h:65
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.
vtkInformation * Information
int vtkTypeBool
Definition: vtkABI.h:69
Key for double vector values.
a simple class to control print indentation
Definition: vtkIndent.h:33
list of point or cell ids
Definition: vtkIdList.h:30
Key for integer values in vtkInformation.
ArrayT * operator()(vtkAbstractArray *array)
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkIdType GetSize() const
Return the size of the data.
virtual void Modified()
Update the modification time for this object.
Abstract superclass to iterate over elements in an vtkAbstractArray.
void Reset()
Reset to an empty state, without freeing any memory.
#define VTK_NEWINSTANCE
void save(Archiver &ar, const vtkUnicodeString &str, const unsigned int vtkNotUsed(version))
vtkInternalComponentNames * ComponentNames
bool HasInformation() const
Inquire if this array has an instance of vtkInformation already associated with it.
ArrayT * vtkArrayDownCast(vtkAbstractArray *array)
vtkArrayDownCast is to be used by generic (e.g.
virtual vtkIdType GetDataSize() const
Returns the size of the data in DataTypeSize units.
virtual int GetArrayType() const
Method for type-checking in FastDownCast implementations.
unsigned int MaxDiscreteValues
#define VTK_EXPECTS(x)