VTK  9.3.20240412
vtkFieldData.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
143 #ifndef vtkFieldData_h
144 #define vtkFieldData_h
145 
146 #include "vtkCommonDataModelModule.h" // For export macro
147 #include "vtkObject.h"
148 #include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
149 
150 #include "vtkAbstractArray.h" // Needed for inline methods.
151 
152 #include <array> // For CachedGhostRangeType
153 #include <tuple> // For CachedGhostRangeType
154 #include <vector> // For list indices
155 
156 VTK_ABI_NAMESPACE_BEGIN
157 class vtkIdList;
158 class vtkDoubleArray;
160 
161 class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALAUTO vtkFieldData : public vtkObject
162 {
163 public:
164  static vtkFieldData* New();
166 
167  vtkTypeMacro(vtkFieldData, vtkObject);
168  void PrintSelf(ostream& os, vtkIndent indent) override;
169 
174  virtual void Initialize();
175 
181 
188 
198  void AllocateArrays(int num);
199 
206  int GetNumberOfArrays() { return this->NumberOfActiveArrays; }
207 
215 
219  void NullData(vtkIdType id);
220 
222 
225  virtual void RemoveArray(const char* name);
226 
230  virtual void RemoveArray(int index);
232 
242 
253  vtkDataArray* GetArray(const char* arrayName, int& index);
254 
256 
265  vtkDataArray* GetArray(const char* arrayName)
266  {
267  int i;
268  return this->GetArray(arrayName, i);
269  }
271 
278 
285  vtkAbstractArray* GetAbstractArray(const char* arrayName, int& index);
286 
288 
293  vtkAbstractArray* GetAbstractArray(const char* arrayName)
294  {
295  int i;
296  return this->GetAbstractArray(arrayName, i);
297  }
299 
301 
304  vtkTypeBool HasArray(const char* name)
305  {
306  int i;
307  vtkAbstractArray* array = this->GetAbstractArray(name, i);
308  return array ? 1 : 0;
309  }
311 
313 
318  const char* GetArrayName(int i)
319  {
320  vtkAbstractArray* da = this->GetAbstractArray(i);
321  return da ? da->GetName() : nullptr;
322  }
324 
329  virtual void PassData(vtkFieldData* fd);
330 
340  void CopyFieldOn(const char* name) { this->CopyFieldOnOff(name, 1); }
341  void CopyFieldOff(const char* name) { this->CopyFieldOnOff(name, 0); }
342 
352  virtual void CopyAllOn(int unused = 0);
353 
363  virtual void CopyAllOff(int unused = 0);
364 
368  virtual void DeepCopy(vtkFieldData* da);
369 
373  virtual void ShallowCopy(vtkFieldData* da);
374 
378  void Squeeze();
379 
384  void Reset();
385 
392  virtual unsigned long GetActualMemorySize();
393 
397  vtkMTimeType GetMTime() override;
398 
408  void GetField(vtkIdList* ptId, vtkFieldData* f);
409 
417  int GetArrayContainingComponent(int i, int& arrayComp);
418 
429 
441 
451 
458 
464 
471 
473 
492  bool GetRange(const char* name, double range[2], int comp = 0);
493  bool GetRange(int index, double range[2], int comp = 0);
494  bool GetFiniteRange(const char* name, double range[2], int comp = 0);
495  bool GetFiniteRange(int index, double range[2], int comp = 0);
497 
499 
510  vtkGetMacro(GhostsToSkip, unsigned char);
511  virtual void SetGhostsToSkip(unsigned char);
513 
518  bool HasAnyGhostBitSet(int bitFlag);
519 
528  vtkGetObjectMacro(GhostArray, vtkUnsignedCharArray);
529 
530 protected:
532  ~vtkFieldData() override;
533 
537 
541  void SetArray(int i, vtkAbstractArray* array);
542 
546  virtual void InitializeFields();
547 
549  {
550  char* ArrayName;
551  int IsCopied;
552  };
553 
554  CopyFieldFlag* CopyFieldFlags; // the names of fields not to be copied
555  int NumberOfFieldFlags; // the number of fields not to be copied
556  void CopyFieldOnOff(const char* name, int onOff);
558  int FindFlag(const char* field);
559  int GetFlag(const char* field);
563 
564  /*
565  * This tuple holds: [array time stamp, ghost array time stamp, cached ranges].
566  * Those time stamps are used to decide whether the cached range should be recomputed or not.
567  * when requesting the range of an array.
568  *
569  * When there is no ghost array, the ghost array time stamp is defined as equal to 0.
570  */
571  using CachedGhostRangeType = std::tuple<vtkMTimeType, vtkMTimeType, std::vector<double>>;
572  unsigned char GhostsToSkip;
574 
576 
583  std::vector<std::array<CachedGhostRangeType, 2>> Ranges;
584  std::vector<std::array<CachedGhostRangeType, 2>> FiniteRanges;
586 
587 private:
588  vtkFieldData(const vtkFieldData&) = delete;
589  void operator=(const vtkFieldData&) = delete;
590 
591 public:
592  class VTKCOMMONDATAMODEL_EXPORT BasicIterator
593  {
594  public:
595  BasicIterator() = default;
597  BasicIterator(const int* list, unsigned int listSize);
599  virtual ~BasicIterator() = default;
600  void PrintSelf(ostream& os, vtkIndent indent);
601 
602  int GetListSize() const { return static_cast<int>(this->List.size()); }
603  int GetCurrentIndex() { return this->List[this->Position]; }
605  {
606  this->Position = -1;
607  return this->NextIndex();
608  }
609  int End() const { return (this->Position >= static_cast<int>(this->List.size())); }
610  int NextIndex()
611  {
612  this->Position++;
613  return (this->End() ? -1 : this->List[this->Position]);
614  }
615 
616  // Support C++ range-for loops; e.g, code like
617  // "for (const auto& i : basicIterator)".
618  std::vector<int>::const_iterator begin() { return this->List.begin(); }
619  std::vector<int>::const_iterator end() { return this->List.end(); }
620 
621  protected:
622  std::vector<int> List;
623  int Position;
624  };
625 
626  class VTKCOMMONDATAMODEL_EXPORT Iterator : public BasicIterator
627  {
628  public:
631  ~Iterator() override;
632  Iterator(vtkFieldData* dsa, const int* list = nullptr, unsigned int listSize = 0);
633 
635  {
636  this->Position = -1;
637  return this->Next();
638  }
639 
641  {
642  this->Position++;
643  if (this->End())
644  {
645  return nullptr;
646  }
647 
648  // vtkFieldData::GetArray() can return null, which implies that
649  // a the array at the given index in not a vtkDataArray subclass.
650  // This iterator skips such arrays.
651  vtkDataArray* cur = Fields->GetArray(this->List[this->Position]);
652  return (cur ? cur : this->Next());
653  }
654 
656 
657  protected:
659  int Detached;
660  };
661 };
662 
663 VTK_ABI_NAMESPACE_END
664 #endif
Abstract superclass for all arrays.
virtual char * GetName()
Set/get array's name.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:155
dynamic, self-adjusting array of double
BasicIterator(const BasicIterator &source)
std::vector< int >::const_iterator begin()
Definition: vtkFieldData.h:618
BasicIterator(const int *list, unsigned int listSize)
BasicIterator & operator=(const BasicIterator &source)
virtual ~BasicIterator()=default
void PrintSelf(ostream &os, vtkIndent indent)
std::vector< int > List
Definition: vtkFieldData.h:622
std::vector< int >::const_iterator end()
Definition: vtkFieldData.h:619
vtkDataArray * Begin()
Definition: vtkFieldData.h:634
Iterator(vtkFieldData *dsa, const int *list=nullptr, unsigned int listSize=0)
vtkFieldData * Fields
Definition: vtkFieldData.h:658
Iterator(const Iterator &source)
Iterator & operator=(const Iterator &source)
vtkDataArray * Next()
Definition: vtkFieldData.h:640
represent and manipulate fields of data
Definition: vtkFieldData.h:162
vtkTypeBool Allocate(vtkIdType sz, vtkIdType ext=1000)
Allocate data for each array.
int GetFlag(const char *field)
vtkAbstractArray ** Data
Definition: vtkFieldData.h:536
static vtkFieldData * ExtendedNew()
int GetNumberOfArrays()
Get the number of arrays of data available.
Definition: vtkFieldData.h:206
virtual void DeepCopy(vtkFieldData *da)
Copy a field by creating new data arrays (i.e., duplicate storage).
int AddArray(vtkAbstractArray *array)
Add an array to the array list.
void CopyFlags(const vtkFieldData *source)
~vtkFieldData() override
static vtkFieldData * New()
void Reset()
Resets each data array in the field (Reset() does not release memory but it makes the arrays look lik...
void InsertTuple(vtkIdType i, vtkIdType j, vtkFieldData *source)
Insert the jth tuple in source field data at the ith location.
bool GetFiniteRange(const char *name, double range[2], int comp=0)
Computes the range of the input data array (specified through its name or the index in this field dat...
bool HasAnyGhostBitSet(int bitFlag)
Helper function that tests if any of the values in ghost array has been set.
std::vector< std::array< CachedGhostRangeType, 2 > > FiniteRanges
Ranges and FiniteRanges store cached ranges for arrays stored in this field data.
Definition: vtkFieldData.h:584
virtual void SetGhostsToSkip(unsigned char)
Set / Get the binary mask filtering out certain types of ghosts when calling GetRange.
void AllocateArrays(int num)
AllocateArrays actually sets the number of vtkAbstractArray pointers in the vtkFieldData object,...
virtual void RemoveArray(int index)
Remove an array (with the given index) from the list of arrays.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual void InitializeFields()
Release all data but do not delete object.
bool GetRange(const char *name, double range[2], int comp=0)
Computes the range of the input data array (specified through its name or the index in this field dat...
int GetNumberOfComponents()
Get the number of components in the field.
vtkMTimeType GetMTime() override
Check object's components for modified times.
std::vector< std::array< CachedGhostRangeType, 2 > > Ranges
Ranges and FiniteRanges store cached ranges for arrays stored in this field data.
Definition: vtkFieldData.h:583
std::tuple< vtkMTimeType, vtkMTimeType, std::vector< double > > CachedGhostRangeType
Definition: vtkFieldData.h:571
virtual void RemoveArray(const char *name)
Remove an array (with the given name) from the list of arrays.
unsigned char GhostsToSkip
Definition: vtkFieldData.h:572
const char * GetArrayName(int i)
Get the name of ith array.
Definition: vtkFieldData.h:318
void SetTuple(vtkIdType i, vtkIdType j, vtkFieldData *source)
Set the jth tuple in source field data at the ith location.
virtual void CopyAllOn(int unused=0)
Turn on copying of all data.
CopyFieldFlag * CopyFieldFlags
Definition: vtkFieldData.h:554
void SetNumberOfTuples(vtkIdType number)
Set the number of tuples for each data array in the field.
vtkDataArray * GetArray(int i)
Not recommended for use.
vtkAbstractArray * GetAbstractArray(const char *arrayName)
Return the array with the name given.
Definition: vtkFieldData.h:293
virtual unsigned long GetActualMemorySize()
Return the memory in kibibytes (1024 bytes) consumed by this field data.
int GetArrayContainingComponent(int i, int &arrayComp)
Return the array containing the ith component of the field.
void ClearFieldFlags()
int FindFlag(const char *field)
vtkDataArray * GetArray(const char *arrayName)
Not recommended for use.
Definition: vtkFieldData.h:265
virtual void Initialize()
Release all data but do not delete object.
virtual void CopyAllOff(int unused=0)
Turn off copying of all data.
bool GetRange(int index, double range[2], int comp=0)
Computes the range of the input data array (specified through its name or the index in this field dat...
virtual void ShallowCopy(vtkFieldData *da)
Copy a field by reference counting the data arrays.
void CopyFieldOn(const char *name)
Turn on/off the copying of the field specified by name.
Definition: vtkFieldData.h:340
bool GetFiniteRange(int index, double range[2], int comp=0)
Computes the range of the input data array (specified through its name or the index in this field dat...
vtkUnsignedCharArray * GhostArray
Definition: vtkFieldData.h:573
void CopyFieldOff(const char *name)
Definition: vtkFieldData.h:341
vtkAbstractArray * GetAbstractArray(int i)
Returns the ith array in the field.
vtkIdType GetNumberOfTuples()
Get the number of tuples in the field.
void Squeeze()
Squeezes each data array in the field (Squeeze() reclaims unused memory.)
vtkIdType InsertNextTuple(vtkIdType j, vtkFieldData *source)
Insert the jth tuple in source field data at the end of the tuple matrix.
void NullData(vtkIdType id)
Sets every vtkDataArray at index id to a null tuple.
void GetField(vtkIdList *ptId, vtkFieldData *f)
Get a field from a list of ids.
void CopyFieldOnOff(const char *name, int onOff)
int NumberOfActiveArrays
Definition: vtkFieldData.h:535
virtual void PassData(vtkFieldData *fd)
Pass entire arrays of input data through to output.
vtkTypeBool HasArray(const char *name)
Return 1 if an array with the given name could be found.
Definition: vtkFieldData.h:304
void CopyStructure(vtkFieldData *)
Copy data array structure from a given field.
vtkDataArray * GetArray(const char *arrayName, int &index)
Not recommended for use.
void SetArray(int i, vtkAbstractArray *array)
Set an array to define the field.
int NumberOfFieldFlags
Definition: vtkFieldData.h:555
vtkAbstractArray * GetAbstractArray(const char *arrayName, int &index)
Return the array with the name given.
list of point or cell ids
Definition: vtkIdList.h:133
a simple class to control print indentation
Definition: vtkIndent.h:108
abstract base class for most VTK objects
Definition: vtkObject.h:162
dynamic, self-adjusting array of unsigned char
@ field
Definition: vtkX3D.h:177
@ range
Definition: vtkX3D.h:238
@ name
Definition: vtkX3D.h:219
@ index
Definition: vtkX3D.h:246
int vtkTypeBool
Definition: vtkABI.h:64
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
int vtkIdType
Definition: vtkType.h:315
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:270
#define VTK_MARSHALAUTO