def test_set_id_type_array(self):
N = 5
a = numpy.zeros((N,4), ID_TYPE_CODE)
a[:,1] = 1
a[:,2] = 2
a[:,3] = 3
def diff_arr(x, y):
return numpy.sum(numpy.ravel(x) - numpy.ravel(y[:,1:]))
# Test contiguous arrays.
b = numpy.zeros((N,5), ID_TYPE_CODE)
set_id_type_array(a, b)
self.assertEqual(diff_arr(a, b), 0)
# Test non-contiguous arrays.
b = numpy.zeros((N,3), ID_TYPE_CODE)
set_id_type_array(a[:,::2], b)
self.assertEqual(diff_arr(a[:,::2], b), 0)
# Test 1D array.
b = numpy.zeros(N*5, ID_TYPE_CODE)
set_id_type_array(a, b)
self.assertEqual(diff_arr(a, numpy.reshape(b, (N,5))), 0)
# Test assertions.
d = a.astype('d')
b = numpy.zeros((N, 5), ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array,
d, b)
# B should b contiguous.
b = numpy.zeros((N, 10), ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array,
a, b[:,::2])
self.assertRaises(AssertionError, set_id_type_array,
a[0], b)
# Test size check assertion.
b = numpy.zeros((N, 4), ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array,
a, b)
b = numpy.zeros(N*6, ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array,
a, b)
# This should work!
set_id_type_array(a, b[:N*5])
self.assertEqual(diff_arr(a, numpy.reshape(b[:N*5], (N,5))), 0)
def test_set_id_type_array(self):
N = 5
a = numpy.zeros((N, 4), ID_TYPE_CODE)
a[:, 1] = 1
a[:, 2] = 2
a[:, 3] = 3
def diff_arr(x, y):
return numpy.sum(numpy.ravel(x) - numpy.ravel(y[:, 1:]))
# Test contiguous arrays.
b = numpy.zeros((N, 5), ID_TYPE_CODE)
set_id_type_array(a, b)
self.assertEqual(diff_arr(a, b), 0)
# Test non-contiguous arrays.
b = numpy.zeros((N, 3), ID_TYPE_CODE)
set_id_type_array(a[:, ::2], b)
self.assertEqual(diff_arr(a[:, ::2], b), 0)
# Test 1D array.
b = numpy.zeros(N * 5, ID_TYPE_CODE)
set_id_type_array(a, b)
self.assertEqual(diff_arr(a, numpy.reshape(b, (N, 5))), 0)
# Test assertions.
d = a.astype('d')
b = numpy.zeros((N, 5), ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array, d, b)
# B should b contiguous.
b = numpy.zeros((N, 10), ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array, a, b[:, ::2])
self.assertRaises(AssertionError, set_id_type_array, a[0], b)
# Test size check assertion.
b = numpy.zeros((N, 4), ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array, a, b)
b = numpy.zeros(N * 6, ID_TYPE_CODE)
self.assertRaises(AssertionError, set_id_type_array, a, b)
# This should work!
set_id_type_array(a, b[:N * 5])
self.assertEqual(diff_arr(a, numpy.reshape(b[:N * 5], (N, 5))), 0)
def array2vtkCellArray(num_array, vtk_array=None):
"""Given a nested Python list or a numpy array, this method
creates a vtkCellArray instance and returns it.
A variety of input arguments are supported as described in the
Parameter documentation. If numpy arrays are given, this method
is highly efficient. This function is most efficient if the
passed numpy arrays have a typecode `ID_TYPE_CODE`. Otherwise a
typecast is necessary and this involves an extra copy. This
method *always copies* the input data.
An alternative and more efficient way to build the connectivity
list is to create a vtkIdTypeArray having data of the form
(npts,p0,p1,...p(npts-1), repeated for each cell) and then call
<vtkCellArray_instance>.SetCells(n_cell, id_list).
Parameters
----------
- num_array : numpy array or Python list/tuple
Valid values are:
1. A Python list of 1D lists. Each 1D list can contain one
cell connectivity list. This is very slow and is to be
used only when efficiency is of no consequence.
2. A 2D numpy array with the cell connectivity list.
3. A Python list of 2D numpy arrays. Each numeric array can
have a different shape. This makes it easy to generate a
cell array having cells of different kinds.
- vtk_array : `vtkCellArray` (default: `None`)
If an optional `vtkCellArray` instance, is passed as an argument
then a new array is not created and returned. The passed array
is itself modified and returned.
Example
-------
>>> a = [[0], [1, 2], [3, 4, 5], [6, 7, 8, 9]]
>>> cells = array_handler.array2vtkCellArray(a)
>>> a = numpy.array([[0,1,2], [3,4,5], [6,7,8]], 'l')
>>> cells = array_handler.array2vtkCellArray(a)
>>> l_a = [a[:,:1], a[:2,:2], a]
>>> cells = array_handler.array2vtkCellArray(l_a)
"""
if vtk_array:
cells = vtk_array
else:
cells = vtk.vtkCellArray()
assert cells.GetClassName() == 'vtkCellArray', \
'Second argument must be a `vtkCellArray` instance.'
if len(num_array) == 0:
return cells
########################################
# Internal functions.
def _slow_array2cells(z, cells):
cells.Reset()
vtk_ids = vtk.vtkIdList()
for i in z:
vtk_ids.Reset()
for j in i:
vtk_ids.InsertNextId(j)
cells.InsertNextCell(vtk_ids)
def _get_tmp_array(arr):
try:
tmp_arr = numpy.asarray(arr, ID_TYPE_CODE)
except TypeError:
tmp_arr = arr.astype(ID_TYPE_CODE)
return tmp_arr
def _set_cells(cells, n_cells, id_typ_arr):
vtk_arr = vtk.vtkIdTypeArray()
array2vtk(id_typ_arr, vtk_arr)
cells.SetCells(n_cells, vtk_arr)
########################################
msg = "Invalid argument. Valid types are a Python list of lists,"\
" a Python list of numpy arrays, or a numpy array."
if issubclass(type(num_array), (types.ListType, types.TupleType)):
assert len(num_array[0]) > 0, "Input array must be 2D."
tp = type(num_array[0])
if issubclass(tp, types.ListType): # Pure Python list.
_slow_array2cells(num_array, cells)
return cells
elif issubclass(tp, numpy.ndarray): # List of arrays.
# Check shape of array and find total size.
tot_size = 0
n_cells = 0
for arr in num_array:
assert len(arr.shape) == 2, "Each array must be 2D"
shp = arr.shape
tot_size += shp[0] * (shp[1] + 1)
n_cells += shp[0]
# Create an empty array.
id_typ_arr = numpy.empty((tot_size, ), ID_TYPE_CODE)
# Now populate it with the ids.
count = 0
for arr in num_array:
tmp_arr = _get_tmp_array(arr)
shp = arr.shape
sz = shp[0] * (shp[1] + 1)
set_id_type_array(tmp_arr, id_typ_arr[count:count + sz])
count += sz
# Now set them cells.
_set_cells(cells, n_cells, id_typ_arr)
return cells
else:
raise TypeError, msg
elif issubclass(type(num_array), numpy.ndarray):
assert len(num_array.shape) == 2, "Input array must be 2D."
tmp_arr = _get_tmp_array(num_array)
shp = tmp_arr.shape
id_typ_arr = numpy.empty((shp[0] * (shp[1] + 1), ), ID_TYPE_CODE)
set_id_type_array(tmp_arr, id_typ_arr)
_set_cells(cells, shp[0], id_typ_arr)
return cells
else:
raise TypeError, msg
def array2vtkCellArray(num_array, vtk_array=None):
"""Given a nested Python list or a numpy array, this method
creates a vtkCellArray instance and returns it.
A variety of input arguments are supported as described in the
Parameter documentation. If numpy arrays are given, this method
is highly efficient. This function is most efficient if the
passed numpy arrays have a typecode `ID_TYPE_CODE`. Otherwise a
typecast is necessary and this involves an extra copy. This
method *always copies* the input data.
An alternative and more efficient way to build the connectivity
list is to create a vtkIdTypeArray having data of the form
(npts,p0,p1,...p(npts-1), repeated for each cell) and then call
<vtkCellArray_instance>.SetCells(n_cell, id_list).
Parameters
----------
- num_array : numpy array or Python list/tuple
Valid values are:
1. A Python list of 1D lists. Each 1D list can contain one
cell connectivity list. This is very slow and is to be
used only when efficiency is of no consequence.
2. A 2D numpy array with the cell connectivity list.
3. A Python list of 2D numpy arrays. Each numeric array can
have a different shape. This makes it easy to generate a
cell array having cells of different kinds.
- vtk_array : `vtkCellArray` (default: `None`)
If an optional `vtkCellArray` instance, is passed as an argument
then a new array is not created and returned. The passed array
is itself modified and returned.
Example
-------
>>> a = [[0], [1, 2], [3, 4, 5], [6, 7, 8, 9]]
>>> cells = array_handler.array2vtkCellArray(a)
>>> a = numpy.array([[0,1,2], [3,4,5], [6,7,8]], 'l')
>>> cells = array_handler.array2vtkCellArray(a)
>>> l_a = [a[:,:1], a[:2,:2], a]
>>> cells = array_handler.array2vtkCellArray(l_a)
"""
if vtk_array:
cells = vtk_array
else:
cells = vtk.vtkCellArray()
assert cells.GetClassName() == 'vtkCellArray', \
'Second argument must be a `vtkCellArray` instance.'
if len(num_array) == 0:
return cells
########################################
# Internal functions.
def _slow_array2cells(z, cells):
cells.Reset()
vtk_ids = vtk.vtkIdList()
for i in z:
vtk_ids.Reset()
for j in i:
vtk_ids.InsertNextId(j)
cells.InsertNextCell(vtk_ids)
def _get_tmp_array(arr):
try:
tmp_arr = numpy.asarray(arr, ID_TYPE_CODE)
except TypeError:
tmp_arr = arr.astype(ID_TYPE_CODE)
return tmp_arr
def _set_cells(cells, n_cells, id_typ_arr):
vtk_arr = vtk.vtkIdTypeArray()
array2vtk(id_typ_arr, vtk_arr)
cells.SetCells(n_cells, vtk_arr)
########################################
msg = "Invalid argument. Valid types are a Python list of lists,"\
" a Python list of numpy arrays, or a numpy array."
if issubclass(type(num_array), (types.ListType, types.TupleType)):
assert len(num_array[0]) > 0, "Input array must be 2D."
tp = type(num_array[0])
if issubclass(tp, types.ListType): # Pure Python list.
_slow_array2cells(num_array, cells)
return cells
elif issubclass(tp, numpy.ndarray): # List of arrays.
# Check shape of array and find total size.
tot_size = 0
n_cells = 0
for arr in num_array:
assert len(arr.shape) == 2, "Each array must be 2D"
shp = arr.shape
tot_size += shp[0]*(shp[1] + 1)
n_cells += shp[0]
# Create an empty array.
id_typ_arr = numpy.empty((tot_size,), ID_TYPE_CODE)
# Now populate it with the ids.
count = 0
for arr in num_array:
tmp_arr = _get_tmp_array(arr)
shp = arr.shape
sz = shp[0]*(shp[1] + 1)
set_id_type_array(tmp_arr, id_typ_arr[count:count+sz])
count += sz
# Now set them cells.
_set_cells(cells, n_cells, id_typ_arr)
return cells
else:
raise TypeError, msg
elif issubclass(type(num_array), numpy.ndarray):
assert len(num_array.shape) == 2, "Input array must be 2D."
tmp_arr = _get_tmp_array(num_array)
shp = tmp_arr.shape
id_typ_arr = numpy.empty((shp[0]*(shp[1] + 1),), ID_TYPE_CODE)
set_id_type_array(tmp_arr, id_typ_arr)
_set_cells(cells, shp[0], id_typ_arr)
return cells
else:
raise TypeError, msg
