VTK  9.0.20210508
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  }
747 
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 
767 #endif
vtkAbstractArray::SetArrayFreeFunction
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...
vtkAbstractArray::Initialize
virtual void Initialize()=0
Release storage and reset array to initial state.
vtkAbstractArray::LookupValue
virtual vtkIdType LookupValue(vtkVariant value)=0
Return the value indices where a specific value appears.
vtkAbstractArray::Name
char * Name
Definition: vtkAbstractArray.h:684
vtkAbstractArray::Squeeze
virtual void Squeeze()=0
Free any unnecessary memory.
vtkAbstractArray::CopyInformation
virtual int CopyInformation(vtkInformation *infoFrom, int deep=1)
Copy information instance.
vtkAbstractArray::InterpolateTuple
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...
vtkAbstractArray::DeleteMethod
DeleteMethod
Definition: vtkAbstractArray.h:322
VTK_INT_MAX
#define VTK_INT_MAX
Definition: vtkType.h:155
vtkAbstractArray::CopyComponentNames
int CopyComponentNames(vtkAbstractArray *da)
Copies the component names from the inputed array to the current array make sure that the current arr...
vtkAbstractArray::VTK_DATA_ARRAY_ALIGNED_FREE
@ VTK_DATA_ARRAY_ALIGNED_FREE
Definition: vtkAbstractArray.h:325
vtkAbstractArray::GetVariantValue
virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
Retrieve value from the array as a variant.
vtkVariant.h
vtkAbstractArray::SetVoidArray
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.
vtkAbstractArray::HasAComponentName
bool HasAComponentName() const
Returns if any component has had a name assigned.
vtkX3D::component
@ component
Definition: vtkX3D.h:181
vtkAbstractArray::NewIterator
virtual vtkArrayIterator * NewIterator()=0
Subclasses must override this method and provide the right kind of templated vtkArrayIteratorTemplate...
vtkAbstractArray::InsertTuple
virtual void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray *source)=0
Insert the tuple at srcTupleIdx in the source array into this array at dstTupleIdx.
VTK_EXPECTS
#define VTK_EXPECTS(x)
Definition: vtkWrappingHints.h:47
vtkX3D::value
@ value
Definition: vtkX3D.h:226
vtkAbstractArray::VTK_DATA_ARRAY_DELETE
@ VTK_DATA_ARRAY_DELETE
Definition: vtkAbstractArray.h:324
vtkAbstractArray::GetElementComponentSize
virtual int GetElementComponentSize() const =0
Return the size, in bytes, of the lowest-level element of an array.
vtkX3D::type
@ type
Definition: vtkX3D.h:522
vtkIdType
int vtkIdType
Definition: vtkType.h:338
vtkAbstractArray::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkAbstractArray::InsertNextTuple
virtual vtkIdType InsertNextTuple(vtkIdType srcTupleIdx, vtkAbstractArray *source)=0
Insert the tuple from srcTupleIdx in the source array at the end of this array.
vtkAbstractArray::Modified
void Modified() override
Removes out-of-date PER_COMPONENT() and PER_FINITE_COMPONENT() values.
vtkAbstractArray::SetNumberOfTuples
virtual void SetNumberOfTuples(vtkIdType numTuples)=0
Set the number of tuples (a component group) in the array.
vtkAbstractArray::~vtkAbstractArray
~vtkAbstractArray() override
vtkAbstractArray::InsertTuples
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...
vtkAbstractArray::Size
vtkIdType Size
Definition: vtkAbstractArray.h:677
vtkAbstractArray::VTK_DATA_ARRAY_FREE
@ VTK_DATA_ARRAY_FREE
Definition: vtkAbstractArray.h:323
vtkAbstractArray::GetDataType
virtual int GetDataType() const =0
Return the underlying data type.
vtkAbstractArray::Information
vtkInformation * Information
Definition: vtkAbstractArray.h:688
vtkAbstractArray::SetVoidArray
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.
Definition: vtkAbstractArray.h:349
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:63
vtkAbstractArray::IsNumeric
virtual int IsNumeric() const =0
This method is here to make backward compatibility easier.
vtkAbstractArray::MappedDataArray
@ MappedDataArray
Definition: vtkAbstractArray.h:640
vtkVariantArray
An array holding vtkVariants.
Definition: vtkVariantArray.h:50
vtkAbstractArray::ScaleSoADataArrayTemplate
@ ScaleSoADataArrayTemplate
Definition: vtkAbstractArray.h:641
vtkAbstractArray::HasStandardMemoryLayout
virtual bool HasStandardMemoryLayout() const
Returns true if this array uses the standard memory layout defined in the VTK user guide,...
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
vtkAbstractArray::ComponentNames
vtkInternalComponentNames * ComponentNames
Definition: vtkAbstractArray.h:690
vtkNotUsed
const vtkUnicodeString const unsigned int vtkNotUsed(version))
Definition: vtkVariantBoostSerialization.h:72
vtkAbstractArray::GetTuples
virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray *output)
Get the tuples for the range of tuple ids specified (i.e., p1->p2 inclusive).
vtkAbstractArray::GetInformation
vtkInformation * GetInformation()
Get an information object that can be used to annotate the array.
vtkAbstractArray::Allocate
virtual vtkTypeBool Allocate(vtkIdType numValues, vtkIdType ext=1000)=0
Allocate memory for this array.
vtkAbstractArray::InsertVariantValue
virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)=0
Insert a value into the array from a variant.
vtkAbstractArray::GetVoidPointer
virtual void * GetVoidPointer(vtkIdType valueIdx)=0
Return a void pointer.
vtkAbstractArray::GetNumberOfTuples
vtkIdType GetNumberOfTuples() const
Get the number of complete tuples (a component group) in the array.
Definition: vtkAbstractArray.h:172
vtkAbstractArray::GetArrayType
virtual int GetArrayType() const
Method for type-checking in FastDownCast implementations.
Definition: vtkAbstractArray.h:650
vtkAbstractArray::vtkAbstractArray
vtkAbstractArray()
vtkAbstractArray::GetNumberOfValues
vtkIdType GetNumberOfValues() const
Get the total number of values in the array.
Definition: vtkAbstractArray.h:180
vtkAbstractArray::LookupValue
virtual void LookupValue(vtkVariant value, vtkIdList *valueIds)=0
Return the value indices where a specific value appears.
vtkAbstractArray::RebuildArray
bool RebuildArray
Definition: vtkAbstractArray.h:686
vtkAbstractArray::UpdateDiscreteValueSet
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 ...
vtkAbstractArray::Reset
void Reset()
Reset to an empty state, without freeing any memory.
Definition: vtkAbstractArray.h:304
vtkAbstractArray::AoSDataArrayTemplate
@ AoSDataArrayTemplate
Definition: vtkAbstractArray.h:637
vtkAbstractArray::SetTuple
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.
vtkAbstractArray::GetNumberOfComponents
int GetNumberOfComponents() const
Set/Get the dimension (n) of the components.
Definition: vtkAbstractArray.h:127
vtkInformationIntegerKey
Key for integer values in vtkInformation.
Definition: vtkInformationIntegerKey.h:32
vtkAbstractArray::GetDataSize
virtual vtkIdType GetDataSize() const
Returns the size of the data in DataTypeSize units.
Definition: vtkAbstractArray.h:427
vtkAbstractArray::DISCRETE_VALUE_SAMPLE_PARAMETERS
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...
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:34
vtkInformationVariantVectorKey
Key for variant vector values.
Definition: vtkInformationVariantVectorKey.h:34
vtkAbstractArray::CreateArray
static vtkAbstractArray * CreateArray(int dataType)
Creates an array for dataType where dataType is one of VTK_BIT, VTK_CHAR, VTK_UNSIGNED_CHAR,...
save
void save(Archiver &ar, const std::string &str, const unsigned int vtkNotUsed(version))
Definition: vtkVariantBoostSerialization.h:64
vtkVariant
A atomic type representing the union of many types.
Definition: vtkVariant.h:66
vtkIdList
list of point or cell ids
Definition: vtkIdList.h:31
vtkArrayDownCast_impl::operator()
ArrayT * operator()(vtkAbstractArray *array)
Definition: vtkAbstractArray.h:707
vtkAbstractArray::InterpolateTuple
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,...
vtkArrayDownCast_impl
Implementation of vtkArrayDownCast.
Definition: vtkAbstractArray.h:706
vtkAbstractArray::SoADataArrayTemplate
@ SoADataArrayTemplate
Definition: vtkAbstractArray.h:638
vtkX3D::size
@ size
Definition: vtkX3D.h:259
vtkAbstractArray::GetComponentName
const char * GetComponentName(vtkIdType component) const
Get the component name for a given component.
vtkAbstractArray::SetInformation
virtual void SetInformation(vtkInformation *)
Set an information object that can be used to annotate the array.
vtkAbstractArray::PER_FINITE_COMPONENT
static vtkInformationInformationVectorKey * PER_FINITE_COMPONENT()
This key is used to hold a vector of COMPONENT_VALUES (and, for vtkDataArray subclasses,...
vtkAbstractArray::GetDataTypeSize
static int GetDataTypeSize(int type)
Return the size of the underlying data type.
vtkAbstractArray::SetVariantValue
virtual void SetVariantValue(vtkIdType valueIdx, vtkVariant value)=0
Set a value in the array from a variant.
vtkAbstractArray::SetComponentName
void SetComponentName(vtkIdType component, const char *name)
Set the name for a component.
vtkX3D::name
@ name
Definition: vtkX3D.h:225
vtkAbstractArray::InsertTuples
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,...
vtkObject.h
vtkAbstractArray::SetNumberOfValues
virtual bool SetNumberOfValues(vtkIdType numValues)
Specify the number of values (tuples * components) for this object to hold.
vtkArrayDownCast
ArrayT * vtkArrayDownCast(vtkAbstractArray *array)
vtkArrayDownCast is to be used by generic (e.g.
Definition: vtkAbstractArray.h:729
vtkAbstractArray
Abstract superclass for all arrays.
Definition: vtkAbstractArray.h:76
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:74
vtkAbstractArray::GetMaxId
vtkIdType GetMaxId() const
What is the maximum id currently in the array.
Definition: vtkAbstractArray.h:319
vtkAbstractArray::ExportToVoidPointer
virtual void ExportToVoidPointer(void *out_ptr)
This method copies the array data to the void pointer specified by the user.
vtkAbstractArray::MaxDiscreteValues
unsigned int MaxDiscreteValues
Definition: vtkAbstractArray.h:682
vtkIdTypeArray
dynamic, self-adjusting array of vtkIdType
Definition: vtkIdTypeArray.h:36
vtkAbstractArray::GetActualMemorySize
virtual unsigned long GetActualMemorySize() const =0
Return the memory in kibibytes (1024 bytes) consumed by this data array.
vtkInformationDoubleVectorKey
Key for double vector values.
Definition: vtkInformationDoubleVectorKey.h:32
vtkAbstractArray::DeepCopy
virtual void DeepCopy(vtkAbstractArray *da)
Deep copy of data.
vtkArrayIterator
Abstract superclass to iterate over elements in an vtkAbstractArray.
Definition: vtkArrayIterator.h:50
vtkAbstractArray::TypedDataArray
@ TypedDataArray
Definition: vtkAbstractArray.h:639
vtkAbstractArray::DataArray
@ DataArray
Definition: vtkAbstractArray.h:636
vtkInformationInformationVectorKey
Key for vtkInformation vectors.
Definition: vtkInformationInformationVectorKey.h:34
vtkAbstractArray::GetTuples
virtual void GetTuples(vtkIdList *tupleIds, vtkAbstractArray *output)
Given a list of tuple ids, return an array of tuples.
vtkAbstractArray::GetDataTypeSize
virtual int GetDataTypeSize() const =0
Return the size of the underlying data type.
vtkAbstractArray::GUI_HIDE
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...
source
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:959
vtkAbstractArray::GetDataTypeAsString
virtual const char * GetDataTypeAsString(void) const
Get the name of a data type as a string.
Definition: vtkAbstractArray.h:391
vtkAbstractArray::ClearLookup
virtual void ClearLookup()=0
Delete the associated fast lookup data structure on this array, if it exists.
VTK_NEWINSTANCE
#define VTK_NEWINSTANCE
Definition: vtkWrappingHints.h:44
vtkAbstractArray::MaxId
vtkIdType MaxId
Definition: vtkAbstractArray.h:678
vtkAbstractArray::DISCRETE_VALUES
static vtkInformationVariantVectorKey * DISCRETE_VALUES()
A key used to hold discrete values taken on either by the tuples of the array (when present in this->...
vtkAbstractArray::GetProminentComponentValues
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 ...
vtkAbstractArray::HasInformation
bool HasInformation() const
Inquire if this array has an instance of vtkInformation already associated with it.
Definition: vtkAbstractArray.h:548
vtkAbstractArray::PER_COMPONENT
static vtkInformationInformationVectorKey * PER_COMPONENT()
This key is used to hold a vector of COMPONENT_VALUES (and, for vtkDataArray subclasses,...
vtkAbstractArray::DataChanged
virtual void DataChanged()=0
Tell the array explicitly that the data has changed.
vtkAbstractArray::GetSize
vtkIdType GetSize() const
Return the size of the data.
Definition: vtkAbstractArray.h:314
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkAbstractArray::Resize
virtual vtkTypeBool Resize(vtkIdType numTuples)=0
Resize the array to the requested number of tuples and preserve data.
vtkAbstractArray::NumberOfComponents
int NumberOfComponents
Definition: vtkAbstractArray.h:679