VTK  9.0.1
vtkGenericDataArray.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkGenericDataArray.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 =========================================================================*/
66 #ifndef vtkGenericDataArray_h
67 #define vtkGenericDataArray_h
68 
69 #include "vtkDataArray.h"
70 
71 #include "vtkConfigure.h"
73 #include "vtkSmartPointer.h"
74 #include "vtkTypeTraits.h"
75 
76 #include <cassert>
77 
78 template <class DerivedT, class ValueTypeT>
80 {
82 
83 public:
84  typedef ValueTypeT ValueType;
86 
90  enum
91  {
93  };
94 
99 
107  inline ValueType GetValue(vtkIdType valueIdx) const
108  {
109  return static_cast<const DerivedT*>(this)->GetValue(valueIdx);
110  }
111 
120  VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues())
121  {
122  static_cast<DerivedT*>(this)->SetValue(valueIdx, value);
123  }
124 
133  void GetTypedTuple(vtkIdType tupleIdx, ValueType* tuple) const
134  VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
135  {
136  static_cast<const DerivedT*>(this)->GetTypedTuple(tupleIdx, tuple);
137  }
138 
147  void SetTypedTuple(vtkIdType tupleIdx, const ValueType* tuple)
148  VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
149  {
150  static_cast<DerivedT*>(this)->SetTypedTuple(tupleIdx, tuple);
151  }
152 
158  ValueType GetTypedComponent(vtkIdType tupleIdx, int compIdx) const VTK_EXPECTS(0 <= tupleIdx &&
159  tupleIdx < GetNumberOfTuples()) VTK_EXPECTS(0 <= compIdx && compIdx < GetNumberOfComponents())
160  {
161  return static_cast<const DerivedT*>(this)->GetTypedComponent(tupleIdx, compIdx);
162  }
163 
169  void SetTypedComponent(vtkIdType tupleIdx, int compIdx, ValueType value)
170  VTK_EXPECTS(0 <= tupleIdx && tupleIdx < GetNumberOfTuples())
171  VTK_EXPECTS(0 <= compIdx && compIdx < GetNumberOfComponents())
172  {
173  static_cast<DerivedT*>(this)->SetTypedComponent(tupleIdx, compIdx, value);
174  }
175 
177 
181  void* GetVoidPointer(vtkIdType valueIdx) override;
182  ValueType* GetPointer(vtkIdType valueIdx);
183  void SetVoidArray(void*, vtkIdType, int) override;
184  void SetVoidArray(void*, vtkIdType, int, int) override;
185  void SetArrayFreeFunction(void (*callback)(void*)) override;
186  void* WriteVoidPointer(vtkIdType valueIdx, vtkIdType numValues) override;
187  ValueType* WritePointer(vtkIdType valueIdx, vtkIdType numValues);
189 
196  void RemoveTuple(vtkIdType tupleIdx) override;
197 
202 
206  void InsertValue(vtkIdType valueIdx, ValueType value);
207 
211  void InsertTypedTuple(vtkIdType tupleIdx, const ValueType* t);
212 
217 
222  void InsertTypedComponent(vtkIdType tupleIdx, int compIdx, ValueType val);
223 
225 
229  void GetValueRange(ValueType range[2], int comp);
230  ValueType* GetValueRange(int comp) VTK_SIZEHINT(2);
232 
238  void GetValueRange(ValueType range[2]) { this->GetValueRange(range, 0); }
239 
245  void GetFiniteValueRange(ValueType range[2], int comp);
248  void GetFiniteValueRange(ValueType range[2]) { this->GetFiniteValueRange(range, 0); }
255  vtkIdType Capacity() { return this->Size; }
256 
260  virtual void FillTypedComponent(int compIdx, ValueType value);
261 
265  virtual void FillValue(ValueType value);
266 
267  int GetDataType() const override;
268  int GetDataTypeSize() const override;
269  bool HasStandardMemoryLayout() const override;
270  vtkTypeBool Allocate(vtkIdType size, vtkIdType ext = 1000) override;
271  vtkTypeBool Resize(vtkIdType numTuples) override;
272  void SetNumberOfComponents(int num) override;
273  void SetNumberOfTuples(vtkIdType number) override;
274  void Initialize() override;
275  void Squeeze() override;
276  void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) override;
277  // MSVC doesn't like 'using' here (error C2487). Just forward instead:
278  // using Superclass::SetTuple;
279  void SetTuple(vtkIdType tupleIdx, const float* tuple) override
280  {
281  this->Superclass::SetTuple(tupleIdx, tuple);
282  }
283  void SetTuple(vtkIdType tupleIdx, const double* tuple) override
284  {
285  this->Superclass::SetTuple(tupleIdx, tuple);
286  }
287 
288  void InsertTuples(vtkIdList* dstIds, vtkIdList* srcIds, vtkAbstractArray* source) override;
289  // MSVC doesn't like 'using' here (error C2487). Just forward instead:
290  // using Superclass::InsertTuples;
292  vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray* source) override
293  {
294  this->Superclass::InsertTuples(dstStart, n, srcStart, source);
295  }
296 
297  void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray* source) override;
298  void InsertTuple(vtkIdType tupleIdx, const float* source) override;
299  void InsertTuple(vtkIdType tupleIdx, const double* source) override;
300  void InsertComponent(vtkIdType tupleIdx, int compIdx, double value) override;
302  vtkIdType InsertNextTuple(const float* tuple) override;
303  vtkIdType InsertNextTuple(const double* tuple) override;
304  void GetTuples(vtkIdList* tupleIds, vtkAbstractArray* output) override;
305  void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray* output) override;
306  double* GetTuple(vtkIdType tupleIdx) override;
307  void GetTuple(vtkIdType tupleIdx, double* tuple) override;
308  void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdList* ptIndices, vtkAbstractArray* source,
309  double* weights) override;
310  void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx1, vtkAbstractArray* source1,
311  vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) override;
312  void SetComponent(vtkIdType tupleIdx, int compIdx, double value) override;
313  double GetComponent(vtkIdType tupleIdx, int compIdx) override;
314  void SetVariantValue(vtkIdType valueIdx, vtkVariant value) override;
315  vtkVariant GetVariantValue(vtkIdType valueIdx) override;
316  void InsertVariantValue(vtkIdType valueIdx, vtkVariant value) override;
319  void LookupValue(vtkVariant value, vtkIdList* valueIds) override;
320  virtual void LookupTypedValue(ValueType value, vtkIdList* valueIds);
321  void ClearLookup() override;
322  void DataChanged() override;
323  void FillComponent(int compIdx, double value) override;
325 
326 protected:
328  ~vtkGenericDataArray() override;
329 
335  inline bool AllocateTuples(vtkIdType numTuples)
336  {
337  return static_cast<DerivedT*>(this)->AllocateTuples(numTuples);
338  }
339 
345  inline bool ReallocateTuples(vtkIdType numTuples)
346  {
347  return static_cast<DerivedT*>(this)->ReallocateTuples(numTuples);
348  }
349 
350  // This method resizes the array if needed so that the given tuple index is
351  // valid/accessible.
352  bool EnsureAccessToTuple(vtkIdType tupleIdx);
353 
361  void ComputeValueRange(ValueType range[2], int comp);
362 
370  void ComputeFiniteValueRange(ValueType range[2], int comp);
371 
378  bool ComputeScalarValueRange(ValueType* ranges);
379 
385 
393 
399 
400  std::vector<double> LegacyTuple;
401  std::vector<ValueType> LegacyValueRange;
402  std::vector<ValueType> LegacyValueRangeFull;
403 
405 
406 private:
407  vtkGenericDataArray(const vtkGenericDataArray&) = delete;
408  void operator=(const vtkGenericDataArray&) = delete;
409 };
410 
411 // these predeclarations are needed before the .txx include for MinGW
412 namespace vtkDataArrayPrivate
413 {
414 template <typename A, typename R, typename T>
415 bool DoComputeScalarRange(A*, R*, T);
416 template <typename A, typename R>
417 bool DoComputeVectorRange(A*, R[2], AllValues);
418 template <typename A, typename R>
419 bool DoComputeVectorRange(A*, R[2], FiniteValues);
420 } // namespace vtkDataArrayPrivate
421 
422 #include "vtkGenericDataArray.txx"
423 
424 // Adds an implementation of NewInstanceInternal() that returns an AoS
425 // (unmapped) VTK array, if possible. This allows the pipeline to copy and
426 // propagate the array when the array data is not modifiable. Use this in
427 // combination with vtkAbstractTypeMacro or vtkAbstractTemplateTypeMacro
428 // (instead of vtkTypeMacro) to avoid adding the default NewInstance
429 // implementation.
430 #define vtkAOSArrayNewInstanceMacro(thisClass) \
431 protected: \
432  vtkObjectBase* NewInstanceInternal() const override \
433  { \
434  if (vtkDataArray* da = vtkDataArray::CreateDataArray(thisClass::VTK_DATA_TYPE)) \
435  { \
436  return da; \
437  } \
438  return thisClass::New(); \
439  } \
440  \
441 public:
442 
443 #endif
444 
445 // This portion must be OUTSIDE the include blockers. This is used to tell
446 // libraries other than vtkCommonCore that instantiations of
447 // the GetValueRange lookups can be found externally. This prevents each library
448 // from instantiating these on their own.
449 // Additionally it helps hide implementation details that pull in system
450 // headers.
451 // We only provide these specializations for the 64-bit integer types, since
452 // other types can reuse the double-precision mechanism in
453 // vtkDataArray::GetRange without losing precision.
454 #ifdef VTK_GDA_VALUERANGE_INSTANTIATING
455 
456 // Forward declare necessary stuffs:
457 template <typename ValueType>
459 template <typename ValueType>
461 
462 #ifdef VTK_USE_SCALED_SOA_ARRAYS
463 template <typename ValueType>
465 #endif
466 
467 #define VTK_INSTANTIATE_VALUERANGE_ARRAYTYPE(ArrayType, ValueType) \
468  template VTKCOMMONCORE_EXPORT bool DoComputeScalarRange( \
469  ArrayType*, ValueType*, vtkDataArrayPrivate::AllValues); \
470  template VTKCOMMONCORE_EXPORT bool DoComputeScalarRange( \
471  ArrayType*, ValueType*, vtkDataArrayPrivate::FiniteValues); \
472  template VTKCOMMONCORE_EXPORT bool DoComputeVectorRange( \
473  ArrayType*, ValueType[2], vtkDataArrayPrivate::AllValues); \
474  template VTKCOMMONCORE_EXPORT bool DoComputeVectorRange( \
475  ArrayType*, ValueType[2], vtkDataArrayPrivate::FiniteValues);
476 
477 #ifdef VTK_USE_SCALED_SOA_ARRAYS
478 
479 #define VTK_INSTANTIATE_VALUERANGE_VALUETYPE(ValueType) \
480  VTK_INSTANTIATE_VALUERANGE_ARRAYTYPE(vtkAOSDataArrayTemplate<ValueType>, ValueType) \
481  VTK_INSTANTIATE_VALUERANGE_ARRAYTYPE(vtkSOADataArrayTemplate<ValueType>, ValueType) \
482  VTK_INSTANTIATE_VALUERANGE_ARRAYTYPE(vtkScaledSOADataArrayTemplate<ValueType>, ValueType)
483 
484 #else // VTK_USE_SCALED_SOA_ARRAYS
485 
486 #define VTK_INSTANTIATE_VALUERANGE_VALUETYPE(ValueType) \
487  VTK_INSTANTIATE_VALUERANGE_ARRAYTYPE(vtkAOSDataArrayTemplate<ValueType>, ValueType) \
488  VTK_INSTANTIATE_VALUERANGE_ARRAYTYPE(vtkSOADataArrayTemplate<ValueType>, ValueType)
489 
490 #endif
491 
492 #elif defined(VTK_USE_EXTERN_TEMPLATE) // VTK_GDA_VALUERANGE_INSTANTIATING
493 
494 #ifndef VTK_GDA_TEMPLATE_EXTERN
495 #define VTK_GDA_TEMPLATE_EXTERN
496 #ifdef _MSC_VER
497 #pragma warning(push)
498 // The following is needed when the following is declared
499 // dllexport and is used from another class in vtkCommonCore
500 #pragma warning(disable : 4910) // extern and dllexport incompatible
501 #endif
502 
503 // Forward declare necessary stuffs:
504 template <typename ValueType>
506 template <typename ValueType>
508 
509 #ifdef VTK_USE_SCALED_SOA_ARRAYS
510 template <typename ValueType>
512 #endif
513 
514 namespace vtkDataArrayPrivate
515 {
516 template <typename A, typename R, typename T>
517 bool DoComputeScalarRange(A*, R*, T);
518 template <typename A, typename R>
519 bool DoComputeVectorRange(A*, R[2], AllValues);
520 template <typename A, typename R>
521 bool DoComputeVectorRange(A*, R[2], FiniteValues);
522 } // namespace vtkDataArrayPrivate
523 
524 #define VTK_DECLARE_VALUERANGE_ARRAYTYPE(ArrayType, ValueType) \
525  extern template VTKCOMMONCORE_EXPORT bool DoComputeScalarRange( \
526  ArrayType*, ValueType*, vtkDataArrayPrivate::AllValues); \
527  extern template VTKCOMMONCORE_EXPORT bool DoComputeScalarRange( \
528  ArrayType*, ValueType*, vtkDataArrayPrivate::FiniteValues); \
529  extern template VTKCOMMONCORE_EXPORT bool DoComputeVectorRange( \
530  ArrayType*, ValueType[2], vtkDataArrayPrivate::AllValues); \
531  extern template VTKCOMMONCORE_EXPORT bool DoComputeVectorRange( \
532  ArrayType*, ValueType[2], vtkDataArrayPrivate::FiniteValues);
533 
534 #ifdef VTK_USE_SCALED_SOA_ARRAYS
535 
536 #define VTK_DECLARE_VALUERANGE_VALUETYPE(ValueType) \
537  VTK_DECLARE_VALUERANGE_ARRAYTYPE(vtkAOSDataArrayTemplate<ValueType>, ValueType) \
538  VTK_DECLARE_VALUERANGE_ARRAYTYPE(vtkSOADataArrayTemplate<ValueType>, ValueType) \
539  VTK_DECLARE_VALUERANGE_ARRAYTYPE(vtkScaledSOADataArrayTemplate<ValueType>, ValueType)
540 
541 #else // VTK_USE_SCALED_SOA_ARRAYS
542 
543 #define VTK_DECLARE_VALUERANGE_VALUETYPE(ValueType) \
544  VTK_DECLARE_VALUERANGE_ARRAYTYPE(vtkAOSDataArrayTemplate<ValueType>, ValueType) \
545  VTK_DECLARE_VALUERANGE_ARRAYTYPE(vtkSOADataArrayTemplate<ValueType>, ValueType)
546 
547 #endif
548 
549 namespace vtkDataArrayPrivate
550 {
551 VTK_DECLARE_VALUERANGE_VALUETYPE(long)
552 VTK_DECLARE_VALUERANGE_VALUETYPE(unsigned long)
553 VTK_DECLARE_VALUERANGE_VALUETYPE(long long)
554 VTK_DECLARE_VALUERANGE_VALUETYPE(unsigned long long)
555 VTK_DECLARE_VALUERANGE_ARRAYTYPE(vtkDataArray, double)
556 } // namespace vtkDataArrayPrivate
557 
558 #undef VTK_DECLARE_VALUERANGE_ARRAYTYPE
559 #undef VTK_DECLARE_VALUERANGE_VALUETYPE
560 
561 #ifdef _MSC_VER
562 #pragma warning(pop)
563 #endif
564 #endif // VTK_SOA_DATA_ARRAY_TEMPLATE_EXTERN
565 
566 #endif // VTK_GDA_VALUERANGE_INSTANTIATING
567 
568 // VTK-HeaderTest-Exclude: vtkGenericDataArray.h
vtkGenericDataArray::LookupTypedValue
virtual vtkIdType LookupTypedValue(ValueType value)
vtkGenericDataArrayLookupHelper.h
vtkGenericDataArray::FillComponent
void FillComponent(int compIdx, double value) override
Fill a component of a data array with a specified value.
vtkGenericDataArray::ValueType
ValueTypeT ValueType
Definition: vtkGenericDataArray.h:84
vtkGenericDataArray::Squeeze
void Squeeze() override
Free any unnecessary memory.
vtkGenericDataArray::SetValue
void SetValue(vtkIdType valueIdx, ValueType value)
Set the value at valueIdx to value.
Definition: vtkGenericDataArray.h:119
vtkGenericDataArray::ClearLookup
void ClearLookup() override
Delete the associated fast lookup data structure on this array, if it exists.
vtkDataArrayPrivate::DoComputeScalarRange
bool DoComputeScalarRange(A *, R *, T)
vtkGenericDataArray::GetTypedComponent
ValueType GetTypedComponent(vtkIdType tupleIdx, int compIdx) const
Get component compIdx of the tuple at tupleIdx.
Definition: vtkGenericDataArray.h:158
vtkGenericDataArrayLookupHelper
internal class used by vtkGenericDataArray to support LookupValue.
Definition: vtkGenericDataArrayLookupHelper.h:57
vtkTypeTraits
Template defining traits of native types used by VTK.
Definition: vtkTypeTraits.h:30
vtkGenericDataArray::vtkTemplateTypeMacro
vtkTemplateTypeMacro(SelfType, vtkDataArray)
vtkGenericDataArray::SetVariantValue
void SetVariantValue(vtkIdType valueIdx, vtkVariant value) override
Set a value in the array from a variant.
VTK_EXPECTS
#define VTK_EXPECTS(x)
Definition: vtkWrappingHints.h:44
vtkX3D::value
@ value
Definition: vtkX3D.h:226
vtkGenericDataArray::InsertTypedComponent
void InsertTypedComponent(vtkIdType tupleIdx, int compIdx, ValueType val)
Insert (memory allocation performed) the value at the specified tuple and component location.
vtkSOADataArrayTemplate
Struct-Of-Arrays implementation of vtkGenericDataArray.
Definition: vtkSOADataArrayTemplate.h:38
vtkGenericDataArray::Resize
vtkTypeBool Resize(vtkIdType numTuples) override
Resize the array to the requested number of tuples and preserve data.
vtkIdType
int vtkIdType
Definition: vtkType.h:338
vtkGenericDataArray::GetVoidPointer
void * GetVoidPointer(vtkIdType valueIdx) override
Default implementation raises a runtime error.
vtkGenericDataArray::InsertTuple
void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray *source) override
Insert the tuple at srcTupleIdx in the source array into this array at dstTupleIdx.
vtkGenericDataArray::Allocate
vtkTypeBool Allocate(vtkIdType size, vtkIdType ext=1000) override
Allocate memory for this array.
vtkGenericDataArray::SetVoidArray
void SetVoidArray(void *, vtkIdType, int) override
vtkGenericDataArray::GetComponent
double GetComponent(vtkIdType tupleIdx, int compIdx) override
Return the data component at the location specified by tupleIdx and compIdx.
vtkAbstractArray::Size
vtkIdType Size
Definition: vtkAbstractArray.h:677
vtkGenericDataArray::SetTypedComponent
void SetTypedComponent(vtkIdType tupleIdx, int compIdx, ValueType value)
Set component compIdx of the tuple at tupleIdx to value.
Definition: vtkGenericDataArray.h:169
vtkGenericDataArray::InsertNextTuple
vtkIdType InsertNextTuple(vtkIdType srcTupleIdx, vtkAbstractArray *source) override
Insert the tuple from srcTupleIdx in the source array at the end of this array.
vtkGenericDataArray
Base interface for all typed vtkDataArray subclasses.
Definition: vtkGenericDataArray.h:79
vtkX3D::range
@ range
Definition: vtkX3D.h:244
vtkGenericDataArray::GetValue
ValueType GetValue(vtkIdType valueIdx) const
Get the value at valueIdx.
Definition: vtkGenericDataArray.h:107
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkScaledSOADataArrayTemplate
Struct-Of-Arrays implementation of vtkGenericDataArray with a scaling factor.
Definition: vtkScaledSOADataArrayTemplate.h:43
vtkGenericDataArray::SetTuple
void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray *source) override
Set the tuple at dstTupleIdx in this array to the tuple at srcTupleIdx in the source array.
vtkGenericDataArray::Lookup
vtkGenericDataArrayLookupHelper< SelfType > Lookup
Definition: vtkGenericDataArray.h:404
vtkGenericDataArray::GetTuple
double * GetTuple(vtkIdType tupleIdx) override
Get the data tuple at tupleIdx.
vtkGenericDataArray::InsertTypedTuple
void InsertTypedTuple(vtkIdType tupleIdx, const ValueType *t)
Insert (memory allocation performed) the tuple t at tupleIdx.
vtkGenericDataArray::SetArrayFreeFunction
void SetArrayFreeFunction(void(*callback)(void *)) override
This method allows the user to specify a custom free function to be called when the array is dealloca...
vtkGenericDataArray::DataChanged
void DataChanged() override
Tell the array explicitly that the data has changed.
vtkGenericDataArray::GetValueRange
ValueType * GetValueRange()
Get the range of array values for the 0th component in the native data type.
Definition: vtkGenericDataArray.h:237
vtkGenericDataArray::HasStandardMemoryLayout
bool HasStandardMemoryLayout() const override
Returns true if this array uses the standard memory layout defined in the VTK user guide,...
vtkAbstractArray::GetNumberOfTuples
vtkIdType GetNumberOfTuples() const
Get the number of complete tuples (a component group) in the array.
Definition: vtkAbstractArray.h:172
vtkGenericDataArray::GetVariantValue
vtkVariant GetVariantValue(vtkIdType valueIdx) override
Retrieve value from the array as a variant.
vtkGenericDataArray::FillTypedComponent
virtual void FillTypedComponent(int compIdx, ValueType value)
Set component comp of all tuples to value.
vtkGenericDataArray::InsertTuples
void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds, vtkAbstractArray *source) override
Copy the tuples indexed in srcIds from the source array to the tuple locations indexed by dstIds in t...
vtkGenericDataArray::SetNumberOfTuples
void SetNumberOfTuples(vtkIdType number) override
Set the number of tuples (a component group) in the array.
vtkGenericDataArray::GetFiniteValueRange
void GetFiniteValueRange(ValueType range[2])
These methods are analogous to the GetValueRange methods, except that the only consider finite values...
Definition: vtkGenericDataArray.h:248
vtkAbstractArray::GetNumberOfValues
vtkIdType GetNumberOfValues() const
Get the total number of values in the array.
Definition: vtkAbstractArray.h:180
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:45
vtkGenericDataArray::ComputeFiniteValueRange
void ComputeFiniteValueRange(ValueType range[2], int comp)
Compute the range for a specific component.
vtkGenericDataArray::GetDataTypeSize
int GetDataTypeSize() const override
Return the size of the underlying data type.
vtkTypeTraits.h
vtkGenericDataArray::AllocateTuples
bool AllocateTuples(vtkIdType numTuples)
Allocate space for numTuples.
Definition: vtkGenericDataArray.h:335
vtkAbstractArray::GetNumberOfComponents
int GetNumberOfComponents() const
Definition: vtkAbstractArray.h:127
vtkGenericDataArray::GetTypedTuple
void GetTypedTuple(vtkIdType tupleIdx, ValueType *tuple) const
Copy the tuple at tupleIdx into tuple.
Definition: vtkGenericDataArray.h:133
vtkGenericDataArray::RemoveTuple
void RemoveTuple(vtkIdType tupleIdx) override
Removes a tuple at the given index.
vtkDataArrayPrivate
Definition: vtkDataArray.h:600
vtkSmartPointer.h
vtkVariant
A atomic type representing the union of many types.
Definition: vtkVariant.h:65
vtkIdList
list of point or cell ids
Definition: vtkIdList.h:30
vtkX3D::size
@ size
Definition: vtkX3D.h:259
vtkGenericDataArray::GetDataType
int GetDataType() const override
Return the underlying data type.
vtkGenericDataArray::EnsureAccessToTuple
bool EnsureAccessToTuple(vtkIdType tupleIdx)
vtkDataArrayPrivate::DoComputeVectorRange
bool DoComputeVectorRange(A *, R[2], AllValues)
vtkGenericDataArray::InsertValue
void InsertValue(vtkIdType valueIdx, ValueType value)
Insert data at a specified position in the array.
vtkGenericDataArray::InsertNextTypedTuple
vtkIdType InsertNextTypedTuple(const ValueType *t)
Insert (memory allocation performed) the tuple onto the end of the array.
vtkGenericDataArray::FillValue
virtual void FillValue(ValueType value)
Set all the values in array to value.
vtkGenericDataArray::SetTypedTuple
void SetTypedTuple(vtkIdType tupleIdx, const ValueType *tuple)
Set this array's tuple at tupleIdx to the values in tuple.
Definition: vtkGenericDataArray.h:147
vtkGenericDataArray::InterpolateTuple
void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdList *ptIndices, vtkAbstractArray *source, double *weights) override
Set the tuple at dstTupleIdx in this array to the interpolated tuple value, given the ptIndices in th...
vtkGenericDataArray::GetValueRange
void GetValueRange(ValueType range[2])
Definition: vtkGenericDataArray.h:238
vtkGenericDataArray::LegacyValueRange
std::vector< ValueType > LegacyValueRange
Definition: vtkGenericDataArray.h:401
vtkGenericDataArray::SetTuple
void SetTuple(vtkIdType tupleIdx, const float *tuple) override
Set the data tuple at tupleIdx.
Definition: vtkGenericDataArray.h:279
vtkAbstractArray
Abstract superclass for all arrays.
Definition: vtkAbstractArray.h:75
vtkGenericDataArray::~vtkGenericDataArray
~vtkGenericDataArray() override
vtkGenericDataArray::NewIterator
vtkArrayIterator * NewIterator() override
Subclasses must override this method and provide the right kind of templated vtkArrayIteratorTemplate...
vtkGenericDataArray::GetTuples
void GetTuples(vtkIdList *tupleIds, vtkAbstractArray *output) override
Given a list of tuple ids, return an array of tuples.
vtkGenericDataArray::InsertComponent
void InsertComponent(vtkIdType tupleIdx, int compIdx, double value) override
Insert value at the location specified by tupleIdx and compIdx.
vtkGenericDataArray::LegacyTuple
std::vector< double > LegacyTuple
Definition: vtkGenericDataArray.h:400
vtkDataArray.h
vtkGenericDataArray::WritePointer
ValueType * WritePointer(vtkIdType valueIdx, vtkIdType numValues)
vtkGenericDataArray::InsertVariantValue
void InsertVariantValue(vtkIdType valueIdx, vtkVariant value) override
Insert a value into the array from a variant.
vtkGenericDataArray::GetFiniteValueRange
ValueType * GetFiniteValueRange()
These methods are analogous to the GetValueRange methods, except that the only consider finite values...
Definition: vtkGenericDataArray.h:247
vtkArrayIterator
Abstract superclass to iterate over elements in an vtkAbstractArray.
Definition: vtkArrayIterator.h:49
vtkGenericDataArray::Capacity
vtkIdType Capacity()
Return the capacity in typeof T units of the current array.
Definition: vtkGenericDataArray.h:255
vtkGenericDataArray::ComputeFiniteScalarValueRange
bool ComputeFiniteScalarValueRange(ValueType *ranges)
Computes the range for each component of an array, the length of ranges must be two times the number ...
vtkGenericDataArray::VTK_DATA_TYPE
@ VTK_DATA_TYPE
Definition: vtkGenericDataArray.h:92
vtkGenericDataArray::ComputeFiniteVectorValueRange
bool ComputeFiniteVectorValueRange(ValueType range[2])
Returns true if the range was computed.
vtkGenericDataArray::SetTuple
void SetTuple(vtkIdType tupleIdx, const double *tuple) override
Definition: vtkGenericDataArray.h:283
vtkGenericDataArray::GetPointer
ValueType * GetPointer(vtkIdType valueIdx)
vtkGenericDataArray::vtkGenericDataArray
vtkGenericDataArray()
vtkAOSDataArrayTemplate
Array-Of-Structs implementation of vtkGenericDataArray.
Definition: vtkAOSDataArrayTemplate.h:41
vtkGenericDataArray::LookupValue
vtkIdType LookupValue(vtkVariant value) override
Return the value indices where a specific value appears.
vtkGenericDataArray::WriteVoidPointer
void * WriteVoidPointer(vtkIdType valueIdx, vtkIdType numValues) override
Get the address of a particular data index.
source
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:959
VTK_NEWINSTANCE
#define VTK_NEWINSTANCE
Definition: vtkWrappingHints.h:42
vtkGenericDataArray::InsertTuples
void InsertTuples(vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray *source) override
Copy n consecutive tuples starting at srcStart from the source array to this array,...
Definition: vtkGenericDataArray.h:291
vtkGenericDataArray::ComputeScalarValueRange
bool ComputeScalarValueRange(ValueType *ranges)
Computes the range for each component of an array, the length of ranges must be two times the number ...
vtkGenericDataArray::InsertNextValue
vtkIdType InsertNextValue(ValueType value)
Insert data at the end of the array.
vtkGenericDataArray::LegacyValueRangeFull
std::vector< ValueType > LegacyValueRangeFull
Definition: vtkGenericDataArray.h:402
vtkGenericDataArray::Initialize
void Initialize() override
Release storage and reset array to initial state.
vtkGenericDataArray::ComputeVectorValueRange
bool ComputeVectorValueRange(ValueType range[2])
Returns true if the range was computed.
vtkGenericDataArray::ComputeValueRange
void ComputeValueRange(ValueType range[2], int comp)
Compute the range for a specific component.
vtkGenericDataArray::ReallocateTuples
bool ReallocateTuples(vtkIdType numTuples)
Allocate space for numTuples.
Definition: vtkGenericDataArray.h:345
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkGenericDataArray::SetNumberOfComponents
void SetNumberOfComponents(int num) override
Set/Get the dimension (n) of the components.
vtkGenericDataArray::SetComponent
void SetComponent(vtkIdType tupleIdx, int compIdx, double value) override
Set the data component at the location specified by tupleIdx and compIdx to value.