FreeMat

- Main Page
- Related Pages

vtkAbstractArray

Section: Visualization Toolkit Common Classes

# Usage

vtkAbstractArray is an abstract superclass for data array objects. This class defines an API that all subclasses must support. The data type must be assignable and copy-constructible, but no other assumptions about its type are made. Most of the subclasses of this array deal with numeric data either as scalars or tuples of scalars. A program can use the IsNumeric() method to check whether an instance of vtkAbstractArray contains numbers. It is also possible to test for this by attempting to SafeDownCast an array to an instance of vtkDataArray, although this assumes that all numeric arrays will always be descended from vtkDataArray.

Every array has a character-string name. The naming of the array occurs automatically when it is instantiated, but you are free to change this name using the SetName() method. (The array name is used for data manipulation.)

To create an instance of class vtkAbstractArray, simply invoke its constructor as follows

      obj = vtkAbstractArray

# Methods

The class vtkAbstractArray has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the VTK sources, and may not be completely intelligible. When in doubt, consult the VTK website. In the methods listed below, `obj` is an instance of the vtkAbstractArray class.

- `string = obj.GetClassName ()`
- `int = obj.IsA (string name)`
- `vtkAbstractArray = obj.NewInstance ()`
- `vtkAbstractArray = obj.SafeDownCast (vtkObject o)`
- `int = obj.Allocate (vtkIdType sz, vtkIdType ext)` - Allocate memory for this array. Delete old storage only if necessary. Note that ext is no longer used.
- `obj.Initialize ()` - Release storage and reset array to initial state.
- `int = obj.GetDataType ()` - Return the underlying data type. An integer indicating data type is returned as specified in vtkSetGet.h.
- `int = obj.GetDataTypeSize ()` - Return the size of the underlying data type. For a bit, 0 is returned. For string 0 is returned. Arrays with variable length components return 0.
- `int = obj.GetElementComponentSize ()` - Return the size, in bytes, of the lowest-level element of an array. For vtkDataArray and subclasses this is the size of the data type. For vtkStringArray, this is sizeof(vtkStdString::value_type), which winds up being sizeof(char).
- `obj.SetNumberOfComponents (int )` - Set/Get the dimention (n) of the components. Must be >= 1. Make sure that this is set before allocation.
- `int = obj.GetNumberOfComponentsMinValue ()` - Set/Get the dimention (n) of the components. Must be >= 1. Make sure that this is set before allocation.
- `int = obj.GetNumberOfComponentsMaxValue ()` - Set/Get the dimention (n) of the components. Must be >= 1. Make sure that this is set before allocation.
- `int = obj.GetNumberOfComponents ()` - Set the number of tuples (a component group) in the array. Note that this may allocate space depending on the number of components. Also note that if allocation is performed no copy is performed so existing data will be lost (if data conservation is sought, one may use the Resize method instead).
- `obj.SetNumberOfTuples (vtkIdType number)` - Set the number of tuples (a component group) in the array. Note that this may allocate space depending on the number of components. Also note that if allocation is performed no copy is performed so existing data will be lost (if data conservation is sought, one may use the Resize method instead).
- `vtkIdType = obj.GetNumberOfTuples ()` - Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with SetNumberOfTuples() to allocate space.
- `obj.SetTuple (vtkIdType i, vtkIdType j, vtkAbstractArray source)` - Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with SetNumberOfTuples() to allocate space.
- `obj.InsertTuple (vtkIdType i, vtkIdType j, vtkAbstractArray source)` - Insert the jth tuple in the source array, at ith location in this array. Note that memory allocation is performed as necessary to hold the data.
- `vtkIdType = obj.InsertNextTuple (vtkIdType j, vtkAbstractArray source)` - Insert the jth tuple in the source array, at the end in this array. Note that memory allocation is performed as necessary to hold the data. Returns the location at which the data was inserted.
- `obj.GetTuples (vtkIdList ptIds, vtkAbstractArray output)` - Given a list of point ids, return an array of tuples. You must insure that the output array has been previously allocated with enough space to hold the data.
- `obj.GetTuples (vtkIdType p1, vtkIdType p2, vtkAbstractArray output)` - Get the tuples for the range of points ids specified (i.e., p1->p2 inclusive). You must insure that the output array has been previously allocated with enough space to hold the data.

- `obj.DeepCopy (vtkAbstractArray da)` - Deep copy of data. Implementation left to subclasses, which should support as many type conversions as possible given the data type.

  Subclasses should call vtkAbstractArray::DeepCopy() so that the information object (if one exists) is copied from da.

- `obj.InterpolateTuple (vtkIdType i, vtkIdList ptIndices, vtkAbstractArray source, double weights)` - Set the ith tuple in this array as the interpolated tuple value, given the ptIndices in the source array and associated interpolation weights. This method assumes that the two arrays are of the same type and strcuture.
- `obj.InterpolateTuple (vtkIdType i, vtkIdType id1, vtkAbstractArray source1, vtkIdType id2, vtkAbstractArray source2, double t)`
- `obj.Squeeze ()` - Resize object to just fit data requirement. Reclaims extra memory.
- `int = obj.Resize (vtkIdType numTuples)` - Resize the array while conserving the data. Returns 1 if resizing succeeded and 0 otherwise.
- `obj.Reset ()` - Return the size of the data.
- `vtkIdType = obj.GetSize ()` - What is the maximum id currently in the array.
- `vtkIdType = obj.GetMaxId ()` - This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the supplied array.
- `long = obj.GetActualMemorySize ()` - Return the memory in kilobytes consumed by this data array. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.
- `obj.SetName (string )` - Set/get array's name
- `string = obj.GetName ()` - Set/get array's name
- `string = obj.GetDataTypeAsString (void )` - Creates an array for dataType where dataType is one of VTK_BIT, VTK_CHAR, VTK_UNSIGNED_CHAR, VTK_SHORT, VTK_UNSIGNED_SHORT, VTK_INT, VTK_UNSIGNED_INT, VTK_LONG, VTK_UNSIGNED_LONG, VTK_DOUBLE, VTK_DOUBLE, VTK_ID_TYPE, VTK_STRING. Note that the data array returned has be deleted by the user.
- `int = obj.IsNumeric ()` - This method is here to make backward compatibility easier. It must return true if and only if an array contains numeric data.
- `vtkArrayIterator = obj.NewIterator ()` - Subclasses must override this method and provide the right kind of templated vtkArrayIteratorTemplate.
- `vtkIdType = obj.GetDataSize ()` - Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's API (i.e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.
- `obj.DataChanged ()` - Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's API (i.e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.
- `obj.ClearLookup ()` - Delete the associated fast lookup data structure on this array, if it exists. The lookup will be rebuilt on the next call to a lookup function.
- `vtkInformation = obj.GetInformation ()` - Get an information object that can be used to annotate the array. This will always return an instance of vtkInformation, if one is not currently associated with the array it will be created.
- `bool = obj.HasInformation ()`