VTK  9.3.1
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
34 #ifndef vtkFieldData_h
35 #define vtkFieldData_h
36 
37 #include "vtkCommonDataModelModule.h" // For export macro
38 #include "vtkObject.h"
39 
40 #include "vtkAbstractArray.h" // Needed for inline methods.
41 
42 #include <array> // For CachedGhostRangeType
43 #include <tuple> // For CachedGhostRangeType
44 #include <vector> // For list indices
45 
46 VTK_ABI_NAMESPACE_BEGIN
47 class vtkIdList;
48 class vtkDoubleArray;
50 
51 class VTKCOMMONDATAMODEL_EXPORT vtkFieldData : public vtkObject
52 {
53 public:
54  static vtkFieldData* New();
55  static vtkFieldData* ExtendedNew();
56 
57  vtkTypeMacro(vtkFieldData, vtkObject);
58  void PrintSelf(ostream& os, vtkIndent indent) override;
59 
64  virtual void Initialize();
65 
70  vtkTypeBool Allocate(vtkIdType sz, vtkIdType ext = 1000);
71 
77  void CopyStructure(vtkFieldData*);
78 
88  void AllocateArrays(int num);
89 
96  int GetNumberOfArrays() { return this->NumberOfActiveArrays; }
97 
104  int AddArray(vtkAbstractArray* array);
105 
109  void NullData(vtkIdType id);
110 
112 
115  virtual void RemoveArray(const char* name);
116 
120  virtual void RemoveArray(int index);
122 
131  vtkDataArray* GetArray(int i);
132 
143  vtkDataArray* GetArray(const char* arrayName, int& index);
144 
146 
155  vtkDataArray* GetArray(const char* arrayName)
156  {
157  int i;
158  return this->GetArray(arrayName, i);
159  }
161 
167  vtkAbstractArray* GetAbstractArray(int i);
168 
175  vtkAbstractArray* GetAbstractArray(const char* arrayName, int& index);
176 
178 
183  vtkAbstractArray* GetAbstractArray(const char* arrayName)
184  {
185  int i;
186  return this->GetAbstractArray(arrayName, i);
187  }
189 
191 
194  vtkTypeBool HasArray(const char* name)
195  {
196  int i;
197  vtkAbstractArray* array = this->GetAbstractArray(name, i);
198  return array ? 1 : 0;
199  }
201 
203 
208  const char* GetArrayName(int i)
209  {
210  vtkAbstractArray* da = this->GetAbstractArray(i);
211  return da ? da->GetName() : nullptr;
212  }
214 
219  virtual void PassData(vtkFieldData* fd);
220 
230  void CopyFieldOn(const char* name) { this->CopyFieldOnOff(name, 1); }
231  void CopyFieldOff(const char* name) { this->CopyFieldOnOff(name, 0); }
232 
242  virtual void CopyAllOn(int unused = 0);
243 
253  virtual void CopyAllOff(int unused = 0);
254 
258  virtual void DeepCopy(vtkFieldData* da);
259 
263  virtual void ShallowCopy(vtkFieldData* da);
264 
268  void Squeeze();
269 
274  void Reset();
275 
282  virtual unsigned long GetActualMemorySize();
283 
287  vtkMTimeType GetMTime() override;
288 
298  void GetField(vtkIdList* ptId, vtkFieldData* f);
299 
307  int GetArrayContainingComponent(int i, int& arrayComp);
308 
318  int GetNumberOfComponents();
319 
330  vtkIdType GetNumberOfTuples();
331 
340  void SetNumberOfTuples(vtkIdType number);
341 
347  void SetTuple(vtkIdType i, vtkIdType j, vtkFieldData* source);
348 
353  void InsertTuple(vtkIdType i, vtkIdType j, vtkFieldData* source);
354 
360  vtkIdType InsertNextTuple(vtkIdType j, vtkFieldData* source);
361 
363 
382  bool GetRange(const char* name, double range[2], int comp = 0);
383  bool GetRange(int index, double range[2], int comp = 0);
384  bool GetFiniteRange(const char* name, double range[2], int comp = 0);
385  bool GetFiniteRange(int index, double range[2], int comp = 0);
387 
389 
400  vtkGetMacro(GhostsToSkip, unsigned char);
401  virtual void SetGhostsToSkip(unsigned char);
403 
408  bool HasAnyGhostBitSet(int bitFlag);
409 
418  vtkGetObjectMacro(GhostArray, vtkUnsignedCharArray);
419 
420 protected:
421  vtkFieldData();
422  ~vtkFieldData() override;
423 
427 
431  void SetArray(int i, vtkAbstractArray* array);
432 
436  virtual void InitializeFields();
437 
439  {
440  char* ArrayName;
441  int IsCopied;
442  };
443 
444  CopyFieldFlag* CopyFieldFlags; // the names of fields not to be copied
445  int NumberOfFieldFlags; // the number of fields not to be copied
446  void CopyFieldOnOff(const char* name, int onOff);
447  void ClearFieldFlags();
448  int FindFlag(const char* field);
449  int GetFlag(const char* field);
450  void CopyFlags(const vtkFieldData* source);
453 
454  /*
455  * This tuple holds: [array time stamp, ghost array time stamp, cached ranges].
456  * Those time stamps are used to decide whether the cached range should be recomputed or not.
457  * when requesting the range of an array.
458  *
459  * When there is no ghost array, the ghost array time stamp is defined as equal to 0.
460  */
461  using CachedGhostRangeType = std::tuple<vtkMTimeType, vtkMTimeType, std::vector<double>>;
462  unsigned char GhostsToSkip;
464 
466 
473  std::vector<std::array<CachedGhostRangeType, 2>> Ranges;
474  std::vector<std::array<CachedGhostRangeType, 2>> FiniteRanges;
476 
477 private:
478  vtkFieldData(const vtkFieldData&) = delete;
479  void operator=(const vtkFieldData&) = delete;
480 
481 public:
482  class VTKCOMMONDATAMODEL_EXPORT BasicIterator
483  {
484  public:
485  BasicIterator() = default;
487  BasicIterator(const int* list, unsigned int listSize);
488  BasicIterator& operator=(const BasicIterator& source);
489  virtual ~BasicIterator() = default;
490  void PrintSelf(ostream& os, vtkIndent indent);
491 
492  int GetListSize() const { return static_cast<int>(this->List.size()); }
493  int GetCurrentIndex() { return this->List[this->Position]; }
495  {
496  this->Position = -1;
497  return this->NextIndex();
498  }
499  int End() const { return (this->Position >= static_cast<int>(this->List.size())); }
500  int NextIndex()
501  {
502  this->Position++;
503  return (this->End() ? -1 : this->List[this->Position]);
504  }
505 
506  // Support C++ range-for loops; e.g, code like
507  // "for (const auto& i : basicIterator)".
508  std::vector<int>::const_iterator begin() { return this->List.begin(); }
509  std::vector<int>::const_iterator end() { return this->List.end(); }
510 
511  protected:
512  std::vector<int> List;
513  int Position;
514  };
515 
516  class VTKCOMMONDATAMODEL_EXPORT Iterator : public BasicIterator
517  {
518  public:
519  Iterator(const Iterator& source);
520  Iterator& operator=(const Iterator& source);
521  ~Iterator() override;
522  Iterator(vtkFieldData* dsa, const int* list = nullptr, unsigned int listSize = 0);
523 
525  {
526  this->Position = -1;
527  return this->Next();
528  }
529 
531  {
532  this->Position++;
533  if (this->End())
534  {
535  return nullptr;
536  }
537 
538  // vtkFieldData::GetArray() can return null, which implies that
539  // a the array at the given index in not a vtkDataArray subclass.
540  // This iterator skips such arrays.
541  vtkDataArray* cur = Fields->GetArray(this->List[this->Position]);
542  return (cur ? cur : this->Next());
543  }
544 
545  void DetachFieldData();
546 
547  protected:
549  int Detached;
550  };
551 };
552 
553 VTK_ABI_NAMESPACE_END
554 #endif
vtkFieldData * Fields
Definition: vtkFieldData.h:548
std::vector< int > List
Definition: vtkFieldData.h:512
vtkUnsignedCharArray * GhostArray
Definition: vtkFieldData.h:463
vtkDataArray * GetArray(const char *arrayName)
Not recommended for use.
Definition: vtkFieldData.h:155
std::tuple< vtkMTimeType, vtkMTimeType, std::vector< double >> CachedGhostRangeType
Definition: vtkFieldData.h:461
abstract base class for most VTK objects
Definition: vtkObject.h:51
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:270
Abstract superclass for all arrays.
CopyFieldFlag * CopyFieldFlags
Definition: vtkFieldData.h:444
int vtkIdType
Definition: vtkType.h:315
std::vector< std::array< CachedGhostRangeType, 2 > > Ranges
Ranges and FiniteRanges store cached ranges for arrays stored in this field data. ...
Definition: vtkFieldData.h:473
void CopyFieldOn(const char *name)
Turn on/off the copying of the field specified by name.
Definition: vtkFieldData.h:230
dynamic, self-adjusting array of double
BasicIterator & operator=(const BasicIterator &source)
int vtkTypeBool
Definition: vtkABI.h:64
std::vector< std::array< CachedGhostRangeType, 2 > > FiniteRanges
Ranges and FiniteRanges store cached ranges for arrays stored in this field data. ...
Definition: vtkFieldData.h:474
unsigned char GhostsToSkip
Definition: vtkFieldData.h:462
a simple class to control print indentation
Definition: vtkIndent.h:28
vtkAbstractArray * GetAbstractArray(const char *arrayName)
Return the array with the name given.
Definition: vtkFieldData.h:183
list of point or cell ids
Definition: vtkIdList.h:22
std::vector< int >::const_iterator begin()
Definition: vtkFieldData.h:508
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:44
virtual vtkMTimeType GetMTime()
Return this object's modified time.
virtual char * GetName()
Set/get array's name.
int NumberOfFieldFlags
Definition: vtkFieldData.h:445
const char * GetArrayName(int i)
Get the name of ith array.
Definition: vtkFieldData.h:208
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
dynamic, self-adjusting array of unsigned char
int NumberOfActiveArrays
Definition: vtkFieldData.h:425
void CopyFieldOff(const char *name)
Definition: vtkFieldData.h:231
std::vector< int >::const_iterator end()
Definition: vtkFieldData.h:509
vtkTypeBool HasArray(const char *name)
Return 1 if an array with the given name could be found.
Definition: vtkFieldData.h:194
vtkAbstractArray ** Data
Definition: vtkFieldData.h:426
vtkDataArray * Begin()
Definition: vtkFieldData.h:524
int GetNumberOfArrays()
Get the number of arrays of data available.
Definition: vtkFieldData.h:96
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on...
vtkDataArray * Next()
Definition: vtkFieldData.h:530
represent and manipulate fields of data
Definition: vtkFieldData.h:51