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 "vtkCommonCoreModule.h" // For export macro
#include "vtkObject.h"
#include "vtkVariant.h" // for variant arguments

class vtkArrayIterator;
class vtkDataArray;
class vtkIdList;
class vtkIdTypeArray;
class vtkInformation;
class vtkInformationDoubleVectorKey;
class vtkInformationIntegerKey;
class vtkInformationInformationVectorKey;
class vtkInformationVariantVectorKey;
class vtkVariantArray;

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

  virtual int Allocate(vtkIdType numValues, 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_INT_MAX);
  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 numTuples) = 0;

  virtual void SetNumberOfValues(vtkIdType numValues);

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

  inline vtkIdType GetNumberOfValues() const
  {
    return (this->MaxId + 1);
  }

  virtual void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx,
                        vtkAbstractArray *source) = 0;

  virtual void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx,
                           vtkAbstractArray* source) = 0;

  virtual void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds,
                            vtkAbstractArray* source) = 0;

  virtual void InsertTuples(vtkIdType dstStart, vtkIdType n, vtkIdType srcStart,
                            vtkAbstractArray* source) = 0;

  virtual vtkIdType InsertNextTuple(vtkIdType srcTupleIdx,
                                    vtkAbstractArray* source) = 0;

  virtual void GetTuples(vtkIdList *tupleIds, vtkAbstractArray* output);

  virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray *output);

  virtual bool HasStandardMemoryLayout();

  virtual void *GetVoidPointer(vtkIdType valueIdx) = 0;

  virtual void DeepCopy(vtkAbstractArray* da);

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

  virtual void InterpolateTuple(vtkIdType dstTupleIdx,
    vtkIdType srcTupleIdx1, vtkAbstractArray* source1,
    vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) =0;

  virtual void Squeeze() = 0;

  virtual int Resize(vtkIdType numTuples) = 0;


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

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

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

  enum DeleteMethod
  {
    VTK_DATA_ARRAY_FREE,
    VTK_DATA_ARRAY_DELETE,
    VTK_DATA_ARRAY_ALIGNED_FREE
  };


  virtual void SetVoidArray(void *vtkNotUsed(array),
                            vtkIdType vtkNotUsed(size),
                            int vtkNotUsed(save)) =0;
  virtual void SetVoidArray(void *array, vtkIdType size, int save,
                            int vtkNotUsed(deleteMethod))
    {this->SetVoidArray(array,size,save);};

  virtual void ExportToVoidPointer(void *out_ptr);

  virtual unsigned long GetActualMemorySize() = 0;


  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);

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

  VTK_NEWINSTANCE
  static vtkAbstractArray* CreateArray(int dataType);

  virtual int IsNumeric() = 0;

  VTK_NEWINSTANCE
  virtual vtkArrayIterator* NewIterator() = 0;

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


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

  virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
    VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues());

  virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)
    VTK_EXPECTS(0 <= valueIdx) = 0;

  virtual void SetVariantValue(vtkIdType valueIdx, vtkVariant value)
    VTK_EXPECTS(0 <= valueIdx && valueIdx < GetNumberOfValues()) = 0;

  virtual void DataChanged() = 0;

  virtual void ClearLookup() = 0;

  virtual void GetProminentComponentValues(int comp, vtkVariantArray* values,
    double uncertainty = 1.e-6, double minimumProminence = 1.e-3);

  // 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();
  bool HasInformation(){ return this->Information!=nullptr; }

  virtual int CopyInformation(vtkInformation *infoFrom, int deep=1);

  static vtkInformationIntegerKey* GUI_HIDE();

  static vtkInformationInformationVectorKey* PER_COMPONENT();

  static vtkInformationInformationVectorKey* PER_FINITE_COMPONENT();

  void Modified() override;

  static vtkInformationVariantVectorKey* DISCRETE_VALUES();

  static vtkInformationDoubleVectorKey* DISCRETE_VALUE_SAMPLE_PARAMETERS();

  // Deprecated.  Use vtkAbstractArray::MaxDiscreteValues instead.
  enum {
    MAX_DISCRETE_VALUES = 32
  };


  vtkGetMacro(MaxDiscreteValues, unsigned int);
  vtkSetMacro(MaxDiscreteValues, unsigned int);

  enum {
    AbstractArray = 0,
    DataArray,
    AoSDataArrayTemplate,
    SoADataArrayTemplate,
    TypedDataArray,
    MappedDataArray,

    DataArrayTemplate = AoSDataArrayTemplate 
  };

  virtual int GetArrayType()
  {
    return AbstractArray;
  }

protected:
  // Construct object with default tuple dimension (number of components) of 1.
  vtkAbstractArray();
  ~vtkAbstractArray() override;

  virtual void SetInformation( vtkInformation* );

  virtual void UpdateDiscreteValueSet(double uncertainty, double minProminence);

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

  // maximum number of prominent values before array is considered continuous.
  unsigned int MaxDiscreteValues;

  char* Name;

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

  vtkInformation* Information;

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

private:
  vtkAbstractArray(const vtkAbstractArray&) = delete;
  void operator=(const vtkAbstractArray&) = delete;
};


template <typename ArrayT>
struct vtkArrayDownCast_impl
{
  inline ArrayT* operator()(vtkAbstractArray* array)
  {
    return ArrayT::SafeDownCast(array);
  }
};

template <typename ArrayT>
ArrayT* vtkArrayDownCast(vtkAbstractArray *array)
{
  // The default vtkArrayDownCast_impl struct uses SafeDownCast, but is
  // specialized for arrays that support FastDownCast.
  return vtkArrayDownCast_impl<ArrayT>()(array);
}


#define vtkArrayDownCast_FastCastMacro(ArrayT) \
  template <> struct vtkArrayDownCast_impl<ArrayT> \
  { \
    inline ArrayT* operator()(vtkAbstractArray *array) \
    { \
      return ArrayT::FastDownCast(array); \
    } \
  };



#define vtkArrayDownCast_TemplateFastCastMacro(ArrayT) \
  template <typename ValueT> struct vtkArrayDownCast_impl<ArrayT<ValueT> > \
  { \
    inline ArrayT<ValueT>* operator()(vtkAbstractArray *array) \
    { \
      return ArrayT<ValueT>::FastDownCast(array); \
    } \
  };


#endif