VTK  9.1.0
vtkDataSetAttributes.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkDataSetAttributes.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 =========================================================================*/
51 #ifndef vtkDataSetAttributes_h
52 #define vtkDataSetAttributes_h
53 
54 #include "vtkCommonDataModelModule.h" // For export macro
55 #include "vtkDataSetAttributesFieldList.h" // for vtkDataSetAttributesFieldList
56 #include "vtkFieldData.h"
57 
58 class vtkLookupTable;
59 
60 class VTKCOMMONDATAMODEL_EXPORT vtkDataSetAttributes : public vtkFieldData
61 {
62 public:
68 
70  void PrintSelf(ostream& os, vtkIndent indent) override;
71 
76  void Initialize() override;
77 
82  virtual void Update() {}
83 
84  // -- shallow and deep copy -----------------------------------------------
85 
91  void DeepCopy(vtkFieldData* pd) override;
92 
97  void ShallowCopy(vtkFieldData* pd) override;
98 
99  // -- attribute types -----------------------------------------------------
100 
101  // Always keep NUM_ATTRIBUTES as the last entry
103  {
104  SCALARS = 0,
105  VECTORS = 1,
106  NORMALS = 2,
107  TCOORDS = 3,
108  TENSORS = 4,
109  GLOBALIDS = 5,
110  PEDIGREEIDS = 6,
111  EDGEFLAG = 7,
112  TANGENTS = 8,
113  RATIONALWEIGHTS = 9,
114  HIGHERORDERDEGREES = 10,
115  NUM_ATTRIBUTES
116  };
117 
119  {
122  NOLIMIT
123  };
124 
125  // ----------- ghost points and ghost cells -------------------------------------------
126  // The following bit fields are consistent with VisIt ghost zones specification
127  // For details, see http://www.visitusers.org/index.php?title=Representing_ghost_data
128 
130  {
131  DUPLICATECELL = 1, // the cell is present on multiple processors
132  HIGHCONNECTIVITYCELL = 2, // the cell has more neighbors than in a regular mesh
133  LOWCONNECTIVITYCELL = 4, // the cell has less neighbors than in a regular mesh
134  REFINEDCELL = 8, // other cells are present that refines it.
135  EXTERIORCELL = 16, // the cell is on the exterior of the data set
136  HIDDENCELL =
137  32 // the cell is needed to maintain connectivity, but the data values should be ignored.
138  };
139 
141  {
142  DUPLICATEPOINT = 1, // the cell is present on multiple processors
143  HIDDENPOINT =
144  2 // the point is needed to maintain connectivity, but the data values should be ignored.
145  };
146 
147  // A vtkDataArray with this name must be of type vtkUnsignedCharArray.
148  // Each value must be assigned according to the bit fields described in
149  // PointGhostTypes or CellGhostType
150  static const char* GhostArrayName() { return "vtkGhostType"; }
151 
152  //-----------------------------------------------------------------------------------
153 
155 
159  int SetActiveScalars(const char* name);
162 
164 
168  int SetActiveVectors(const char* name);
171 
173 
177  int SetActiveNormals(const char* name);
180 
182 
186  int SetActiveTangents(const char* name);
189 
191 
195  int SetActiveTCoords(const char* name);
198 
200 
204  int SetActiveTensors(const char* name);
207 
209 
213  int SetActiveGlobalIds(const char* name);
216 
218 
222  int SetActivePedigreeIds(const char* name);
225 
227 
231  int SetActiveRationalWeights(const char* name);
234 
236 
243 
245 
250  vtkDataArray* GetScalars(const char* name);
251  vtkDataArray* GetVectors(const char* name);
252  vtkDataArray* GetNormals(const char* name);
254  vtkDataArray* GetTCoords(const char* name);
255  vtkDataArray* GetTensors(const char* name);
261 
277  int SetActiveAttribute(const char* name, int attributeType);
278 
282  int SetActiveAttribute(int index, int attributeType);
283 
288  void GetAttributeIndices(int* indexArray);
289 
296  int IsArrayAnAttribute(int idx);
297 
320  int SetAttribute(vtkAbstractArray* aa, int attributeType);
321 
328  vtkDataArray* GetAttribute(int attributeType);
329 
338 
340 
344  void RemoveArray(int index) override;
346 
348 
352  static const char* GetAttributeTypeAsString(int attributeType);
353  static const char* GetLongAttributeTypeAsString(int attributeType);
355 
356  // -- attribute copy properties ------------------------------------------
357 
359  {
360  COPYTUPLE = 0,
361  INTERPOLATE = 1,
362  PASSDATA = 2,
363  ALLCOPY // all of the above
364  };
365 
387  void SetCopyAttribute(int index, int value, int ctype = ALLCOPY);
388 
393  int GetCopyAttribute(int index, int ctype);
394 
396  void SetCopyScalars(vtkTypeBool i, int ctype = ALLCOPY);
397  vtkTypeBool GetCopyScalars(int ctype = ALLCOPY);
398  vtkBooleanMacro(CopyScalars, vtkTypeBool);
399 
401  void SetCopyVectors(vtkTypeBool i, int ctype = ALLCOPY);
402  vtkTypeBool GetCopyVectors(int ctype = ALLCOPY);
403  vtkBooleanMacro(CopyVectors, vtkTypeBool);
404 
406  void SetCopyNormals(vtkTypeBool i, int ctype = ALLCOPY);
407  vtkTypeBool GetCopyNormals(int ctype = ALLCOPY);
408  vtkBooleanMacro(CopyNormals, vtkTypeBool);
409 
411  void SetCopyTangents(vtkTypeBool i, int ctype = ALLCOPY);
412  vtkTypeBool GetCopyTangents(int ctype = ALLCOPY);
413  vtkBooleanMacro(CopyTangents, vtkTypeBool);
414 
416  void SetCopyTCoords(vtkTypeBool i, int ctype = ALLCOPY);
417  vtkTypeBool GetCopyTCoords(int ctype = ALLCOPY);
418  vtkBooleanMacro(CopyTCoords, vtkTypeBool);
419 
421  void SetCopyTensors(vtkTypeBool i, int ctype = ALLCOPY);
422  vtkTypeBool GetCopyTensors(int ctype = ALLCOPY);
423  vtkBooleanMacro(CopyTensors, vtkTypeBool);
424 
426  void SetCopyGlobalIds(vtkTypeBool i, int ctype = ALLCOPY);
427  vtkTypeBool GetCopyGlobalIds(int ctype = ALLCOPY);
428  vtkBooleanMacro(CopyGlobalIds, vtkTypeBool);
429 
431  void SetCopyPedigreeIds(vtkTypeBool i, int ctype = ALLCOPY);
432  vtkTypeBool GetCopyPedigreeIds(int ctype = ALLCOPY);
433  vtkBooleanMacro(CopyPedigreeIds, vtkTypeBool);
434 
436  void SetCopyRationalWeights(vtkTypeBool i, int ctype = ALLCOPY);
437  vtkTypeBool GetCopyRationalWeights(int ctype = ALLCOPY);
438  vtkBooleanMacro(CopyRationalWeights, vtkTypeBool);
439 
441  void SetCopyHigherOrderDegrees(vtkTypeBool i, int ctype = ALLCOPY);
443  vtkBooleanMacro(CopyHigherOrderDegrees, vtkTypeBool);
444 
446  void CopyAllOn(int ctype = ALLCOPY) override;
447 
449  void CopyAllOff(int ctype = ALLCOPY) override;
450 
451  // -- passthrough operations ----------------------------------------------
452 
462  void PassData(vtkFieldData* fd) override;
463 
464  // -- copytuple operations ------------------------------------------------
465 
467 
478  void CopyAllocate(vtkDataSetAttributes* pd, vtkIdType sze = 0, vtkIdType ext = 1000)
479  {
480  this->CopyAllocate(pd, sze, ext, 0);
481  }
482  void CopyAllocate(vtkDataSetAttributes* pd, vtkIdType sze, vtkIdType ext, int shallowCopyArrays);
484 
493 
503  vtkDataSetAttributes* inDsa, const int* inExt, const int* outExt, bool setSize = true);
504 
506 
516  void CopyData(vtkDataSetAttributes* fromPd, vtkIdType fromId, vtkIdType toId);
517  void CopyData(vtkDataSetAttributes* fromPd, vtkIdList* fromIds, vtkIdList* toIds);
519 
525  void CopyData(vtkDataSetAttributes* fromPd, vtkIdType dstStart, vtkIdType n, vtkIdType srcStart);
526 
528 
534  void CopyTuple(
535  vtkAbstractArray* fromData, vtkAbstractArray* toData, vtkIdType fromId, vtkIdType toId);
537  vtkAbstractArray* fromData, vtkAbstractArray* toData, vtkIdList* fromIds, vtkIdList* toIds);
538  void CopyTuples(vtkAbstractArray* fromData, vtkAbstractArray* toData, vtkIdType dstStart,
539  vtkIdType n, vtkIdType srcStart);
541 
542  // -- interpolate operations ----------------------------------------------
543 
545 
554  {
555  this->InterpolateAllocate(pd, sze, ext, 0);
556  }
558  vtkDataSetAttributes* pd, vtkIdType sze, vtkIdType ext, int shallowCopyArrays);
560 
569  vtkDataSetAttributes* fromPd, vtkIdType toId, vtkIdList* ids, double* weights);
570 
581  vtkDataSetAttributes* fromPd, vtkIdType toId, vtkIdType p1, vtkIdType p2, double t);
582 
596  vtkDataSetAttributes* from1, vtkDataSetAttributes* from2, vtkIdType id, double t);
597 
599 
600  // field list copy operations ------------------------------------------
601 
607 
615  vtkIdType fromId, vtkIdType toId);
617  vtkIdType dstStart, vtkIdType n, vtkIdType srcStart);
618 
626  vtkDataSetAttributes::FieldList& list, vtkIdType sze = 0, vtkIdType ext = 1000);
627 
635  int idx, vtkIdType toId, vtkIdList* ids, double* weights);
636 
637 protected:
640 
642  vtkIdType ext = 1000, int shallowCopyArrays = 0, bool createNewArrays = true);
643 
647  void InitializeFields() override;
648 
649  int AttributeIndices[NUM_ATTRIBUTES]; // index to attribute array in field data
650  int CopyAttributeFlags[ALLCOPY][NUM_ATTRIBUTES]; // copy flag for attribute data
651 
652  friend struct ArrayList; // Friend to base class in vtkArrayListTemplate
655 
656  static const int NumberOfAttributeComponents[NUM_ATTRIBUTES];
657  static const int AttributeLimits[NUM_ATTRIBUTES];
658  static const char AttributeNames[NUM_ATTRIBUTES][19];
659  static const char LongAttributeNames[NUM_ATTRIBUTES][42];
660 
661 private:
662  static int CheckNumberOfComponents(vtkAbstractArray* da, int attributeType);
663 
664  vtkFieldData::BasicIterator ComputeRequiredArrays(vtkDataSetAttributes* pd, int ctype);
665 
666 private:
668  void operator=(const vtkDataSetAttributes&) = delete;
669 
671 };
672 
673 #endif
Abstract superclass for all arrays.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
helps manage arrays from multiple vtkDataSetAttributes.
represent and manipulate attribute data in a dataset
vtkDataArray * GetScalars(const char *name)
This will first look for an array with the correct name.
vtkTypeBool GetCopyPedigreeIds(int ctype=ALLCOPY)
static const char * GhostArrayName()
void PassData(vtkFieldData *fd) override
Pass entire arrays of input data through to output.
virtual void Update()
Attributes have a chance to bring themselves up to date; right now this is ignored.
vtkDataArray * GetTensors()
Set/Get the tensor data.
int SetActiveTangents(const char *name)
Set/get the tangent data.
int SetGlobalIds(vtkDataArray *da)
Set/Get the global id data.
void InterpolateEdge(vtkDataSetAttributes *fromPd, vtkIdType toId, vtkIdType p1, vtkIdType p2, double t)
Interpolate data from the two points p1,p2 (forming an edge) and an interpolation factor,...
void CopyAllocate(vtkDataSetAttributes *pd, vtkIdType sze, vtkIdType ext, int shallowCopyArrays)
Allocates point data for point-by-point (or cell-by-cell) copy operation.
vtkDataArray * GetNormals(const char *name)
This will first look for an array with the correct name.
void Initialize() override
Initialize all of the object's data to nullptr Also, clear the copy flags.
int GetCopyAttribute(int index, int ctype)
Get the attribute copy flag for copy operation ctype of attribute index.
vtkDataArray * GetVectors(const char *name)
This will first look for an array with the correct name.
vtkFieldData::BasicIterator RequiredArrays
vtkDataArray * GetRationalWeights()
Set/Get the rational weights data.
vtkTypeBool GetCopyScalars(int ctype=ALLCOPY)
int SetActiveAttribute(int index, int attributeType)
Make the array with the given index the active attribute.
void SetCopyAttribute(int index, int value, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
~vtkDataSetAttributes() override
int SetHigherOrderDegrees(vtkDataArray *da)
Set/Get the rational degrees data.
int SetActiveNormals(const char *name)
Set/get the normal data.
void SetCopyNormals(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
void InterpolateAllocate(vtkDataSetAttributes *pd, vtkIdType sze=0, vtkIdType ext=1000)
Initialize point interpolation method.
int SetActiveHigherOrderDegrees(const char *name)
Set/Get the rational degrees data.
int SetScalars(vtkDataArray *da)
Set/Get the scalar data.
vtkAbstractArray * GetAbstractAttribute(int attributeType)
Return an attribute given the attribute type (see vtkDataSetAttributes::AttributeTypes).
vtkDataArray * GetTangents(const char *name)
This will first look for an array with the correct name.
void SetCopyTCoords(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
void InterpolatePoint(vtkDataSetAttributes::FieldList &list, vtkDataSetAttributes *fromPd, int idx, vtkIdType toId, vtkIdList *ids, double *weights)
Interpolate data set attributes from other data set attributes given cell or point ids and associated...
vtkAbstractArray * GetPedigreeIds(const char *name)
This will first look for an array with the correct name.
int SetActiveTCoords(const char *name)
Set/Get the texture coordinate data.
vtkDataArray * GetTensors(const char *name)
This will first look for an array with the correct name.
void SetCopyTangents(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
vtkTypeBool GetCopyVectors(int ctype=ALLCOPY)
vtkTypeBool GetCopyNormals(int ctype=ALLCOPY)
void CopyTuples(vtkAbstractArray *fromData, vtkAbstractArray *toData, vtkIdList *fromIds, vtkIdList *toIds)
Copy a tuple (or set of tuples) of data from one data array to another.
void InterpolatePoint(vtkDataSetAttributes *fromPd, vtkIdType toId, vtkIdList *ids, double *weights)
Interpolate data set attributes from other data set attributes given cell or point ids and associated...
void InterpolateAllocate(vtkDataSetAttributes::FieldList &list, vtkIdType sze=0, vtkIdType ext=1000)
A special form of InterpolateAllocate() to be used with FieldLists.
void SetCopyPedigreeIds(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
void InitializeFields() override
Initialize all of the object's data to nullptr.
int SetActiveGlobalIds(const char *name)
Set/Get the global id data.
void SetupForCopy(vtkDataSetAttributes *pd)
Create a mapping between the input attributes and this object so that methods like CopyData() and Cop...
int SetActiveScalars(const char *name)
Set/Get the scalar data.
void CopyData(vtkDataSetAttributes *fromPd, vtkIdType dstStart, vtkIdType n, vtkIdType srcStart)
Copy n consecutive attributes starting at srcStart from fromPd to this container, starting at the dst...
vtkDataArray * GetNormals()
Set/get the normal data.
vtkDataArray * GetHigherOrderDegrees(const char *name)
This will first look for an array with the correct name.
int SetNormals(vtkDataArray *da)
Set/get the normal data.
void InterpolateTime(vtkDataSetAttributes *from1, vtkDataSetAttributes *from2, vtkIdType id, double t)
Interpolate data from the same id (point or cell) at different points in time (parameter t).
void CopyData(vtkDataSetAttributes::FieldList &list, vtkDataSetAttributes *dsa, int idx, vtkIdType fromId, vtkIdType toId)
Special forms of CopyData() to be used with FieldLists.
void CopyAllOn(int ctype=ALLCOPY) override
Turn on/off the copying of attribute data.
void SetCopyScalars(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
void CopyTuple(vtkAbstractArray *fromData, vtkAbstractArray *toData, vtkIdType fromId, vtkIdType toId)
Copy a tuple (or set of tuples) of data from one data array to another.
vtkDataArray * GetGlobalIds(const char *name)
This will first look for an array with the correct name.
void InternalCopyAllocate(vtkDataSetAttributes *pd, int ctype, vtkIdType sze=0, vtkIdType ext=1000, int shallowCopyArrays=0, bool createNewArrays=true)
int IsArrayAnAttribute(int idx)
Determine whether a data array of index idx is considered a data set attribute (i....
vtkTypeBool GetCopyTangents(int ctype=ALLCOPY)
void CopyData(vtkDataSetAttributes *fromPd, vtkIdType fromId, vtkIdType toId)
Copy the attribute data from one id to another.
int SetActivePedigreeIds(const char *name)
Set/Get the pedigree id data.
static vtkDataSetAttributes * ExtendedNew()
int SetActiveRationalWeights(const char *name)
Set/Get the rational weights data.
vtkDataArray * GetGlobalIds()
Set/Get the global id data.
void RemoveArray(int index) override
Remove an array (with the given name) from the list of arrays.
vtkTypeBool GetCopyRationalWeights(int ctype=ALLCOPY)
vtkTypeBool GetCopyHigherOrderDegrees(int ctype=ALLCOPY)
void CopyTuples(vtkAbstractArray *fromData, vtkAbstractArray *toData, vtkIdType dstStart, vtkIdType n, vtkIdType srcStart)
Copy a tuple (or set of tuples) of data from one data array to another.
void CopyData(vtkDataSetAttributes::FieldList &list, vtkDataSetAttributes *dsa, int idx, vtkIdType dstStart, vtkIdType n, vtkIdType srcStart)
vtkTypeBool GetCopyGlobalIds(int ctype=ALLCOPY)
vtkTypeBool GetCopyTCoords(int ctype=ALLCOPY)
void CopyStructuredData(vtkDataSetAttributes *inDsa, const int *inExt, const int *outExt, bool setSize=true)
This method is used to copy data arrays in images.
static vtkDataSetAttributes * New()
Construct object with copying turned on for all data.
static const char * GetAttributeTypeAsString(int attributeType)
Given an integer attribute type, this static method returns a string type for the attribute (i....
vtkDataArray * GetVectors()
Set/Get the vector data.
void CopyAllocate(vtkDataSetAttributes::FieldList &list, vtkIdType sze=0, vtkIdType ext=1000)
A special form of CopyAllocate() to be used with FieldLists.
void CopyAllocate(vtkDataSetAttributes *pd, vtkIdType sze=0, vtkIdType ext=1000)
Allocates point data for point-by-point (or cell-by-cell) copy operation.
static const char * GetLongAttributeTypeAsString(int attributeType)
Given an integer attribute type, this static method returns a string type for the attribute (i....
vtkDataArray * GetRationalWeights(const char *name)
This will first look for an array with the correct name.
void DeepCopy(vtkFieldData *pd) override
Deep copy of data (i.e., create new data arrays and copy from input data).
int SetRationalWeights(vtkDataArray *da)
Set/Get the rational weights data.
void ShallowCopy(vtkFieldData *pd) override
Shallow copy of data (i.e., use reference counting).
void GetAttributeIndices(int *indexArray)
Get the field data array indices corresponding to scalars, vectors, tensors, etc.
vtkDataArray * GetTCoords(const char *name)
This will first look for an array with the correct name.
void SetCopyRationalWeights(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
vtkDataArray * GetTangents()
Set/get the tangent data.
void SetCopyTensors(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
vtkAbstractArray * GetPedigreeIds()
Set/Get the pedigree id data.
int SetActiveAttribute(const char *name, int attributeType)
Make the array with the given name the active attribute.
vtkDataArray * GetTCoords()
Set/Get the texture coordinate data.
int SetTCoords(vtkDataArray *da)
Set/Get the texture coordinate data.
vtkDataArray * GetHigherOrderDegrees()
Set/Get the rational degrees data.
void SetCopyHigherOrderDegrees(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
vtkDataArray * GetScalars()
Set/Get the scalar data.
void InterpolateAllocate(vtkDataSetAttributes *pd, vtkIdType sze, vtkIdType ext, int shallowCopyArrays)
Initialize point interpolation method.
int SetPedigreeIds(vtkAbstractArray *da)
Set/Get the pedigree id data.
vtkTypeBool GetCopyTensors(int ctype=ALLCOPY)
void CopyData(vtkDataSetAttributes *fromPd, vtkIdList *fromIds, vtkIdList *toIds)
Copy the attribute data from one id to another.
int SetActiveVectors(const char *name)
Set/Get the vector data.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void SetCopyGlobalIds(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
void CopyAllOff(int ctype=ALLCOPY) override
Turn on/off the copying of attribute data.
int SetTangents(vtkDataArray *da)
Set/get the tangent data.
int SetActiveTensors(const char *name)
Set/Get the tensor data.
void SetCopyVectors(vtkTypeBool i, int ctype=ALLCOPY)
Turn on/off the copying of attribute data.
int SetVectors(vtkDataArray *da)
Set/Get the vector data.
int SetTensors(vtkDataArray *da)
Set/Get the tensor data.
vtkDataArray * GetAttribute(int attributeType)
Return an attribute given the attribute type (see vtkDataSetAttributes::AttributeTypes).
int SetAttribute(vtkAbstractArray *aa, int attributeType)
Set an array to use as the given attribute type (i.e., vtkDataSetAttributes::SCALAR,...
represent and manipulate fields of data
Definition: vtkFieldData.h:55
virtual void RemoveArray(const char *name)
Remove an array (with the given name or index) from the list of arrays.
list of point or cell ids
Definition: vtkIdList.h:31
a simple class to control print indentation
Definition: vtkIndent.h:34
map scalar values into colors via a lookup table
@ value
Definition: vtkX3D.h:226
@ name
Definition: vtkX3D.h:225
@ index
Definition: vtkX3D.h:252
int vtkTypeBool
Definition: vtkABI.h:69
int vtkIdType
Definition: vtkType.h:332