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], vtkAllValues);
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::vtkAllValues); \
470  template VTKCOMMONCORE_EXPORT bool DoComputeScalarRange( \
471  ArrayType*, ValueType*, vtkDataArrayPrivate::FiniteValues); \
472  template VTKCOMMONCORE_EXPORT bool DoComputeVectorRange( \
473  ArrayType*, ValueType[2], vtkDataArrayPrivate::vtkAllValues); \
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], vtkAllValues);
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::vtkAllValues); \
527  extern template VTKCOMMONCORE_EXPORT bool DoComputeScalarRange( \
528  ArrayType*, ValueType*, vtkDataArrayPrivate::FiniteValues); \
529  extern template VTKCOMMONCORE_EXPORT bool DoComputeVectorRange( \
530  ArrayType*, ValueType[2], vtkDataArrayPrivate::vtkAllValues); \
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
Struct-Of-Arrays implementation of vtkGenericDataArray with a scaling factor.
void SetValue(vtkIdType valueIdx, ValueType value)
Set the value at valueIdx to value.
Struct-Of-Arrays implementation of vtkGenericDataArray.
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...
void FillComponent(int compIdx, double value) override
Fill a component of a data array with a specified value.
vtkIdType InsertNextTypedTuple(const ValueType *t)
Insert (memory allocation performed) the tuple onto the end of the array.
void Squeeze() override
Free any unnecessary memory.
void GetFiniteValueRange(ValueType range[2])
These methods are analogous to the GetValueRange methods, except that the only consider finite values...
vtkIdType GetNumberOfValues() const
Get the total number of values in the array.
vtkIdType GetNumberOfTuples() const
Get the number of complete tuples (a component group) in the array.
bool ComputeVectorValueRange(ValueType range[2])
Returns true if the range was computed.
ValueType GetTypedComponent(vtkIdType tupleIdx, int compIdx) const
Get component compIdx of the tuple at tupleIdx.
void InsertValue(vtkIdType valueIdx, ValueType value)
Insert data at a specified position in the array.
vtkIdType InsertNextTuple(vtkIdType srcTupleIdx, vtkAbstractArray *source) override
Insert the tuple from srcTupleIdx in the source array at the end of this array.
internal class used by vtkGenericDataArray to support LookupValue.
int GetNumberOfComponents() const
Set/Get the dimension (n) of the components.
Abstract superclass for all arrays.
ValueType * GetPointer(vtkIdType valueIdx)
Default implementation raises a runtime error.
vtkGenericDataArrayLookupHelper< SelfType > Lookup
void SetVariantValue(vtkIdType valueIdx, vtkVariant value) override
Set a value in the array from a variant.
bool ComputeFiniteScalarValueRange(ValueType *ranges)
Computes the range for each component of an array, the length of ranges must be two times the number ...
ValueType GetValue(vtkIdType valueIdx) const
Get the value at valueIdx.
bool DoComputeScalarRange(A *, R *, T)
void SetArrayFreeFunction(void(*callback)(void *)) override
Default implementation raises a runtime error.
vtkTypeBool Allocate(vtkIdType size, vtkIdType ext=1000) override
Allocate memory for this array.
void SetComponent(vtkIdType tupleIdx, int compIdx, double value) override
Set the data component at the location specified by tupleIdx and compIdx to value.
void Initialize() override
Release storage and reset array to initial state.
void SetTypedComponent(vtkIdType tupleIdx, int compIdx, ValueType value)
Set component compIdx of the tuple at tupleIdx to value.
std::vector< ValueType > LegacyValueRangeFull
int vtkIdType
Definition: vtkType.h:338
Base interface for all typed vtkDataArray subclasses.
ValueType * GetFiniteValueRange()
These methods are analogous to the GetValueRange methods, except that the only consider finite values...
void SetVoidArray(void *, vtkIdType, int) override
Default implementation raises a runtime error.
void SetNumberOfTuples(vtkIdType number) override
Set the number of tuples (a component group) in the array.
void SetTuple(vtkIdType tupleIdx, const float *tuple) override
Set the data tuple at tupleIdx.
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph *>::edge_descriptor e, vtkGraph *)
A atomic type representing the union of many types.
Definition: vtkVariant.h:65
void SetTuple(vtkIdType tupleIdx, const double *tuple) override
Set the data tuple at tupleIdx.
int vtkTypeBool
Definition: vtkABI.h:69
int GetDataType() const override
Return the underlying data type.
void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx, vtkAbstractArray *source) override
Insert the tuple at srcTupleIdx in the source array into this array at dstTupleIdx.
void InsertVariantValue(vtkIdType valueIdx, vtkVariant value) override
Insert a value into the array from a variant.
double * GetTuple(vtkIdType tupleIdx) override
Get the data tuple at tupleIdx.
vtkIdType Capacity()
Return the capacity in typeof T units of the current array.
bool ComputeFiniteVectorValueRange(ValueType range[2])
Returns true if the range was computed.
void ComputeFiniteValueRange(ValueType range[2], int comp)
Compute the range for a specific component.
Array-Of-Structs implementation of vtkGenericDataArray.
ValueType * GetValueRange()
Get the range of array values for the 0th component in the native data type.
vtkIdType InsertNextValue(ValueType value)
Insert data at the end of the array.
list of point or cell ids
Definition: vtkIdList.h:30
vtkVariant GetVariantValue(vtkIdType valueIdx) override
Retrieve value from the array as a variant.
int GetDataTypeSize() const override
Return the size of the underlying data type.
bool AllocateTuples(vtkIdType numTuples)
Allocate space for numTuples.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
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...
vtkTemplateTypeMacro(SelfType, vtkDataArray)
virtual void FillValue(ValueType value)
Set all the values in array to value.
void * WriteVoidPointer(vtkIdType valueIdx, vtkIdType numValues) override
Default implementation raises a runtime error.
ValueType * WritePointer(vtkIdType valueIdx, vtkIdType numValues)
Default implementation raises a runtime error.
void GetTypedTuple(vtkIdType tupleIdx, ValueType *tuple) const
Copy the tuple at tupleIdx into tuple.
Abstract superclass to iterate over elements in an vtkAbstractArray.
void ClearLookup() override
Delete the associated fast lookup data structure on this array, if it exists.
#define VTK_SIZEHINT(...)
void GetTuples(vtkIdList *tupleIds, vtkAbstractArray *output) override
Given a list of tuple ids, return an array of tuples.
vtkArrayIterator * NewIterator() override
Subclasses must override this method and provide the right kind of templated vtkArrayIteratorTemplate...
void RemoveTuple(vtkIdType tupleIdx) override
Removes a tuple at the given index.
void GetValueRange(ValueType range[2])
~vtkGenericDataArray() override
void DataChanged() override
Tell the array explicitly that the data has changed.
#define VTK_NEWINSTANCE
void * GetVoidPointer(vtkIdType valueIdx) override
Default implementation raises a runtime error.
void SetTypedTuple(vtkIdType tupleIdx, const ValueType *tuple)
Set this array&#39;s tuple at tupleIdx to the values in tuple.
std::vector< ValueType > LegacyValueRange
bool ComputeScalarValueRange(ValueType *ranges)
Computes the range for each component of an array, the length of ranges must be two times the number ...
double GetComponent(vtkIdType tupleIdx, int compIdx) override
Return the data component at the location specified by tupleIdx and compIdx.
vtkIdType LookupValue(vtkVariant value) override
Return the value indices where a specific value appears.
std::vector< double > LegacyTuple
virtual void FillTypedComponent(int compIdx, ValueType value)
Set component comp of all tuples to value.
bool HasStandardMemoryLayout() const override
Returns true if this array uses the standard memory layout defined in the VTK user guide...
void InsertTypedTuple(vtkIdType tupleIdx, const ValueType *t)
Insert (memory allocation performed) the tuple t at tupleIdx.
void ComputeValueRange(ValueType range[2], int comp)
Compute the range for a specific component.
void InsertComponent(vtkIdType tupleIdx, int compIdx, double value) override
Insert value at the location specified by tupleIdx and compIdx.
bool ReallocateTuples(vtkIdType numTuples)
Allocate space for numTuples.
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...
virtual vtkIdType LookupTypedValue(ValueType value)
#define VTK_EXPECTS(x)
void SetNumberOfComponents(int num) override
Set/Get the dimension (n) of the components.
vtkTypeBool Resize(vtkIdType numTuples) override
Resize the array to the requested number of tuples and preserve data.
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, starting at the dstStart location.
Template defining traits of native types used by VTK.
Definition: vtkTypeTraits.h:30
bool DoComputeVectorRange(A *, R[2], vtkAllValues)
bool EnsureAccessToTuple(vtkIdType tupleIdx)
void InsertTypedComponent(vtkIdType tupleIdx, int compIdx, ValueType val)
Insert (memory allocation performed) the value at the specified tuple and component location...