vtkDataSetAttributes.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkDataSetAttributes_h
#define vtkDataSetAttributes_h
 
#include "vtkCommonDataModelModule.h"      // For export macro
#include "vtkDataSetAttributesFieldList.h" // for vtkDataSetAttributesFieldList
#include "vtkFieldData.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALMANUAL
 
VTK_ABI_NAMESPACE_BEGIN
class vtkLookupTable;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALMANUAL vtkDataSetAttributes : public vtkFieldData
{
public:
  static vtkDataSetAttributes* New();
  static vtkDataSetAttributes* ExtendedNew();
 
  vtkTypeMacro(vtkDataSetAttributes, vtkFieldData);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Initialize() override;
 
  virtual void Update() {}
 
  // -- shallow and deep copy -----------------------------------------------
 
  void DeepCopy(vtkFieldData* pd) override;
 
  void ShallowCopy(vtkFieldData* pd) override;
 
  // -- attribute types -----------------------------------------------------
 
  // Always keep NUM_ATTRIBUTES as the last entry
  enum AttributeTypes
  {
    SCALARS = 0,
    VECTORS = 1,
    NORMALS = 2,
    TCOORDS = 3,
    TENSORS = 4,
    GLOBALIDS = 5,
    PEDIGREEIDS = 6,
    EDGEFLAG = 7,
    TANGENTS = 8,
    RATIONALWEIGHTS = 9,
    HIGHERORDERDEGREES = 10,
    PROCESSIDS = 11,
    NUM_ATTRIBUTES
  };
 
  enum AttributeLimitTypes
  {
    MAX,
    EXACT,
    NOLIMIT
  };
 
  // ----------- ghost points and ghost cells -------------------------------------------
  // The following bit fields are consistent with VisIt ghost zones specification
  // For details, see http://www.visitusers.org/index.php?title=Representing_ghost_data
 
  enum CellGhostTypes
  {
    DUPLICATECELL = 1,        // the cell is present on multiple processors
    HIGHCONNECTIVITYCELL = 2, // the cell has more neighbors than in a regular mesh
    LOWCONNECTIVITYCELL = 4,  // the cell has less neighbors than in a regular mesh
    REFINEDCELL = 8,          // other cells are present that refines it.
    EXTERIORCELL = 16,        // the cell is on the exterior of the data set
    HIDDENCELL =
      32 // the cell is needed to maintain connectivity, but the data values should be ignored.
  };
 
  enum PointGhostTypes
  {
    DUPLICATEPOINT = 1, // the cell is present on multiple processors
    HIDDENPOINT =
      2 // the point is needed to maintain connectivity, but the data values should be ignored.
  };
 
  // A vtkDataArray with this name must be of type vtkUnsignedCharArray.
  // Each value must be assigned according to the bit fields described in
  // PointGhostTypes or CellGhostType
  static const char* GhostArrayName() { return "vtkGhostType"; }
 
  //-----------------------------------------------------------------------------------
 
 
  int SetScalars(vtkDataArray* da);
  int SetActiveScalars(const char* name);
  vtkDataArray* GetScalars();
 
 
  int SetVectors(vtkDataArray* da);
  int SetActiveVectors(const char* name);
  vtkDataArray* GetVectors();
 
 
  int SetNormals(vtkDataArray* da);
  int SetActiveNormals(const char* name);
  vtkDataArray* GetNormals();
 
 
  int SetTangents(vtkDataArray* da);
  int SetActiveTangents(const char* name);
  vtkDataArray* GetTangents();
 
 
  int SetTCoords(vtkDataArray* da);
  int SetActiveTCoords(const char* name);
  vtkDataArray* GetTCoords();
 
 
  int SetTensors(vtkDataArray* da);
  int SetActiveTensors(const char* name);
  vtkDataArray* GetTensors();
 
 
  int SetGlobalIds(vtkDataArray* da);
  int SetActiveGlobalIds(const char* name);
  vtkDataArray* GetGlobalIds();
 
 
  int SetPedigreeIds(vtkAbstractArray* da);
  int SetActivePedigreeIds(const char* name);
  vtkAbstractArray* GetPedigreeIds();
 
 
  int SetRationalWeights(vtkDataArray* da);
  int SetActiveRationalWeights(const char* name);
  vtkDataArray* GetRationalWeights();
 
 
  int SetHigherOrderDegrees(vtkDataArray* da);
  int SetActiveHigherOrderDegrees(const char* name);
  vtkDataArray* GetHigherOrderDegrees();
 
 
  int SetProcessIds(vtkDataArray* da);
  int SetActiveProcessIds(const char* name);
  vtkDataArray* GetProcessIds();
 
 
  vtkDataArray* GetScalars(const char* name);
  vtkDataArray* GetVectors(const char* name);
  vtkDataArray* GetNormals(const char* name);
  vtkDataArray* GetTangents(const char* name);
  vtkDataArray* GetTCoords(const char* name);
  vtkDataArray* GetTensors(const char* name);
  vtkDataArray* GetGlobalIds(const char* name);
  vtkAbstractArray* GetPedigreeIds(const char* name);
  vtkDataArray* GetRationalWeights(const char* name);
  vtkDataArray* GetHigherOrderDegrees(const char* name);
  vtkDataArray* GetProcessIds(const char* name);
 
