dox/Common/vtkAbstractArray.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkAbstractArray.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 __vtkAbstractArray_h
#define __vtkAbstractArray_h

#include "vtkObject.h"
#include "vtkVariant.h" // for variant arguments

class vtkArrayIterator;
class vtkDataArray;
class vtkIdList;
class vtkIdTypeArray;
class vtkInformation;
class vtkInformationIntegerKey;

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

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

  virtual void Initialize() = 0;

  virtual int GetDataType() =0;


  virtual int GetDataTypeSize() = 0;
  static int GetDataTypeSize(int type);

  virtual int GetElementComponentSize() = 0;


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

  void SetComponentName( vtkIdType component, const char *name );
  
  const char* GetComponentName( vtkIdType component );

  bool HasAComponentName();

  int CopyComponentNames( vtkAbstractArray *da );
  
  virtual void SetNumberOfTuples(vtkIdType number) = 0;


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

  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 *GetVoidPointer(vtkIdType id) = 0;

  virtual void DeepCopy(vtkAbstractArray* da);


  virtual void InterpolateTuple(vtkIdType i, vtkIdList *ptIndices,
    vtkAbstractArray* source,  double* weights) = 0;


  virtual void InterpolateTuple(vtkIdType i, 
    vtkIdType id1, vtkAbstractArray* source1, 
    vtkIdType id2, vtkAbstractArray* source2, double t) =0;

  virtual void Squeeze() = 0; 

  virtual int 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)) =0;

  virtual void ExportToVoidPointer(void *vtkNotUsed(out_ptr)) {}

  virtual unsigned long GetActualMemorySize() = 0;


  vtkSetStringMacro(Name); 
  vtkGetStringMacro(Name);


  virtual const char *GetDataTypeAsString( void )
    { return vtkImageScalarTypeNameMacro( this->GetDataType() ); }

  static vtkAbstractArray* CreateArray(int dataType);

  virtual int IsNumeric() = 0;

  virtual vtkArrayIterator* NewIterator() = 0;


  virtual vtkIdType GetDataSize()
    {
    return this->GetNumberOfComponents() * this->GetNumberOfTuples();
    }


  virtual vtkIdType LookupValue(vtkVariant value) = 0;
  virtual void LookupValue(vtkVariant value, vtkIdList* ids) = 0;

  virtual vtkVariant GetVariantValue(vtkIdType idx);

  virtual void InsertVariantValue(vtkIdType idx, vtkVariant value);

  virtual void SetVariantValue(vtkIdType idx, vtkVariant value) = 0;

  virtual void DataChanged() = 0;

  virtual void ClearLookup() = 0;

  // TODO: Implement these lookup functions also.
  //virtual void LookupRange(vtkVariant min, vtkVariant max, vtkIdList* ids,
  //  bool includeMin = true, bool includeMax = true) = 0;
  //virtual void LookupGreaterThan(vtkVariant min, vtkIdList* ids, bool includeMin = false) = 0;
  //virtual void LookupLessThan(vtkVariant max, vtkIdList* ids, bool includeMax = false) = 0;


  vtkInformation* GetInformation();
  // Description:
  // Inquire if this array has an instance of vtkInformation 
  // already associated with it.
  bool HasInformation(){ return this->Information!=0; }
  //BTX
  // Description:
  // Copy information instance. Arrays use information objects
  // in a variety of ways. It is important to have flexibility in
  // this regard because certain keys should not be coppied, while
  // others must be.
  // 
  // NOTE: Subclasses must always call their superclass's CopyInformation
  // method, so that all classes in the hierarchy get a chance to remove
  // keys they do not wish to be coppied. The subclass will not need to
  // explicilty copy the keys as it's handled here.
  virtual int CopyInformation(vtkInformation *infoFrom, int deep=1);
  //ETX

  static vtkInformationIntegerKey* GUI_HIDE();

protected:
  virtual void SetInformation( vtkInformation* );

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

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

  char* Name;

  bool RebuildArray;      // whether to rebuild the fast lookup data structure.

  vtkInformation* Information;

  //BTX
  class vtkInternalComponentNames;
  vtkInternalComponentNames* ComponentNames; //names for each component
  //ETX

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

#endif

---