1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
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 ()
* FreeMat_Documentation
* Visualization_Toolkit_Common_Classes
* Generated on Thu Jul 25 2013 17:18:30 for FreeMat by
doxygen_ 1.8.1.1
|
