Common/vtkDataArray.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkDataArray.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 __vtkDataArray_h
#define __vtkDataArray_h

#include "vtkObject.h"

class vtkFloatArray;
class vtkLookupTable;
class vtkIdList;

class VTK_COMMON_EXPORT vtkDataArray : public vtkObject 
{
public:
  vtkTypeRevisionMacro(vtkDataArray,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);


  virtual int Allocate(const vtkIdType sz, const vtkIdType ext=1000) = 0;
  virtual void Initialize() = 0;

#ifndef VTK_REMOVE_LEGACY_CODE

  virtual vtkDataArray* MakeObject();
#endif

  virtual int GetDataType() = 0;

  virtual int GetDataTypeSize() = 0;


  vtkSetClampMacro(NumberOfComponents,int,1,VTK_LARGE_INTEGER);
  int GetNumberOfComponents() {return this->NumberOfComponents;};

  virtual void SetNumberOfTuples(const vtkIdType number) = 0;


  vtkIdType GetNumberOfTuples() 
    {return (this->MaxId + 1)/this->NumberOfComponents;}

  virtual float *GetTuple(const vtkIdType i) = 0;


  virtual void GetTuple(const vtkIdType i, float * tuple) = 0;
  virtual void GetTuple(const vtkIdType i, double * tuple);


  float GetTuple1(const vtkIdType i);
  float* GetTuple2(const vtkIdType i);
  float* GetTuple3(const vtkIdType i);
  float* GetTuple4(const vtkIdType i);
  float* GetTuple9(const vtkIdType i);

  void GetTuples(vtkIdList *ptIds, vtkDataArray *output);

  void GetTuples(vtkIdType p1, vtkIdType p2, vtkDataArray *output);


  virtual void SetTuple(const vtkIdType i, const float * tuple) = 0;
  virtual void SetTuple(const vtkIdType i, const double * tuple);


  void SetTuple1(const vtkIdType i, float value);
  void SetTuple2(const vtkIdType i, float val0, float val1);
  void SetTuple3(const vtkIdType i, float val0, float val1, float val2);
  void SetTuple4(const vtkIdType i, float val0, float val1, float val2,
                 float val3);
  void SetTuple9(const vtkIdType i, float val0, float val1, float val2,
                 float val3, float val4, float val5, float val6,
                 float val7, float val8);


  virtual void InsertTuple(const vtkIdType i, const float * tuple) = 0;
  virtual void InsertTuple(const vtkIdType i, const double * tuple);


  void InsertTuple1(const vtkIdType i, float value);
  void InsertTuple2(const vtkIdType i, float val0, float val1);
  void InsertTuple3(const vtkIdType i, float val0, float val1, float val2);
  void InsertTuple4(const vtkIdType i, float val0, float val1, float val2,
                    float val3);
  void InsertTuple9(const vtkIdType i, float val0, float val1, float val2,
                    float val3, float val4, float val5, float val6,
                    float val7, float val8);


  virtual vtkIdType InsertNextTuple(const float * tuple) = 0;
  virtual vtkIdType InsertNextTuple(const double * tuple);


  void InsertNextTuple1(float value);
  void InsertNextTuple2(float val0, float val1);
  void InsertNextTuple3(float val0, float val1, float val2);
  void InsertNextTuple4(float val0, float val1, float val2,
                        float val3);
  void InsertNextTuple9(float val0, float val1, float val2,
                        float val3, float val4, float val5, float val6,
                        float val7, float val8);

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

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

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


  virtual void GetData(vtkIdType tupleMin, vtkIdType tupleMax, int compMin,
                       int compMax, vtkFloatArray* data);

  virtual void DeepCopy(vtkDataArray *da);

  virtual void FillComponent(const int j, const float c);


  virtual void CopyComponent(const int j, vtkDataArray *from,
                             const int fromComponent);

  virtual void *GetVoidPointer(const vtkIdType id) = 0;

  virtual void Squeeze() = 0;

  virtual void Resize(vtkIdType numTuples) = 0;


  void Reset() 
    {this->MaxId = -1;}


  vtkIdType GetSize() 
    {return this->Size;}
  

  vtkIdType GetMaxId() 
    {return this->MaxId;}


  virtual void SetVoidArray(void *vtkNotUsed(array),
                            vtkIdType vtkNotUsed(size),
                            int vtkNotUsed(save)) {};

  unsigned long GetActualMemorySize();
  
  void CreateDefaultLookupTable();


  void SetLookupTable(vtkLookupTable *lut);
  vtkGetObjectMacro(LookupTable,vtkLookupTable);
  

  void SetName(const char* name);
  const char* GetName();


  void GetRange(float range[2], int comp)
    {
      this->ComputeRange(comp);
      memcpy(range, this->Range, 2*sizeof(float));
    }
  float* GetRange(int comp)
    {
      this->ComputeRange(comp);
      return this->Range;
    }

  virtual void ComputeRange(int comp);

  float* GetRange()
    {
      this->ComputeRange(0);
      return this->Range;
    }
  void GetRange(float range[2])
    {
      this->GetRange(range,0);
    }


  void GetDataTypeRange(double range[2]);
  double GetDataTypeMin();
  double GetDataTypeMax();

  virtual float GetMaxNorm();

  static vtkDataArray* CreateDataArray(int dataType);

protected:
  // Construct object with default tuple dimension (number of components) of 1.
  vtkDataArray(vtkIdType numComp=1);
  ~vtkDataArray();

  vtkLookupTable *LookupTable;

  vtkIdType Size;      // allocated size of data
  vtkIdType MaxId;     // maximum index inserted thus far
  int NumberOfComponents; // the number of components per tuple

  char* Name;

private:
  float Range[2];
  int ComponentForLastRange;
  vtkTimeStamp ComputeTimeForLastRange;

  float* GetTupleN(const vtkIdType i, int n);
  
private:
  vtkDataArray(const vtkDataArray&);  // Not implemented.
  void operator=(const vtkDataArray&);  // Not implemented.
};

#endif

Generated on Thu Jan 22 15:46:42 2004 for VTK by Doxygen 1.3.4