def testExceptions(self):
"Test if the right assertion errors are raised."
# Test if bit arrays raise an exception.
vtk_arr = vtk.vtkBitArray()
vtk_arr.InsertNextValue(0)
vtk_arr.InsertNextValue(1)
self.assertRaises(AssertionError, vtk_to_numpy, vtk_arr)
def testBitArrayArguments(self):
a = vtk.vtkBitArray()
a.SetNumberOfComponents(2)
a.SetNumberOfTuples(1)
ti = [0,1]
to = [0,0]
a.SetTuple(0, ti)
a.GetTuple(0, to);
self.assertEqual(ti, [int(x) for x in to])
def testExceptions(self):
"Test if the right assertion errors are raised."
# Test if bit arrays raise an exception.
vtk_arr = vtk.vtkBitArray()
vtk_arr.InsertNextValue(0)
vtk_arr.InsertNextValue(1)
self.assertRaises(AssertionError, vtk_to_numpy, vtk_arr)
# Test if non-contiguous arrays are not supported.
a = numpy.linspace(0, 1, 100)
a.shape = (10, 10)
x = a[::2,::2]
self.assertRaises(AssertionError, numpy_to_vtk, x)
def testBitArray(self):
"""Test the special case of the bit array."""
if sys.hexversion < 0x02070000:
return
# bit array is actually stored as a byte array
a = vtk.vtkBitArray()
a.InsertNextValue(0)
a.InsertNextValue(1)
a.InsertNextValue(1)
a.InsertNextValue(0)
a.InsertNextValue(1)
m = memoryview(a)
self.assertEqual(m.format, 'B')
self.assertEqual(m.itemsize, 1)
self.assertEqual(m.shape, (1,))
# test the contents of the memoryview
self.assertEqual(ord(m.tobytes()) & 0xF8, 0x68)
def test_array2vtk(self):
"""Test Numeric array to VTK array conversion and vice-versa."""
# Put all the test arrays here.
t_z = []
# Test the different types of arrays.
t_z.append(numpy.array([-128, 0, 127], numpy.int8))
# FIXME: character arrays are a problem since there is no
# unique mapping to a VTK data type and back.
#t_z.append(numpy.array([-128, 0, 127], numpy.character))
t_z.append(numpy.array([-32768, 0, 32767], numpy.int16))
t_z.append(numpy.array([-2147483648, 0, 2147483647], numpy.int32))
t_z.append(numpy.array([0, 255], numpy.uint8))
t_z.append(numpy.array([0, 65535], numpy.uint16))
t_z.append(numpy.array([0, 4294967295L], numpy.uint32))
t_z.append(numpy.array([-1.0e38, 0, 1.0e38], 'f'))
t_z.append(numpy.array([-1.0e299, 0, 1.0e299], 'd'))
# Check multi-component arrays.
t_z.append(numpy.array([[1], [2], [300]], 'd'))
t_z.append(numpy.array([[1, 20], [300, 4000]], 'd'))
t_z.append(numpy.array([[1, 2, 3], [4, 5, 6]], 'f'))
t_z.append(numpy.array([[1, 2, 3],[4, 5, 6]], 'd'))
t_z.append(numpy.array([[1, 2, 3, 400],[4, 5, 6, 700]],
'd'))
t_z.append(numpy.array([range(9),range(10,19)], 'f'))
# Test if a Python list also works.
t_z.append(numpy.array([[1., 2., 3., 400.],[4, 5, 6, 700]],
'd'))
# Test if arrays with number of components not in [1,2,3,4,9] work.
t_z.append(numpy.array([[1, 2, 3, 400, 5000],
[4, 5, 6, 700, 8000]], 'd'))
t_z.append(numpy.array([range(10), range(10,20)], 'd'))
for z in t_z:
vtk_arr = array_handler.array2vtk(z)
# Test for memory leaks.
self.assertEqual(vtk_arr.GetReferenceCount(),
array_handler.BASE_REFERENCE_COUNT)
self._check_arrays(z, vtk_arr)
z1 = array_handler.vtk2array(vtk_arr)
if len(z.shape) == 1:
self.assertEqual(len(z1.shape), 1)
if z.dtype.char != 'c':
#print z1
self.assertEqual(sum(numpy.ravel(z) - numpy.ravel(z1)), 0)
else:
#print z1.astype('c')
self.assertEqual(z, z1.astype('c'))
# Check if type conversion works correctly.
z = numpy.array([-128, 0, 127], numpy.int8)
vtk_arr = vtk.vtkDoubleArray()
ident = id(vtk_arr)
vtk_arr = array_handler.array2vtk(z, vtk_arr)
# Make sure this is the same array!
self.assertEqual(ident, id(vtk_arr))
self._check_arrays(z, vtk_arr)
# Check the vtkBitArray.
vtk_arr = vtk.vtkBitArray()
vtk_arr.InsertNextValue(0)
vtk_arr.InsertNextValue(1)
vtk_arr.InsertNextValue(0)
vtk_arr.InsertNextValue(1)
arr = array_handler.vtk2array(vtk_arr)
self.assertEqual(numpy.sum(arr - [0,1,0,1]), 0)
vtk_arr = array_handler.array2vtk(arr, vtk_arr)
self.assertEqual(vtk_arr.GetValue(0), 0)
self.assertEqual(vtk_arr.GetValue(1), 1)
self.assertEqual(vtk_arr.GetValue(2), 0)
self.assertEqual(vtk_arr.GetValue(3), 1)
# ----------------------------------------
# Test if the array is copied or not.
a = numpy.array([[1, 2, 3],[4, 5, 6]], 'd')
vtk_arr = array_handler.array2vtk(a)
# Change the numpy array and see if the changes are
# reflected in the VTK array.
a[0] = [10.0, 20.0, 30.0]
self.assertEqual(vtk_arr.GetTuple3(0), (10., 20., 30.))
# Make sure the cache is doing its job.
key = vtk_arr.__this__
z = array_handler._array_cache.get(vtk_arr)
self.assertEqual(numpy.sum(z - numpy.ravel(a)), 0.0)
l1 = len(array_handler._array_cache)
# del the Numeric array and see if this still works.
del a
self.assertEqual(vtk_arr.GetTuple3(0), (10., 20., 30.))
# Check the cache -- just making sure.
self.assertEqual(len(array_handler._array_cache), l1)
# Delete the VTK array and see if the cache is cleared.
del vtk_arr
self.assertEqual(len(array_handler._array_cache), l1-1)
self.assertEqual(array_handler._array_cache._cache.has_key(key),
False)
# Make sure bit arrays are copied.
vtk_arr = vtk.vtkBitArray()
a = numpy.array([0,1,0,1], numpy.int32)
vtk_arr = array_handler.array2vtk(a, vtk_arr)
del a
self.assertEqual(vtk_arr.GetValue(0), 0)
self.assertEqual(vtk_arr.GetValue(1), 1)
self.assertEqual(vtk_arr.GetValue(2), 0)
self.assertEqual(vtk_arr.GetValue(3), 1)
# Make sure the code at least runs for all the non-complex
# numerical dtypes in numpy.
for dtype in (numpy.sctypes['int'] + numpy.sctypes['uint'] +
numpy.sctypes['float']):
array_handler.array2vtk(numpy.zeros((1,), dtype=dtype))
"""
Same TestHyperTreeGrid2DFull
with build mask
Warning : only to call SubdivideLeaf on leaf cell don't masked
"""
import vtk
htg = vtk.vtkHyperTreeGrid()
htg.Initialize()
scalarArray = vtk.vtkUnsignedCharArray()
scalarArray.SetName('scalar')
scalarArray.SetNumberOfValues(0)
htg.GetPointData().AddArray(scalarArray)
mask = vtk.vtkBitArray()
mask.SetName('mask')
mask.SetNumberOfValues(26)
mask.FillComponent(0, 0)
htg.SetMask(mask)
htg.SetDimensions([4, 3, 1])
htg.SetBranchFactor(2)
# rectilinear grid coordinates
xValues = vtk.vtkDoubleArray()
xValues.SetNumberOfValues(4)
xValues.SetValue(0, -1)
xValues.SetValue(1, 0)
xValues.SetValue(2, 1)
xValues.SetValue(3, 2)
def _create_vtkarray(X, name):
import numpy as np
from vtk import vtkBitArray, vtkIntArray, vtkDoubleArray, vtkCharArray
# If something isn't a Numpy array already, try to make it one.
if not isinstance(X, np.ndarray) and not isinstance(X, str):
X = np.array(X)
# This could be a lot more fine-grained:
# vtkLongLongArray, vtkFloatArray,...
if isinstance(X, str) or X.dtype.kind == 'S':
array = vtkCharArray()
elif X.dtype == bool:
array = vtkBitArray()
elif X.dtype == int:
array = vtkIntArray()
elif X.dtype == float:
array = vtkDoubleArray()
elif X.dtype == complex:
# Convert complex arrays to double.
Y = np.empty((len(X),2), dtype=float)
if len(X.shape) == 1:
Y[:,0] = X.real
Y[:,1] = X.imag
elif len(X.shape) == 2:
Y[:,0] = X[:,0].real
Y[:,1] = X[:,0].imag
else:
raise RuntimeError()
X = Y
array = vtkDoubleArray()
else:
raise TypeError('Unknown VTK data type', X.dtype, '.')
# For some reason, setting the number of tuples and then using
# SetNextTuple() or similar doesn't seem to work:
# The application segfaults or, worse, yields an irrecoverable
# glibc memory corruption.
# Most likely the cause: You have to call SetNumberOfTuples()
# AFTER SetNumberOfComponents().
#array.SetNumberOfTuples(X.shape[0])
# Special treatment for strings:
if isinstance(X, str):
array.SetNumberOfComponents(len(X))
array.SetNumberOfTuples(1)
array.SetTupleValue(0, X)
elif len(X.shape) == 0:
array.SetNumberOfComponents(1)
# Set values.
array.InsertNextValue(X)
elif len(X.shape) == 1:
array.SetNumberOfComponents(1)
# Set values.
for k in xrange(X.shape[0]):
array.InsertNextValue(X[k])
elif len(X.shape) == 2:
array.SetNumberOfComponents(X.shape[1])
# Set values.
for k in xrange(X.shape[0]):
for k2 in xrange(X.shape[1]):
array.InsertNextValue(X[k][k2])
else:
raise ValueError('Don''t know what to do with many-dimensional array ''%s''.' % name)
array.SetName(name)
return array
def test_array2vtk(self):
"""Test Numeric array to VTK array conversion and vice-versa."""
# Put all the test arrays here.
t_z = []
# Test the different types of arrays.
t_z.append(numpy.array([-128, 0, 127], numpy.int8))
# FIXME: character arrays are a problem since there is no
# unique mapping to a VTK data type and back.
#t_z.append(numpy.array([-128, 0, 127], numpy.character))
t_z.append(numpy.array([-32768, 0, 32767], numpy.int16))
t_z.append(numpy.array([-2147483648, 0, 2147483647], numpy.int32))
t_z.append(numpy.array([0, 255], numpy.uint8))
t_z.append(numpy.array([0, 65535], numpy.uint16))
t_z.append(numpy.array([0, 4294967295], numpy.uint32))
t_z.append(numpy.array([-1.0e38, 0, 1.0e38], 'f'))
t_z.append(numpy.array([-1.0e299, 0, 1.0e299], 'd'))
# Check multi-component arrays.
t_z.append(numpy.array([[1], [2], [300]], 'd'))
t_z.append(numpy.array([[1, 20], [300, 4000]], 'd'))
t_z.append(numpy.array([[1, 2, 3], [4, 5, 6]], 'f'))
t_z.append(numpy.array([[1, 2, 3], [4, 5, 6]], 'd'))
t_z.append(numpy.array([[1, 2, 3, 400], [4, 5, 6, 700]], 'd'))
t_z.append(numpy.array([list(range(9)), list(range(10, 19))], 'f'))
# Test if a Python list also works.
t_z.append(numpy.array([[1., 2., 3., 400.], [4, 5, 6, 700]], 'd'))
# Test if arrays with number of components not in [1,2,3,4,9] work.
t_z.append(
numpy.array([[1, 2, 3, 400, 5000], [4, 5, 6, 700, 8000]], 'd'))
t_z.append(numpy.array([list(range(10)), list(range(10, 20))], 'd'))
for z in t_z:
vtk_arr = array_handler.array2vtk(z)
# Test for memory leaks.
self.assertEqual(vtk_arr.GetReferenceCount(),
array_handler.BASE_REFERENCE_COUNT)
self._check_arrays(z, vtk_arr)
z1 = array_handler.vtk2array(vtk_arr)
if len(z.shape) == 1:
self.assertEqual(len(z1.shape), 1)
if z.dtype.char != 'c':
#print z1
self.assertEqual(sum(numpy.ravel(z) - numpy.ravel(z1)), 0)
else:
#print z1.astype('c')
self.assertEqual(z, z1.astype('c'))
# Check if type conversion works correctly.
z = numpy.array([-128, 0, 127], numpy.int8)
vtk_arr = vtk.vtkDoubleArray()
ident = id(vtk_arr)
vtk_arr = array_handler.array2vtk(z, vtk_arr)
# Make sure this is the same array!
self.assertEqual(ident, id(vtk_arr))
self._check_arrays(z, vtk_arr)
# Check the vtkBitArray.
vtk_arr = vtk.vtkBitArray()
vtk_arr.InsertNextValue(0)
vtk_arr.InsertNextValue(1)
vtk_arr.InsertNextValue(0)
vtk_arr.InsertNextValue(1)
arr = array_handler.vtk2array(vtk_arr)
self.assertEqual(numpy.sum(arr - [0, 1, 0, 1]), 0)
vtk_arr = array_handler.array2vtk(arr, vtk_arr)
self.assertEqual(vtk_arr.GetValue(0), 0)
self.assertEqual(vtk_arr.GetValue(1), 1)
self.assertEqual(vtk_arr.GetValue(2), 0)
self.assertEqual(vtk_arr.GetValue(3), 1)
# ----------------------------------------
# Test if the array is copied or not.
a = numpy.array([[1, 2, 3], [4, 5, 6]], 'd')
vtk_arr = array_handler.array2vtk(a)
# Change the numpy array and see if the changes are
# reflected in the VTK array.
a[0] = [10.0, 20.0, 30.0]
self.assertEqual(vtk_arr.GetTuple3(0), (10., 20., 30.))
# Make sure the cache is doing its job.
key = vtk_arr.__this__
z = array_handler._array_cache.get(vtk_arr)
self.assertEqual(numpy.sum(z - numpy.ravel(a)), 0.0)
l1 = len(array_handler._array_cache)
# del the Numeric array and see if this still works.
del a
self.assertEqual(vtk_arr.GetTuple3(0), (10., 20., 30.))
# Check the cache -- just making sure.
self.assertEqual(len(array_handler._array_cache), l1)
# Delete the VTK array and see if the cache is cleared.
del vtk_arr
self.assertEqual(len(array_handler._array_cache), l1 - 1)
self.assertEqual(key in array_handler._array_cache._cache, False)
# Make sure bit arrays are copied.
vtk_arr = vtk.vtkBitArray()
a = numpy.array([0, 1, 0, 1], numpy.int32)
vtk_arr = array_handler.array2vtk(a, vtk_arr)
del a
self.assertEqual(vtk_arr.GetValue(0), 0)
self.assertEqual(vtk_arr.GetValue(1), 1)
self.assertEqual(vtk_arr.GetValue(2), 0)
self.assertEqual(vtk_arr.GetValue(3), 1)
# Make sure the code at least runs for all the non-complex
# numerical dtypes in numpy.
float_types = [
x for x in numpy.sctypes['float']
if x().dtype.name not in ('float16', 'float128')
]
for dtype in (numpy.sctypes['int'] + numpy.sctypes['uint'] +
float_types):
print(dtype)
array_handler.array2vtk(numpy.zeros((1, ), dtype=dtype))
without mask
during HTG build we build scalar, used Global Index implicit with SetGlobalIndexStart
SetGlobalIndexStart, one call by HT
"""
import vtk
htg = vtk.vtkHyperTreeGrid()
htg.Initialize()
scalarArray = vtk.vtkDoubleArray()
scalarArray.SetName('scalar')
scalarArray.SetNumberOfValues(0)
htg.GetPointData().AddArray(scalarArray)
htg.GetPointData().SetActiveScalars('scalar')
mask = vtk.vtkBitArray()
mask.SetName('mask')
mask.SetNumberOfValues(52)
mask.FillComponent(0, 0)
htg.SetMask(mask)
htg.SetDimensions([4, 3, 3])
htg.SetBranchFactor(2)
# Rectilinear grid coordinates
xValues = vtk.vtkDoubleArray()
xValues.SetNumberOfValues(4)
xValues.SetValue(0, -1)
xValues.SetValue(1, 0)
xValues.SetValue(2, 1)
xValues.SetValue(3, 2)
# compose vtkPolyData
shapes.Update()
polyData = shapes.GetOutput()
for colname in df.columns:
if colname == 'geometry':
continue
dtype = df[colname].dtype
#print (colname,dtype)
# define attribute as array
if dtype in ['int64']:
vtk_arr = vtk.vtkIntArray()
elif dtype in ['float64']:
vtk_arr = vtk.vtkFloatArray()
elif dtype in ['bool']:
vtk_arr = vtk.vtkBitArray()
else:
vtk_arr = vtk.vtkStringArray()
vtk_arr.SetNumberOfComponents(1)
vtk_arr.SetName(colname)
val = row[colname]
# some different datatypes could be saved as strings
if isinstance(vtk_arr, vtk.vtkStringArray):
val = val.encode('utf-8')
for _ in range(polyData.GetNumberOfCells()):
vtk_arr.InsertNextValue(val)
polyData.GetCellData().AddArray(vtk_arr)
if self.GetOutput().IsA("vtkMultiBlockDataSet"):
# use index if label is not defined
if LABEL:
