vtkDataSetAttributes.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkDataSetAttributes.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkDataSetAttributes_h
#define vtkDataSetAttributes_h

#include "vtkCommonDataModelModule.h"      // For export macro
#include "vtkDataSetAttributesFieldList.h" // for vtkDataSetAttributesFieldList
#include "vtkFieldData.h"

class vtkLookupTable;

class VTKCOMMONDATAMODEL_EXPORT vtkDataSetAttributes : public vtkFieldData
{
public:
  static vtkDataSetAttributes *New();

  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,
    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 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();


  vtkDataArray* GetScalars(const char* name);
  vtkDataArray* GetVectors(const char* name);
  vtkDataArray* GetNormals(const char* name);
  vtkDataArray* GetTCoords(const char* name);
  vtkDataArray* GetTensors(const char* name);
  vtkDataArray* GetGlobalIds(const char* name);
  vtkAbstractArray* GetPedigreeIds(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 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 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, 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

  vtkFieldData::BasicIterator RequiredArrays;

  int* TargetIndices;

  static const int NumberOfAttributeComponents[NUM_ATTRIBUTES];
  static const int AttributeLimits[NUM_ATTRIBUTES];
  static const char AttributeNames[NUM_ATTRIBUTES][12];
  static const char LongAttributeNames[NUM_ATTRIBUTES][35];

private:
  static int CheckNumberOfComponents(vtkAbstractArray* da, int attributeType);

  vtkFieldData::BasicIterator  ComputeRequiredArrays(vtkDataSetAttributes* pd, int ctype);

private:
  vtkDataSetAttributes(const vtkDataSetAttributes&) = delete;
  void operator=(const vtkDataSetAttributes&) = delete;

  friend class vtkDataSetAttributesFieldList;
};

#endif