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 InsertTuple6(vtkIdType i, double val0, double val1, double val2,
                    double val3, double val4, double val5);
  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 InsertNextTuple6(double val0, double val1, double val2,
                        double val3, double val4, double val5);
  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