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 "vtkFieldData.h"
 
class vtkLookupTable;
 
class VTKCOMMONDATAMODEL_EXPORT vtkDataSetAttributes : public vtkFieldData
{
public:
  static vtkDataSetAttributes *New();
 
  vtkTypeMacro(vtkDataSetAttributes,vtkFieldData);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  virtual void Initialize();
 
  virtual void Update() {}
 
  // -- shallow and deep copy -----------------------------------------------
 
  virtual void DeepCopy(vtkFieldData *pd);
 
  virtual void ShallowCopy(vtkFieldData *pd);
 
  // -- attribute types -----------------------------------------------------
//BTX
  // 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
  };
//ETX
 
  // ----------- 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);
 
 
  virtual void RemoveArray(const char *name);
  virtual void RemoveArray(int index);
 
 
 
  static const char* GetAttributeTypeAsString(int attributeType);
  static const char* GetLongAttributeTypeAsString(int attributeType);
 
  // -- attribute copy properties ------------------------------------------
 
//BTX
  enum AttributeCopyOperations
  {
    COPYTUPLE=0,
    INTERPOLATE=1,
    PASSDATA=2,
    ALLCOPY  //all of the above
  };
//ETX
 
  void SetCopyAttribute (int index, int value, int ctype=ALLCOPY);
 
 
  void SetCopyScalars(int i, int ctype=ALLCOPY);
  int GetCopyScalars(int ctype=ALLCOPY);
  vtkBooleanMacro(CopyScalars, int);
 
 
  void SetCopyVectors(int i, int ctype=ALLCOPY);
  int GetCopyVectors(int ctype=ALLCOPY);
  vtkBooleanMacro(CopyVectors, int);
 
 
  void SetCopyNormals(int i, int ctype=ALLCOPY);
  int GetCopyNormals(int ctype=ALLCOPY);
  vtkBooleanMacro(CopyNormals, int);
 
 
  void SetCopyTCoords(int i, int ctype=ALLCOPY);
  int GetCopyTCoords(int ctype=ALLCOPY);
  vtkBooleanMacro(CopyTCoords, int);
 
 
  void SetCopyTensors(int i, int ctype=ALLCOPY);
  int GetCopyTensors(int ctype=ALLCOPY);
  vtkBooleanMacro(CopyTensors, int);
 
 
  void SetCopyGlobalIds(int i, int ctype=ALLCOPY);
  int GetCopyGlobalIds(int ctype=ALLCOPY);
  vtkBooleanMacro(CopyGlobalIds, int);
 
 
  void SetCopyPedigreeIds(int i, int ctype=ALLCOPY);
  int GetCopyPedigreeIds(int ctype=ALLCOPY);
  vtkBooleanMacro(CopyPedigreeIds, int);
 
  virtual void CopyAllOn(int ctype=ALLCOPY);
 
  virtual void CopyAllOff(int ctype=ALLCOPY);
 
  // -- passthrough operations ----------------------------------------------
 
  virtual void PassData(vtkFieldData* fd);
 
  // -- 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 CopyStructuredData(vtkDataSetAttributes *inDsa,
                          const int *inExt, const int *outExt);
 
 
  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);
 
//BTX
  class FieldList;
 
  // 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 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);
 
  friend class vtkDataSetAttributes::FieldList;
//ETX
 
//BTX
protected:
  vtkDataSetAttributes();
  ~vtkDataSetAttributes();
 
  void InternalCopyAllocate(vtkDataSetAttributes* pd,
                            int ctype,
                            vtkIdType sze=0,
                            vtkIdType ext=1000,
                            int shallowCopyArrays=0);
 
  void InternalCopyAllocate(
    vtkDataSetAttributes::FieldList& list,
    int ctype,
    vtkIdType sze, vtkIdType ext);
 
  virtual void InitializeFields();
 
  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&);  // Not implemented.
  void operator=(const vtkDataSetAttributes&);  // Not implemented.
 
public:
  // This public class is used to perform set operations, other misc.
  // operations on fields. For example, vtkAppendFilter uses it to
  // determine which attributes the input datasets share in common.
  class vtkInternalComponentNames;
  class VTKCOMMONDATAMODEL_EXPORT FieldList
  {
  public:
    FieldList(int numInputs);
    ~FieldList();
    void PrintSelf(ostream &os, vtkIndent indent);
 
    void InitializeFieldList(vtkDataSetAttributes* dsa);
    void IntersectFieldList(vtkDataSetAttributes* dsa);
 
    void UnionFieldList(vtkDataSetAttributes* dsa);
 
    //Determine whether data is available
    int IsAttributePresent(int attrType); //true/false attributes specified
 
    // Accessor methods.
    int GetNumberOfFields() { return this->NumberOfFields; }
    int GetFieldIndex(int i) { return this->FieldIndices[i]; }
    const char* GetFieldName(int i) { return this->Fields[i]; }
    int GetFieldComponents(int i) { return this->FieldComponents[i]; }
    int GetDSAIndex(int index, int i) { return this->DSAIndices[index][i]; }
 
    friend class vtkDataSetAttributes;
 
  protected:
    FieldList(const FieldList&) {} //prevent these methods from being used
    void operator=(const FieldList&) {}
 
    void SetFieldIndex(int i, int index)
      { this->FieldIndices[i] = index; }
  private:
    void SetField(int index, vtkAbstractArray *da);
    void RemoveField(const char *name);
    void ClearFields();
    void GrowBy(unsigned int delta);
 
    int NumberOfFields; //the number of fields (including five named attributes)
    // These keep track of what is common across datasets. The first
    // six items are always named attributes.
    char** Fields;                     // the names of the fields
    int *FieldTypes;                   // the types of the fields
    int *FieldComponents;              // the number of components in field
    int *FieldIndices;                 // output data array index
    vtkLookupTable **LUT;              // luts associated with each array
    vtkInformation **FieldInformation; // Information map associated with each array
 
    vtkInternalComponentNames **FieldComponentsNames;       // the name for each component in the field
 
    vtkIdType NumberOfTuples; // a running total of values
 
    //For every vtkDataSetAttributes that are processed, keep track of the
    //indices into various things. The indices are organized so that the
    //first NUM_ATTRIBUTES refer to attributes, the next refer to the
    //non-attribute fields, for a total of NUM_ATTRIBUTES + NumberOfFields.
    //CurrentInput is the current input being processed.
    int **DSAIndices;
    int NumberOfDSAIndices;
    int CurrentInput;
 
  };
//ETX
};
 
#endif