vtkDataArray.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkDataArray.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 vtkDataArray_h
#define vtkDataArray_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkAbstractArray.h"
 
class vtkDoubleArray;
class vtkIdList;
class vtkInformationDoubleVectorKey;
class vtkLookupTable;
class vtkPoints;
 
class VTKCOMMONCORE_EXPORT vtkDataArray : public vtkAbstractArray
{
public:
  vtkTypeMacro(vtkDataArray,vtkAbstractArray);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  static vtkDataArray* FastDownCast(vtkAbstractArray *source);
 
 
  virtual int IsNumeric()
    { return 1; }
 
 
  virtual int GetElementComponentSize()
    { return this->GetDataTypeSize(); }
 
  virtual void SetTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source) = 0;
 
  virtual void InsertTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source) = 0;
 
  virtual vtkIdType InsertNextTuple(vtkIdType j, vtkAbstractArray* source) = 0;
 
  virtual void GetTuples(vtkIdList *ptIds, vtkAbstractArray *output);
 
  virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray *output);
 
 
 
  virtual void InterpolateTuple(vtkIdType i, vtkIdList *ptIndices,
    vtkAbstractArray* source,  double* weights);
 
 
  virtual void InterpolateTuple(vtkIdType i,
    vtkIdType id1, vtkAbstractArray* source1,
    vtkIdType id2, vtkAbstractArray* source2, double t);
 
  virtual double *GetTuple(vtkIdType i) = 0;
 
  virtual void GetTuple(vtkIdType i, double * tuple) = 0;
 
 
  double GetTuple1(vtkIdType i);
  double* GetTuple2(vtkIdType i);
  double* GetTuple3(vtkIdType i);
  double* GetTuple4(vtkIdType i);
  double* GetTuple6(vtkIdType i);
  double* GetTuple9(vtkIdType i);
 
 
  virtual void SetTuple(vtkIdType i, const float * tuple) = 0;
  virtual void SetTuple(vtkIdType i, const double * tuple) = 0;
 
 
  void SetTuple1(vtkIdType i, double value);
  void SetTuple2(vtkIdType i, double val0, double val1);
  void SetTuple3(vtkIdType i, double val0, double val1, double val2);
  void SetTuple4(vtkIdType i, double val0, double val1, double val2,
                 double val3);
  void SetTuple6(vtkIdType i, double val0, double val1, double val2,
                 double val3, double val4, double val5);
  void SetTuple9(vtkIdType i, double val0, double val1, double val2,
                 double val3, double val4, double val5, double val6,
                 double val7, double val8);
 
 
  virtual void InsertTuple(vtkIdType i, const float * tuple) = 0;
  virtual void InsertTuple(vtkIdType i, const double * tuple) = 0;
 
 
  void InsertTuple1(vtkIdType i, double value);
  void InsertTuple2(vtkIdType i, double val0, double val1);
  void InsertTuple3(vtkIdType i, double val0, double val1, double val2);
  void InsertTuple4(vtkIdType i, double val0, double val1, double val2,
                    double val3);
  void InsertTuple9(vtkIdType i, double val0, double val1, double val2,
                    double val3, double val4, double val5, double val6,
                    double val7, double val8);
 
 
  virtual vtkIdType InsertNextTuple(const float * tuple) = 0;
  virtual vtkIdType InsertNextTuple(const double * tuple) = 0;
 
 
  void InsertNextTuple1(double value);
  void InsertNextTuple2(double val0, double val1);
  void InsertNextTuple3(double val0, double val1, double val2);
  void InsertNextTuple4(double val0, double val1, double val2,
                        double val3);
  void InsertNextTuple9(double val0, double val1, double val2,
                        double val3, double val4, double val5, double val6,
                        double val7, double val8);
 
 
  virtual void RemoveTuple(vtkIdType id) = 0;
  virtual void RemoveFirstTuple() = 0;
  virtual void RemoveLastTuple() = 0;
 
  virtual double GetComponent(vtkIdType i, int j);
 
  virtual void SetComponent(vtkIdType i, int j, double c);
 
  virtual void InsertComponent(vtkIdType i, int j, double c);
 
 
  virtual void GetData(vtkIdType tupleMin, vtkIdType tupleMax, int compMin,
                       int compMax, vtkDoubleArray* data);
 
 
  virtual void DeepCopy(vtkAbstractArray *aa);
  virtual void DeepCopy(vtkDataArray *da);
 
  virtual void FillComponent(int j, double c);
 
 
  virtual void CopyComponent(int j, vtkDataArray *from,
                             int fromComponent);
 
  virtual void* WriteVoidPointer(vtkIdType id, vtkIdType number) = 0;
 
  virtual unsigned long GetActualMemorySize();
 
  void CreateDefaultLookupTable();
 
 
  void SetLookupTable(vtkLookupTable *lut);
  vtkGetObjectMacro(LookupTable,vtkLookupTable);
 
 
  void GetRange(double range[2], int comp)
    {
    this->ComputeRange(range, comp);
    }
 
 
  double* GetRange(int comp)
    {
    this->GetRange(this->Range, comp);
    return this->Range;
    }
 
 
  double* GetRange()
    {
    return this->GetRange(0);
    }
 
 
  void GetRange(double range[2])
    {
    this->GetRange(range,0);
    }
 
 
  void GetDataTypeRange(double range[2]);
  double GetDataTypeMin();
  double GetDataTypeMax();
  static void GetDataTypeRange(int type, double range[2]);
  static double GetDataTypeMin(int type);
  static double GetDataTypeMax(int type);
 
  virtual double GetMaxNorm();
 
  static vtkDataArray* CreateDataArray(int dataType);
 
  static vtkInformationDoubleVectorKey* COMPONENT_RANGE();
  static vtkInformationDoubleVectorKey* L2_NORM_RANGE();
 
  virtual int CopyInformation(vtkInformation *infoFrom, int deep=1);
 
  virtual int GetArrayType() { return DataArray; }
 
protected:
 
  friend class vtkPoints;
 
  virtual void ComputeRange(double range[2], int comp);
 
  virtual bool ComputeScalarRange(double* ranges);
 
  // Returns true if the range was computed. Will return false
  // if you try to compute the range of an array of length zero.
  virtual bool ComputeVectorRange(double range[2]);
 
  // Construct object with default tuple dimension (number of components) of 1.
  vtkDataArray();
  ~vtkDataArray();
 
  vtkLookupTable *LookupTable;
  double Range[2];
 
private:
  double* GetTupleN(vtkIdType i, int n);
 
private:
  vtkDataArray(const vtkDataArray&);  // Not implemented.
  void operator=(const vtkDataArray&);  // Not implemented.
};
 
//------------------------------------------------------------------------------
inline vtkDataArray* vtkDataArray::FastDownCast(vtkAbstractArray *source)
{
  switch (source->GetArrayType())
    {
    case DataArrayTemplate:
    case TypedDataArray:
    case DataArray:
    case MappedDataArray:
      return static_cast<vtkDataArray*>(source);
    default:
      return NULL;
    }
}
 
#endif