---

Common/vtkFieldData.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkFieldData.h,v $
  Language:  C++

  Copyright (c) 1993-2002 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 __vtkFieldData_h
#define __vtkFieldData_h

#include "vtkObject.h"

#include "vtkDataArray.h" // Needed for inline methods

class vtkIdList;

class VTK_COMMON_EXPORT vtkFieldData : public vtkObject
{
public:
  static vtkFieldData *New();

  vtkTypeRevisionMacro(vtkFieldData,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);

  virtual void Initialize();

  int Allocate(const vtkIdType sz, const vtkIdType ext=1000);

#ifndef VTK_REMOVE_LEGACY_CODE

  virtual vtkFieldData* MakeObject();
#endif

  void CopyStructure(vtkFieldData*);

  void AllocateArrays(int num);

#ifndef VTK_REMOVE_LEGACY_CODE
  void SetNumberOfArrays(int num)
    {
      vtkWarningMacro("This method will be deprecated. Please use "
                      "AllocateArrays() instead.");
      this->AllocateArrays(num);
    }
#endif

  int GetNumberOfArrays();

  int AddArray(vtkDataArray *array);


  virtual void RemoveArray(const char *name)
    {
      int i;
      this->GetArray(name, i);
      this->RemoveArray(i);
    }

  vtkDataArray *GetArray(int i);

  vtkDataArray *GetArray(const char *arrayName, int &index);

  // Return the array with the name given. Returns NULL is array not found.
  vtkDataArray *GetArray(const char *arrayName);


  const char* GetArrayName(int i)
    {
    vtkDataArray* da = this->GetArray(i);
    if (da)
      {
      return da->GetName();
      }
    else
      {
      return 0;
      }
    }

  virtual void PassData(vtkFieldData* fd);


  void CopyFieldOn(const char* name) { this->CopyFieldOnOff(name, 1); }
  void CopyFieldOff(const char* name) { this->CopyFieldOnOff(name, 0); }

  virtual void CopyAllOn();

  virtual void CopyAllOff();

  virtual void DeepCopy(vtkFieldData *da);

  virtual void ShallowCopy(vtkFieldData *da);

  void Squeeze();

  void Reset();

  virtual unsigned long GetActualMemorySize();

  unsigned long int GetMTime();
  
  void GetField(vtkIdList *ptId, vtkFieldData *f);

  int GetArrayContainingComponent(int i, int& arrayComp);

  int GetNumberOfComponents();

  vtkIdType GetNumberOfTuples();

  void SetNumberOfTuples(const vtkIdType number);

  float *GetTuple(const vtkIdType i);

  void GetTuple(const vtkIdType i, float * tuple);

  void SetTuple(const vtkIdType i, const float * tuple);

  void InsertTuple(const vtkIdType i, const float * tuple);

  vtkIdType InsertNextTuple(const float * tuple);

  float GetComponent(const vtkIdType i, const int j);

  void SetComponent(const vtkIdType i, const int j, const float c);
  
  void InsertComponent(const vtkIdType i, const int j, const float c);

protected:

  vtkFieldData();
  ~vtkFieldData();

  int NumberOfArrays;
  int NumberOfActiveArrays;
  vtkDataArray **Data;

  int TupleSize; //used for type conversion
  float *Tuple;

  void SetArray(int i, vtkDataArray *array);

  virtual void RemoveArray(int index);

  virtual void InitializeFields();

//BTX

  struct CopyFieldFlag
  {
    char* ArrayName;
    int IsCopied;
  };

  CopyFieldFlag* CopyFieldFlags; //the names of fields not to be copied
  int NumberOfFieldFlags; //the number of fields not to be copied
  void CopyFieldOnOff(const char* name, int onOff);
  void ClearFieldFlags();
  int FindFlag(const char* field);
  int GetFlag(const char* field);
  void CopyFlags(const vtkFieldData* source);
  int DoCopyAllOn;
  int DoCopyAllOff;


private:
  vtkFieldData(const vtkFieldData&);  // Not implemented.
  void operator=(const vtkFieldData&);  // Not implemented.

public:

  class VTK_COMMON_EXPORT BasicIterator
  {
  public:
    BasicIterator();
    BasicIterator(const BasicIterator& source);
    BasicIterator(const int* list, unsigned int listSize);
    BasicIterator& operator=(const BasicIterator& source);
    virtual ~BasicIterator();

    int GetListSize() const
      {
        return this->ListSize;
      }
    int GetCurrentIndex()
      {
        return this->List[this->Position];
      }
    int BeginIndex()
      {
        this->Position = -1;
        return this->NextIndex();
      }
    int End() const
      {
        return (this->Position >= this->ListSize);
      }
    int NextIndex()
      {
        this->Position++;
        return (this->End() ? -1 : this->List[this->Position]);
      }
    
  protected:

    int* List;
    int ListSize;
    int Position;
  };

  class VTK_COMMON_EXPORT Iterator : public BasicIterator
  {
  public:

    Iterator(const Iterator& source);
    Iterator& operator=(const Iterator& source);
    virtual ~Iterator();
    Iterator(vtkFieldData* dsa, const int* list=0, 
             unsigned int listSize=0);

    vtkDataArray* Begin()
      {
        this->Position = -1;
        return this->Next();
      }

    vtkDataArray* Next()
      {
        this->Position++;
        return (this->End() ? 0 : 
                Fields->GetArray(this->List[this->Position]));
      }

    void DetachFieldData();

  protected:
    vtkFieldData* Fields;
    int Detached;
  };


//ETX

};


#endif

Generated on Fri Mar 7 15:39:59 2003 for VTK by Doxygen 1.2.18