  int SetActiveAttribute(const char* name, int attributeType);
 
  int SetActiveAttribute(int index, int attributeType);
 
  void GetAttributeIndices(int* indexArray);
 
  int IsArrayAnAttribute(int idx);
 
  int SetAttribute(vtkAbstractArray* aa, int attributeType);
 
  vtkDataArray* GetAttribute(int attributeType);
 
  vtkAbstractArray* GetAbstractAttribute(int attributeType);
 
 
  using vtkFieldData::RemoveArray;
  void RemoveArray(int index) override;
 
 
  static const char* GetAttributeTypeAsString(int attributeType);
  static const char* GetLongAttributeTypeAsString(int attributeType);
 
  // -- attribute copy properties ------------------------------------------
 
  enum AttributeCopyOperations
  {
    COPYTUPLE = 0,
    INTERPOLATE = 1,
    PASSDATA = 2,
    ALLCOPY // all of the above
  };
 
  void SetCopyAttribute(int index, int value, int ctype = ALLCOPY);
 
  int GetCopyAttribute(int index, int ctype);
 
  void SetCopyScalars(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyScalars(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyScalars, vtkTypeBool);
 
  void SetCopyVectors(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyVectors(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyVectors, vtkTypeBool);
 
  void SetCopyNormals(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyNormals(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyNormals, vtkTypeBool);
 
  void SetCopyTangents(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyTangents(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyTangents, vtkTypeBool);
 
  void SetCopyTCoords(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyTCoords(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyTCoords, vtkTypeBool);
 
  void SetCopyTensors(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyTensors(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyTensors, vtkTypeBool);
 
  void SetCopyGlobalIds(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyGlobalIds(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyGlobalIds, vtkTypeBool);
 
  void SetCopyPedigreeIds(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyPedigreeIds(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyPedigreeIds, vtkTypeBool);
 
  void SetCopyRationalWeights(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyRationalWeights(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyRationalWeights, vtkTypeBool);
 
  void SetCopyHigherOrderDegrees(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyHigherOrderDegrees(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyHigherOrderDegrees, vtkTypeBool);
 
  void SetCopyProcessIds(vtkTypeBool i, int ctype = ALLCOPY);
  vtkTypeBool GetCopyProcessIds(int ctype = ALLCOPY);
  vtkBooleanMacro(CopyProcessIds, vtkTypeBool);
 
  void CopyAllOn(int ctype = ALLCOPY) override;
 
  void CopyAllOff(int ctype = ALLCOPY) override;
 
  // -- passthrough operations ----------------------------------------------
 
  void PassData(vtkFieldData* fd) override;
 
  // -- copytuple operations ------------------------------------------------
 
 
  void CopyAllocate(vtkDataSetAttributes* pd, vtkIdType sze = 0, vtkIdType ext = 1000)
  {
    this->CopyAllocate(pd, sze, ext, 0);
  }
  void CopyAllocate(vtkDataSetAttributes* pd, vtkIdType sze, vtkIdType ext, int shallowCopyArrays);
 
  void SetupForCopy(vtkDataSetAttributes* pd);
 
  void CopyStructuredData(
    vtkDataSetAttributes* inDsa, const int* inExt, const int* outExt, bool setSize = true);
 
 
  void CopyData(vtkDataSetAttributes* fromPd, vtkIdType fromId, vtkIdType toId);
  void CopyData(vtkDataSetAttributes* fromPd, vtkIdList* fromIds, vtkIdList* toIds);
  void CopyData(vtkDataSetAttributes* fromPd, vtkIdList* fromIds, vtkIdType destStartId = 0);
 
  void CopyData(vtkDataSetAttributes* fromPd, vtkIdType dstStart, vtkIdType n, vtkIdType srcStart);
 
 
  void CopyTuple(
    vtkAbstractArray* fromData, vtkAbstractArray* toData, vtkIdType fromId, vtkIdType toId);
  void CopyTuples(
    vtkAbstractArray* fromData, vtkAbstractArray* toData, vtkIdList* fromIds, vtkIdList* toIds);
  void CopyTuples(vtkAbstractArray* fromData, vtkAbstractArray* toData, vtkIdType dstStart,
    vtkIdType n, vtkIdType srcStart);
 
  // -- interpolate operations ----------------------------------------------
 
 
  void InterpolateAllocate(vtkDataSetAttributes* pd, vtkIdType sze = 0, vtkIdType ext = 1000)
  {
    this->InterpolateAllocate(pd, sze, ext, 0);
  }
  void InterpolateAllocate(
    vtkDataSetAttributes* pd, vtkIdType sze, vtkIdType ext, int shallowCopyArrays);
 
  void InterpolatePoint(
    vtkDataSetAttributes* fromPd, vtkIdType toId, vtkIdList* ids, double* weights);
 
  void InterpolateEdge(
    vtkDataSetAttributes* fromPd, vtkIdType toId, vtkIdType p1, vtkIdType p2, double t);
 
  void InterpolateTime(
    vtkDataSetAttributes* from1, vtkDataSetAttributes* from2, vtkIdType id, double t);
 
  using FieldList = vtkDataSetAttributesFieldList;
 
  // field list copy operations ------------------------------------------
 
  void CopyAllocate(vtkDataSetAttributes::FieldList& list, vtkIdType sze = 0, vtkIdType ext = 1000);
 
  void CopyData(vtkDataSetAttributes::FieldList& list, vtkDataSetAttributes* dsa, int idx,
    vtkIdType fromId, vtkIdType toId);
  void CopyData(vtkDataSetAttributes::FieldList& list, vtkDataSetAttributes* dsa, int idx,
    vtkIdType dstStart, vtkIdType n, vtkIdType srcStart);
 
  void InterpolateAllocate(
    vtkDataSetAttributes::FieldList& list, vtkIdType sze = 0, vtkIdType ext = 1000);
 
  void InterpolatePoint(vtkDataSetAttributes::FieldList& list, vtkDataSetAttributes* fromPd,
    int idx, vtkIdType toId, vtkIdList* ids, double* weights);
 
protected:
  vtkDataSetAttributes();
  ~vtkDataSetAttributes() override;
 
  void InternalCopyAllocate(vtkDataSetAttributes* pd, int ctype, vtkIdType sze = 0,
    vtkIdType ext = 1000, int shallowCopyArrays = 0, bool createNewArrays = true);
 
  void InitializeFields() override;
 
  int AttributeIndices[NUM_ATTRIBUTES];            // index to attribute array in field data
  int CopyAttributeFlags[ALLCOPY][NUM_ATTRIBUTES]; // copy flag for attribute data
 
  friend struct ArrayList; // Friend to base class in vtkArrayListTemplate
  vtkFieldData::BasicIterator RequiredArrays;
  int* TargetIndices;
 
  static const int NumberOfAttributeComponents[NUM_ATTRIBUTES];
  static const int AttributeLimits[NUM_ATTRIBUTES];
  static const char AttributeNames[NUM_ATTRIBUTES][19];
  static const char LongAttributeNames[NUM_ATTRIBUTES][42];
 
private:
  static int CheckNumberOfComponents(vtkAbstractArray* da, int attributeType);
 
  vtkFieldData::BasicIterator ComputeRequiredArrays(vtkDataSetAttributes* pd, int ctype);
 
  vtkDataSetAttributes(const vtkDataSetAttributes&) = delete;
  void operator=(const vtkDataSetAttributes&) = delete;
 
  friend class vtkDataSetAttributesFieldList;
};
 
VTK_ABI_NAMESPACE_END
#endif