VTK
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 //
60 #ifndef vtkAbstractArray_h
61 #define vtkAbstractArray_h
62 
63 #include "vtkCommonCoreModule.h" // For export macro
64 #include "vtkObject.h"
65 #include "vtkVariant.h" // for variant arguments
66 
67 class vtkArrayIterator;
68 class vtkDataArray;
69 class vtkIdList;
70 class vtkIdTypeArray;
71 class vtkInformation;
76 class vtkVariantArray;
77 
78 class VTKCOMMONCORE_EXPORT vtkAbstractArray : public vtkObject
79 {
80 public:
81  vtkTypeMacro(vtkAbstractArray,vtkObject);
82  void PrintSelf(ostream& os, vtkIndent indent) override;
83 
92  virtual int Allocate(vtkIdType numValues, vtkIdType ext=1000) = 0;
93 
97  virtual void Initialize() = 0;
98 
103  virtual int GetDataType() = 0;
104 
106 
111  virtual int GetDataTypeSize() = 0;
112  static int GetDataTypeSize(int type);
114 
122  virtual int GetElementComponentSize() = 0;
123 
125 
129  vtkSetClampMacro(NumberOfComponents, int, 1, VTK_INT_MAX);
130  int GetNumberOfComponents() { return this->NumberOfComponents; }
132 
136  void SetComponentName( vtkIdType component, const char *name );
137 
142  const char* GetComponentName( vtkIdType component );
143 
147  bool HasAComponentName();
148 
153  int CopyComponentNames( vtkAbstractArray *da );
154 
162  virtual void SetNumberOfTuples(vtkIdType numTuples) = 0;
163 
169  virtual void SetNumberOfValues(vtkIdType numValues);
170 
175  {return (this->MaxId + 1)/this->NumberOfComponents;}
176 
184  {
185  return (this->MaxId + 1);
186  }
187 
194  virtual void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx,
195  vtkAbstractArray *source) = 0;
196 
202  virtual void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx,
203  vtkAbstractArray* source) = 0;
204 
210  virtual void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds,
211  vtkAbstractArray* source) = 0;
212 
218  virtual void InsertTuples(vtkIdType dstStart, vtkIdType n, vtkIdType srcStart,
219  vtkAbstractArray* source) = 0;
220 
226  virtual vtkIdType InsertNextTuple(vtkIdType srcTupleIdx,
227  vtkAbstractArray* source) = 0;
228 
234  virtual void GetTuples(vtkIdList *tupleIds, vtkAbstractArray* output);
235 
241  virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray *output);
242 
249  virtual bool HasStandardMemoryLayout();
250 
258  virtual void *GetVoidPointer(vtkIdType valueIdx) = 0;
259 
268  virtual void DeepCopy(vtkAbstractArray* da);
269 
277  virtual void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdList *ptIndices,
278  vtkAbstractArray* source, double* weights) = 0;
279 
288  virtual void InterpolateTuple(vtkIdType dstTupleIdx,
289  vtkIdType srcTupleIdx1, vtkAbstractArray* source1,
290  vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) =0;
291 
297  virtual void Squeeze() = 0;
298 
308  virtual int Resize(vtkIdType numTuples) = 0;
309 
311 
314  void Reset()
315  {
316  this->MaxId = -1;
317  this->DataChanged();
318  }
320 
325  {return this->Size;}
326 
331  {return this->MaxId;}
332 
334  {
337  VTK_DATA_ARRAY_ALIGNED_FREE
338  };
339 
341 
355  virtual void SetVoidArray(void *vtkNotUsed(array),
356  vtkIdType vtkNotUsed(size),
357  int vtkNotUsed(save)) =0;
358  virtual void SetVoidArray(void *array, vtkIdType size, int save,
359  int vtkNotUsed(deleteMethod))
360  {this->SetVoidArray(array,size,save);};
362 
368  virtual void ExportToVoidPointer(void *out_ptr);
369 
378  virtual unsigned long GetActualMemorySize() = 0;
379 
381 
384  vtkSetStringMacro(Name);
385  vtkGetStringMacro(Name);
387 
391  virtual const char *GetDataTypeAsString( void )
392  { return vtkImageScalarTypeNameMacro( this->GetDataType() ); }
393 
404  static vtkAbstractArray* CreateArray(int dataType);
405 
410  virtual int IsNumeric() = 0;
411 
417  virtual vtkArrayIterator* NewIterator() = 0;
418 
426  {
427  return this->GetNumberOfComponents() * this->GetNumberOfTuples();
428  }
429 
431 
434  virtual vtkIdType LookupValue(vtkVariant value) = 0;
435  virtual void LookupValue(vtkVariant value, vtkIdList* valueIds) = 0;
437 
441  virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
442  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues());
443 
448  virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)
449  VTK_EXPECTS(0 <= valueIdx) = 0;
450 
455  virtual void SetVariantValue(vtkIdType valueIdx, vtkVariant value)
456  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues()) = 0;
457 
466  virtual void DataChanged() = 0;
467 
473  virtual void ClearLookup() = 0;
474 
527  virtual void GetProminentComponentValues(int comp, vtkVariantArray* values,
528  double uncertainty = 1.e-6, double minimumProminence = 1.e-3);
529 
530  // TODO: Implement these lookup functions also.
531  //virtual void LookupRange(vtkVariant min, vtkVariant max, vtkIdList* ids,
532  // bool includeMin = true, bool includeMax = true) = 0;
533  //virtual void LookupGreaterThan(vtkVariant min, vtkIdList* ids, bool includeMin = false) = 0;
534  //virtual void LookupLessThan(vtkVariant max, vtkIdList* ids, bool includeMax = false) = 0;
535 
541  vtkInformation* GetInformation();
546  bool HasInformation(){ return this->Information!=nullptr; }
547 
559  virtual int CopyInformation(vtkInformation *infoFrom, int deep=1);
560 
565  static vtkInformationIntegerKey* GUI_HIDE();
566 
579  static vtkInformationInformationVectorKey* PER_COMPONENT();
580 
593  static vtkInformationInformationVectorKey* PER_FINITE_COMPONENT();
594 
598  void Modified() override;
599 
605  static vtkInformationVariantVectorKey* DISCRETE_VALUES();
606 
614  static vtkInformationDoubleVectorKey* DISCRETE_VALUE_SAMPLE_PARAMETERS();
615 
616  // Deprecated. Use vtkAbstractArray::MaxDiscreteValues instead.
617  enum {
618  MAX_DISCRETE_VALUES = 32
619  };
620 
622 
626  vtkGetMacro(MaxDiscreteValues, unsigned int);
627  vtkSetMacro(MaxDiscreteValues, unsigned int);
629 
630  enum {
631  AbstractArray = 0,
637 
638  DataArrayTemplate = AoSDataArrayTemplate
639  };
640 
645  virtual int GetArrayType()
646  {
647  return AbstractArray;
648  }
649 
650 protected:
651  // Construct object with default tuple dimension (number of components) of 1.
653  ~vtkAbstractArray() override;
654 
660  virtual void SetInformation( vtkInformation* );
661 
673  virtual void UpdateDiscreteValueSet(double uncertainty, double minProminence);
674 
675  vtkIdType Size; // allocated size of data
676  vtkIdType MaxId; // maximum index inserted thus far
677  int NumberOfComponents; // the number of components per tuple
678 
679  // maximum number of prominent values before array is considered continuous.
680  unsigned int MaxDiscreteValues;
681 
682  char* Name;
683 
684  bool RebuildArray; // whether to rebuild the fast lookup data structure.
685 
687 
688  class vtkInternalComponentNames;
689  vtkInternalComponentNames* ComponentNames; //names for each component
690 
691 private:
692  vtkAbstractArray(const vtkAbstractArray&) = delete;
693  void operator=(const vtkAbstractArray&) = delete;
694 };
695 
697 
702 template <typename ArrayT>
704 {
705  inline ArrayT* operator()(vtkAbstractArray* array)
706  {
707  return ArrayT::SafeDownCast(array);
708  }
709 };
711 
729 template <typename ArrayT>
731 {
732  // The default vtkArrayDownCast_impl struct uses SafeDownCast, but is
733  // specialized for arrays that support FastDownCast.
734  return vtkArrayDownCast_impl<ArrayT>()(array);
735 }
736 
738 
742 #define vtkArrayDownCast_FastCastMacro(ArrayT) \
743  template <> struct vtkArrayDownCast_impl<ArrayT> \
744  { \
745  inline ArrayT* operator()(vtkAbstractArray *array) \
746  { \
747  return ArrayT::FastDownCast(array); \
748  } \
749  };
750 
751 
753 
759 #define vtkArrayDownCast_TemplateFastCastMacro(ArrayT) \
760  template <typename ValueT> struct vtkArrayDownCast_impl<ArrayT<ValueT> > \
761  { \
762  inline ArrayT<ValueT>* operator()(vtkAbstractArray *array) \
763  { \
764  return ArrayT<ValueT>::FastDownCast(array); \
765  } \
766  };
767 
768 
769 #endif
vtkIdType GetMaxId()
What is the maximum id currently in the array.
abstract base class for most VTK objects
Definition: vtkObject.h:59
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.
An array holding vtkVariants.
Store vtkAlgorithm input/output information.
vtkIdType GetNumberOfTuples()
Get the number of complete tuples (a component group) in the array.
Abstract superclass for all arrays.
Implementation of vtkArrayDownCast.
#define VTK_INT_MAX
Definition: vtkType.h:157
virtual int GetArrayType()
Method for type-checking in FastDownCast implementations.
dynamic, self-adjusting array of vtkIdType
int vtkIdType
Definition: vtkType.h:345
int GetNumberOfComponents()
Set/Get the dimension (n) of the components.
A atomic type representing the union of many types.
Definition: vtkVariant.h:70
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 vtkIdType GetDataSize()
Returns the size of the data in DataTypeSize units.
vtkInformation * Information
a simple class to control print indentation
Definition: vtkIndent.h:39
list of point or cell ids
Definition: vtkIdList.h:36
Key for integer values in vtkInformation.
virtual const char * GetDataTypeAsString(void)
Get the name of a data type as a string.
ArrayT * operator()(vtkAbstractArray *array)
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
bool HasInformation()
Inquire if this array has an instance of vtkInformation already associated with it.
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
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
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
void save(Archiver &ar, const vtkUnicodeString &str, const unsigned int vtkNotUsed(version))
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
vtkIdType GetSize()
Return the size of the data.
vtkInternalComponentNames * ComponentNames
ArrayT * vtkArrayDownCast(vtkAbstractArray *array)
vtkArrayDownCast is to be used by generic (e.g.
unsigned int MaxDiscreteValues
#define VTK_EXPECTS(x)