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