def is_numpy_vtk_type(newscalars):
# Indicate whether the type is known/supported by VTK to NumPy routines.
try:
np_s.get_vtk_array_type(newscalars.dtype)
except TypeError:
return False
else:
return True
def is_numpy_vtk_type(newscalars):
# Indicate whether the type is known/supported by VTK to NumPy routines.
try:
np_s.get_vtk_array_type(newscalars.dtype)
except TypeError:
return False
else:
return True
def _check_array_types(self, table, types=[int, float, float]):
# Check data array types:
typ = table.GetColumn(0).GetDataType()
self.assertEqual(typ, nps.get_vtk_array_type(int))
typ = table.GetColumn(1).GetDataType()
self.assertEqual(typ, 13)
typ = table.GetColumn(2).GetDataType()
self.assertEqual(typ, nps.get_vtk_array_type(float))
return
def create_image(w, h, num_channels=1, dtype=np.uint8):
""" Creates a VTK image. """
image = vtk.vtkImageData()
image.SetExtent(0, w - 1, 0, h - 1, 0, 0)
image.SetSpacing(1., 1., 1.)
image.SetOrigin(0., 0., 0.)
if _is_vtk_5:
image.SetWholeExtent(image.GetExtent())
image.SetScalarType(get_vtk_array_type(dtype))
image.SetNumberOfScalarComponents(num_channels)
image.AllocateScalars()
else:
image.AllocateScalars(get_vtk_array_type(dtype), num_channels)
return image
def create_image(w, h, num_channels=1, dtype=np.uint8):
""" Creates a VTK image. """
image = vtk.vtkImageData()
image.SetExtent(0, w - 1, 0, h - 1, 0, 0)
image.SetSpacing(1., 1., 1.)
image.SetOrigin(0., 0., 0.)
if _is_vtk_5:
image.SetWholeExtent(image.GetExtent())
image.SetScalarType(get_vtk_array_type(dtype))
image.SetNumberOfScalarComponents(num_channels)
image.AllocateScalars()
else:
image.AllocateScalars(get_vtk_array_type(dtype), num_channels)
return image
def RegData_to_vtkImageData(grid, dtype=None):
"""Convert RegData to vtkImageData data."""
require_isinstance(grid, gd.RegData)
dat = grid.data
if dtype is None:
dtype = dat.dtype
else:
dtype = np.dtype(dtype)
#
vtype = numpy_support.get_vtk_array_type(dtype)
flt = dat.ravel(order='F')
varray = numpy_support.numpy_to_vtk(num_array=flt,
deep=True, array_type=vtype)
shape = grid.shape()
x0 = grid.x0()
dx = grid.dx()
imgdat = vtk.vtkImageData()
imgdat.GetPointData().SetScalars(varray)
imgdat.SetDimensions(shape[0], shape[1], shape[2])
imgdat.SetOrigin(x0[0],x0[1],x0[2])
imgdat.SetSpacing(dx[0], dx[1], dx[2])
return imgdat
def numpy_to_vtk(numpy_data, spacing):
"""
Parameters
----------
image : 3d numpy array
spacing : 解像度情報．(float, float, float)のタプル型．
Returns
-------
numpy data : vtk data
"""
w, h, d = numpy_data.shape
scalar_type = numpy_support.get_vtk_array_type(numpy_data.dtype)
# データ順序がC形式でなければならないため，Fortran形式から変換．
if numpy_data.flags.c_contiguous != True:
numpy_data = np.ndarray.flatten(numpy_data, order='F')
numpy_data = np.reshape(numpy_data, (w, h, d), order='C')
vtk_data = vtk.vtkImageImport()
vtk_data.SetDataScalarType(scalar_type)
vtk_data.SetDataSpacing(spacing)
vtk_data.SetDataOrigin(0, 0, 0)
vtk_data.SetDataExtent(0, w - 1, 0, h - 1, 0, d - 1)
vtk_data.SetWholeExtent(0, w - 1, 0, h - 1, 0, d - 1)
vtk_data.SetNumberOfScalarComponents(1)
vtk_data.CopyImportVoidPointer(numpy_data, numpy_data.nbytes)
vtk_data.Update()
return vtk_data
def to_vtk(n_array, spacing):
dz, dy, dx = n_array.shape
n_array.shape = dx * dy * dz
print n_array.shape
v_image = numpy_support.numpy_to_vtk(n_array)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetDimensions(dx, dy, dz)
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
#image.SetNumberOfScalarComponents(1)
image.SetExtent(0, dx - 1, 0, dy - 1, 0, dz - 1)
#image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), 1)
image.GetPointData().SetScalars(v_image)
#image.Update()
image_copy = vtk.vtkImageData()
image_copy.DeepCopy(image)
#image_copy.Update()
n_array.shape = dz, dy, dx
return image_copy
def to_vtk_mask(n_array, spacing=(1.0, 1.0, 1.0), origin=(0.0, 0.0, 0.0)):
dz, dy, dx = n_array.shape
ox, oy, oz = origin
sx, sy, sz = spacing
ox -= sx
oy -= sy
oz -= sz
v_image = numpy_support.numpy_to_vtk(n_array.flat)
extent = (0, dx - 1, 0, dy - 1, 0, dz - 1)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetOrigin(ox, oy, oz)
image.SetSpacing(sx, sy, sz)
image.SetDimensions(dx - 1, dy - 1, dz - 1)
# SetNumberOfScalarComponents and SetScalrType were replaced by
# AllocateScalars
# image.SetNumberOfScalarComponents(1)
# image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), 1)
image.SetExtent(extent)
image.GetPointData().SetScalars(v_image)
# image_copy = vtk.vtkImageData()
# image_copy.DeepCopy(image)
return image
def to_vtk(n_array, spacing, slice_number, orientation):
try:
dz, dy, dx = n_array.shape
except ValueError:
dy, dx = n_array.shape
dz = 1
v_image = numpy_support.numpy_to_vtk(n_array.flat)
if orientation == 'AXIAL':
extent = (0, dx -1, 0, dy -1, slice_number, slice_number + dz - 1)
elif orientation == 'SAGITAL':
dx, dy, dz = dz, dx, dy
extent = (slice_number, slice_number + dx - 1, 0, dy - 1, 0, dz - 1)
elif orientation == 'CORONAL':
dx, dy, dz = dx, dz, dy
extent = (0, dx - 1, slice_number, slice_number + dy - 1, 0, dz - 1)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
image.SetDimensions(dx, dy, dz)
# SetNumberOfScalarComponents and SetScalrType were replaced by
# AllocateScalars
# image.SetNumberOfScalarComponents(1)
# image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), 1)
image.SetExtent(extent)
image.GetPointData().SetScalars(v_image)
image_copy = vtk.vtkImageData()
image_copy.DeepCopy(image)
return image_copy
def set_point_colors(self, **kwargs):
if self.polydata is None:
print("Points are not yet available")
else:
vtk_color_data = kwargs.get('data', None)
if vtk_color_data is None:
sample_labels = kwargs.get('labels', None)
if sample_labels is None:
sample_labels = np.full(shape=[
self.polydata.GetPointData().GetNumberOfTuples()
],
fill_value=0)
labels = np.where(sample_labels >= 0, sample_labels, 0)
colors = self.colormap[labels]
vtk_color_data: vtk.vtkUnsignedCharArray = npsup.numpy_to_vtk(
colors.ravel(),
deep=1,
array_type=npsup.get_vtk_array_type(np.uint8))
vtk_color_data.SetNumberOfComponents(colors.shape[1])
vtk_color_data.SetNumberOfTuples(colors.shape[0])
vtk_color_data.SetName('colors')
vtkpts = self.polydata.GetPointData()
vtkpts.SetScalars(vtk_color_data)
vtkpts.SetActiveScalars('colors')
vtkpts.Modified()
def numpy_to_vtk_cells(data, is_coords=True):
"""Convert numpy array to a vtk cell array.
Parameters
----------
data : ndarray
points coordinate or connectivity array (e.g triangles).
is_coords : ndarray
Select the type of array. default: True.
Returns
-------
vtk_cell : vtkCellArray
connectivity + offset information
"""
data = np.array(data)
nb_cells = len(data)
# Get lines_array in vtk input format
connectivity = data.flatten() if not is_coords else []
offset = [0, ]
current_position = 0
cell_array = vtk.vtkCellArray()
if vtk.vtkVersion.GetVTKMajorVersion() >= 9:
for i in range(nb_cells):
current_len = len(data[i])
offset.append(offset[-1] + current_len)
if is_coords:
end_position = current_position + current_len
connectivity += list(range(current_position, end_position))
current_position = end_position
connectivity = np.array(connectivity, np.intp)
offset = np.array(offset, dtype=connectivity.dtype)
vtk_array_type = numpy_support.get_vtk_array_type(connectivity.dtype)
cell_array.SetData(
numpy_support.numpy_to_vtk(offset, deep=True,
array_type=vtk_array_type),
numpy_support.numpy_to_vtk(connectivity, deep=True,
array_type=vtk_array_type))
else:
for i in range(nb_cells):
current_len = len(data[i])
end_position = current_position + current_len
connectivity += [current_len]
connectivity += list(range(current_position, end_position))
current_position = end_position
connectivity = np.array(connectivity)
cell_array.GetData().DeepCopy(numpy_support.numpy_to_vtk(connectivity))
cell_array.SetNumberOfCells(nb_cells)
return cell_array
def get_vtk_type(typ):
"""This looks up the VTK type for a give python data type.
Return:
int : the integer type id specified in vtkType.h
"""
typ = nps.get_vtk_array_type(typ)
if typ is 3:
return 13
return typ
def exportPython2VTK(img):
"""
This function creates a vtk image from a python array
Args:
img: python ndarray of the image
Returns:
imageData: vtk image
"""
vtkArray = numpy_to_vtk(num_array=img.flatten('F'),
deep=True,
array_type=get_vtk_array_type(img.dtype))
#vtkArray = numpy_to_vtk(img.flatten())
return vtkArray
def get_vtk_type(typ):
"""This looks up the VTK type for a give python data type. Corrects for
string type mapping issues.
Return
------
int : the integer type id specified in vtkType.h
"""
typ = nps.get_vtk_array_type(typ)
# This handles a silly string type bug
if typ is 3:
return 13
return typ
def set_scalars(dataobject, newscalars):
do = dsa.WrapDataObject(dataobject)
oldscalars = do.PointData.GetScalars()
name = oldscalars.GetName()
del oldscalars
# handle the case if the newscalars array has a type that
# cannot be passed on to VTK. In which case, we convert to
# convert to float64
vtk_typecode = np_s.get_vtk_array_type(newscalars.dtype)
if vtk_typecode is None:
newscalars = newscalars.astype(np.float64)
do.PointData.append(newscalars, name)
do.PointData.SetActiveScalars(name)
def set_scalars(dataobject, newscalars):
do = dsa.WrapDataObject(dataobject)
oldscalars = do.PointData.GetScalars()
name = oldscalars.GetName()
del oldscalars
# handle the case if the newscalars array has a type that
# cannot be passed on to VTK. In which case, we convert to
# convert to float64
vtk_typecode = np_s.get_vtk_array_type(newscalars.dtype)
if vtk_typecode is None:
newscalars = newscalars.astype(np.float64)
do.PointData.append(newscalars, name)
do.PointData.SetActiveScalars(name)
def NumToVTKImage(numarray,name=None):
dims = numarray.shape
if len(dims) ==1:
return NumToVTKArray(numarray, name)
ii = vtk.vtkImageData()
ii.SetDimensions(numarray.shape[0], numarray.shape[1], 1)
ii.SetSpacing(1,1,1)
ii.SetOrigin(0,0,0)
ii.SetExtent(0, numarray.shape[0]-1, 0, numarray.shape[1]-1, 0, 0)
vtktype = numpy_support.get_vtk_array_type(numarray.dtype)
ii.AllocateScalars(vtktype, 1)
pd = ii.GetPointData()
arr = numpy_support.numpy_to_vtk(np.ndarray.flatten(numarray, 'F'))
pd.SetScalars(arr)
return ii
def md_to_vti(self, md):
array = md.getSignalArray()
origin = [md.getDimension(n).getMinimum() for n in range(3)]
spacing = [md.getDimension(n).getBinWidth() for n in range(3)]
dimensions = [n + 1 for n in array.shape]
vtkArray = numpy_to_vtk(num_array=array.flatten('F'),
deep=True,
array_type=get_vtk_array_type(array.dtype))
imageData = vtk.vtkImageData()
imageData.SetOrigin(origin)
imageData.SetSpacing(spacing)
imageData.SetDimensions(dimensions)
imageData.GetCellData().SetScalars(vtkArray)
return imageData
def numpyToImageData(img, flip=True, vtktype=None):
if flip:
img = np.flipud(img)
assert len(img.shape) in (2, 3)
height, width = img.shape[:2]
numChannels = 1 if len(img.shape) == 2 else img.shape[2]
image = vtk.vtkImageData()
image.SetDimensions(width, height, 1)
if vtktype is None:
vtktype = numpy_support.get_vtk_array_type(img.dtype)
image.AllocateScalars(vtktype, numChannels)
scalars = getNumpyFromVtk(image, 'ImageScalars')
if numChannels > 1:
scalars[:] = img.reshape(width*height, numChannels)[:]
else:
scalars[:] = img.reshape(width*height)[:]
return image
def __init__(self, array, type_array=None):
'''
:param array: Receives a pandas DataFrame, or numpy array or vtkDataArray
:param type_array: Receives the vtk data type or a numpy array type
'''
self._vtk = None
array = self._convert_list_pandas_to_numpy(array)
vtk_type = None
np_type = None
if isinstance(type_array, int):
vtk_type = type_array
np_type = ns.get_vtk_to_numpy_typemap()[type_array]
elif isinstance(type_array, type):
vtk_type = ns.get_vtk_array_type(type_array)
np_type = type_array
if isinstance(array, np.ndarray):
if not array.flags.contiguous:
array = np.ascontiguousarray(array)
if np_type:
array = array.astype(np_type)
self._numpy = array
self._vtk = ns.numpy_to_vtk(self._numpy, array_type=vtk_type)
self._vtk._np = array
elif isinstance(array, vtk.vtkDataArray):
if type_array is None or array.GetDataType() == vtk_type:
self._vtk = array
self._numpy = ns.vtk_to_numpy(array)
else:
if type_array is None:
np_type = np.double
vtk_type = vtk.VTK_DOUBLE
np_array = ns.vtk_to_numpy(array).astype(np_type)
self._vtk = ns.create_vtk_array(vtk_type)
self._vtk.SetName(array.GetName())
self.numpy_to_vtk(np_array)
else:
raise ValueError(
'Expected a Numpy array, but received a: {}'.format(
type(array)))
self._vtk.AddObserver(vtk.vtkCommand.ModifiedEvent, self._update_numpy)
def to_vtk(n_array, dim, spacing=(1,1,1)):
dz, dy, dx = dim
data_type = n_array.dtype
v_image = numpy_support.numpy_to_vtk(n_array)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetDimensions(dx, dy, dz)
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
image.SetNumberOfScalarComponents(1)
image.SetExtent(0, dx -1, 0, dy -1, 0, dz - 1)
# getattr(image, NUMPY_TO_VTK_TYPE[n_array.dtype.name])()
image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars()
image.GetPointData().SetScalars(v_image)
return image
def to_vtk(n_array, spacing, slice_number=0, orientation='AXIAL'):
"""
This function defines orientation or the TPMS.
Starts vtk.
"""
try:
dz, dy, dx = n_array.shape
except ValueError:
dy, dx = n_array.shape
dz = 1
v_image = numpy_support.numpy_to_vtk(n_array.flat)
if orientation == 'AXIAL':
extent = (0, dx -1, 0, dy -1, slice_number, slice_number + dz - 1)
elif orientation == 'SAGITAL':
dx, dy, dz = dz, dx, dy
extent = (slice_number, slice_number + dx - 1, 0, dy - 1, 0, dz - 1)
elif orientation == 'CORONAL':
dx, dy, dz = dx, dz, dy
extent = (0, dx - 1, slice_number, slice_number + dy - 1, 0, dz - 1)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
# image.SetNumberOfScalarComponents(1)
image.SetDimensions(dx, dy, dz)
image.SetExtent(extent)
# image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), 1)
image.GetPointData().SetScalars(v_image)
# image.Update()
# image.UpdateInformation()
# image_copy = vtk.vtkImageData()
# image_copy.DeepCopy(image)
# image_copy.Update()
return image
def to_vtk(n_array, spacing): dz, dy, dx = n_array.shape n_array.shape = dx * dy * dz v_image = numpy_support.numpy_to_vtk(n_array) # Generating the vtkImageData image = vtk.vtkImageData() image.SetOrigin(0, 0, 0) image.SetDimensions(dx, dy, dz) image.SetSpacing(spacing) image.SetExtent(0, dx -1, 0, dy -1, 0, dz - 1) image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), 1) image.GetPointData().SetScalars(v_image) image_copy = vtk.vtkImageData() image_copy.DeepCopy(image) n_array.shape = dz, dy, dx return image_copy
def np_rgba_to_vtk(n_array, spacing=(1.0, 1.0, 1.0)):
dy, dx, dc = n_array.shape
v_image = numpy_support.numpy_to_vtk(n_array.reshape(dy * dx, dc))
extent = (0, dx - 1, 0, dy - 1, 0, 0)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
image.SetDimensions(dx, dy, 1)
# SetNumberOfScalarComponents and SetScalrType were replaced by
# AllocateScalars
# image.SetNumberOfScalarComponents(1)
# image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), dc)
image.SetExtent(extent)
image.GetPointData().SetScalars(v_image)
return image
def np_rgba_to_vtk(n_array, spacing=(1.0, 1.0, 1.0)):
dy, dx, dc = n_array.shape
v_image = numpy_support.numpy_to_vtk(n_array.reshape(dy*dx, dc))
extent = (0, dx -1, 0, dy -1, 0, 0)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
image.SetDimensions(dx, dy, 1)
# SetNumberOfScalarComponents and SetScalrType were replaced by
# AllocateScalars
# image.SetNumberOfScalarComponents(1)
# image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), dc)
image.SetExtent(extent)
image.GetPointData().SetScalars(v_image)
return image
def to_vtk(n_array, spacing, slice_number, orientation):
"""
It transforms a numpy array into a vtkImageData.
"""
# TODO Merge this function with imagedata_utils.to_vtk to eliminate
# duplicated code
try:
dz, dy, dx = n_array.shape
except ValueError:
dy, dx = n_array.shape
dz = 1
v_image = numpy_support.numpy_to_vtk(n_array.flat)
if orientation == 'AXIAL':
extent = (0, dx -1, 0, dy -1, slice_number, slice_number + dz - 1)
elif orientation == 'SAGITAL':
extent = (slice_number, slice_number + dx - 1, 0, dy - 1, 0, dz - 1)
elif orientation == 'CORONAL':
extent = (0, dx - 1, slice_number, slice_number + dy - 1, 0, dz - 1)
image = vtk.vtkImageData()
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
image.SetNumberOfScalarComponents(1)
image.SetDimensions(dx, dy, dz)
image.SetExtent(extent)
image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars()
image.Update()
image.GetCellData().SetScalars(v_image)
image.GetPointData().SetScalars(v_image)
image.Update()
image_copy = vtk.vtkImageData()
image_copy.DeepCopy(image)
image_copy.Update()
return image_copy
def to_vtk(n_array, spacing, slice_number, orientation):
"""
It transforms a numpy array into a vtkImageData.
"""
# TODO Merge this function with imagedata_utils.to_vtk to eliminate
# duplicated code
try:
dz, dy, dx = n_array.shape
except ValueError:
dy, dx = n_array.shape
dz = 1
v_image = numpy_support.numpy_to_vtk(n_array.flat)
if orientation == 'AXIAL':
extent = (0, dx - 1, 0, dy - 1, slice_number, slice_number + dz - 1)
elif orientation == 'SAGITAL':
extent = (slice_number, slice_number + dx - 1, 0, dy - 1, 0, dz - 1)
elif orientation == 'CORONAL':
extent = (0, dx - 1, slice_number, slice_number + dy - 1, 0, dz - 1)
image = vtk.vtkImageData()
image.SetOrigin(0, 0, 0)
image.SetSpacing(spacing)
image.SetNumberOfScalarComponents(1)
image.SetDimensions(dx, dy, dz)
image.SetExtent(extent)
image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars()
image.Update()
image.GetCellData().SetScalars(v_image)
image.GetPointData().SetScalars(v_image)
image.Update()
image_copy = vtk.vtkImageData()
image_copy.DeepCopy(image)
image_copy.Update()
return image_copy
def write_vti(self,
array,
spacing,
filename='Polydata.vti',
origin=(0, 0, 0)):
vtkArray = numpy_to_vtk(num_array=array.flatten('F'),
deep=True,
array_type=get_vtk_array_type(array.dtype))
imageData = vtk.vtkImageData()
imageData.SetOrigin(origin)
imageData.SetSpacing(spacing)
imageData.SetDimensions(array.shape)
imageData.GetPointData().SetScalars(vtkArray)
writer = vtk.vtkXMLImageDataWriter()
if os.sep == '\\':
writer.SetFileName(".\\__vtk_files__\\{}".format(filename))
else:
writer.SetFileName("__vtk_files__/{}".format(filename))
writer.SetInputData(imageData)
writer.Write()
self.vti_write = True
def numpy_to_vtk(num_array, deep=0, array_type=None):
"""Converts a contiguous real numpy Array to a VTK array object.
This function only works for real arrays that are contiguous.
Complex arrays are NOT handled. It also works for multi-component
arrays. However, only 1, and 2 dimensional arrays are supported.
This function is very efficient, so large arrays should not be a
problem.
If the second argument is set to 1, the array is deep-copied from
from numpy. This is not as efficient as the default behavior
(shallow copy) and uses more memory but detaches the two arrays
such that the numpy array can be released.
WARNING: You must maintain a reference to the passed numpy array, if
the numpy data is gc'd and VTK will point to garbage which will in
the best case give you a segfault.
Parameters
----------
- num_array : a contiguous 1D or 2D, real numpy array.
Notes
-----
This was pulled from VTK and modified to eliminate numpy 1.14 warnings.
VTK uses a BSD license, so it's OK to do that.
"""
z = np.asarray(num_array)
if not z.flags.contiguous:
z = np.ascontiguousarray(z)
shape = z.shape
assert z.flags.contiguous, 'Only contiguous arrays are supported.'
assert len(shape) < 3, \
"Only arrays of dimensionality 2 or lower are allowed!"
assert not np.issubdtype(z.dtype, np.complexfloating), \
"Complex numpy arrays cannot be converted to vtk arrays."\
"Use real() or imag() to get a component of the array before"\
" passing it to vtk."
# First create an array of the right type by using the typecode.
if array_type:
vtk_typecode = array_type
else:
vtk_typecode = get_vtk_array_type(z.dtype)
result_array = create_vtk_array(vtk_typecode)
# Fixup shape in case its empty or scalar.
try:
test_var = shape[0]
except:
shape = (0, )
# Find the shape and set number of components.
if len(shape) == 1:
result_array.SetNumberOfComponents(1)
else:
result_array.SetNumberOfComponents(shape[1])
result_array.SetNumberOfTuples(shape[0])
# Ravel the array appropriately.
arr_dtype = get_numpy_array_type(vtk_typecode)
if np.issubdtype(z.dtype, arr_dtype) or \
z.dtype == np.dtype(arr_dtype):
z_flat = np.ravel(z)
else:
z_flat = np.ravel(z).astype(arr_dtype)
# z_flat is now a standalone object with no references from the caller.
# As such, it will drop out of this scope and cause memory issues if we
# do not deep copy its data.
deep = 1
# Point the VTK array to the numpy data. The last argument (1)
# tells the array not to deallocate.
result_array.SetVoidArray(z_flat, len(z_flat), 1)
if deep:
copy = result_array.NewInstance()
copy.DeepCopy(result_array)
result_array = copy
else:
result_array._numpy_reference = z
return result_array
def load_image(filename, as_vtktype=False, use_pillow=True):
"""Load an image.
Parameters
----------
filename: str
should be png, bmp, jpeg or jpg files
as_vtktype: bool, optional
if True, return vtk output otherwise an ndarray. Default False.
use_pillow: bool, optional
Use pillow python library to load the files. Default True
Returns
-------
image: ndarray or vtk output
desired image array
"""
if use_pillow:
with Image.open(filename) as pil_image:
if pil_image.mode in ['RGBA', 'RGB', 'L']:
image = np.asarray(pil_image)
elif pil_image.mode.startswith('I;16'):
raw = pil_image.tobytes('raw', pil_image.mode)
dtype = '>u2' if pil_image.mode.endswith('B') else '<u2'
image = np.frombuffer(raw, dtype=dtype)
image.reshape(pil_image.size[::-1]).astype('=u2')
else:
try:
image = pil_image.convert('RGBA')
except ValueError:
raise RuntimeError('Unknown image mode {}'.format(
pil_image.mode))
image = np.asarray(pil_image)
if as_vtktype:
if image.ndim not in [2, 3]:
raise IOError("only 2D (L, RGB, RGBA) or 3D image available")
vtk_image = vtk.vtkImageData()
depth = 1 if image.ndim == 2 else image.shape[2]
# width, height
vtk_image.SetDimensions(image.shape[1], image.shape[0], depth)
vtk_image.SetExtent(0, image.shape[1] - 1, 0, image.shape[0] - 1,
0, 0)
vtk_image.SetSpacing(1.0, 1.0, 1.0)
vtk_image.SetOrigin(0.0, 0.0, 0.0)
arr_tmp = np.flipud(image)
arr_tmp = arr_tmp.reshape(image.shape[1] * image.shape[0], depth)
arr_tmp = np.ascontiguousarray(arr_tmp, dtype=image.dtype)
vtk_array_type = numpy_support.get_vtk_array_type(image.dtype)
uchar_array = numpy_support.numpy_to_vtk(arr_tmp,
deep=True,
array_type=vtk_array_type)
vtk_image.GetPointData().SetScalars(uchar_array)
image = vtk_image
return image
d_reader = {
".png": vtk.vtkPNGReader,
".bmp": vtk.vtkBMPReader,
".jpeg": vtk.vtkJPEGReader,
".jpg": vtk.vtkJPEGReader,
".tiff": vtk.vtkTIFFReader,
".tif": vtk.vtkTIFFReader
}
extension = os.path.splitext(os.path.basename(filename).lower())[1]
if extension.lower() not in d_reader.keys():
raise IOError(
"Impossible to read the file {0}: Unknown extension {1}".format(
filename, extension))
reader = d_reader.get(extension)()
reader.SetFileName(filename)
reader.Update()
reader.GetOutput().GetPointData().GetArray(0).SetName("original")
if not as_vtktype:
w, h, _ = reader.GetOutput().GetDimensions()
vtk_array = reader.GetOutput().GetPointData().GetScalars()
components = vtk_array.GetNumberOfComponents()
image = numpy_support.vtk_to_numpy(vtk_array).reshape(h, w, components)
image = np.flipud(image)
return reader.GetOutput() if as_vtktype else image
def addGrid(self, grid):
nx, ny, nz = grid.shape[1:]
self.display.append(True)
self.grids.append(vtk.vtkStructuredGrid())
self.grids[-1].SetExtent(0, nz-1, 0, ny-1, 0, nx-1)
p = vtk.vtkPoints()
shp = grid.shape
grid.shape = (3, nx*ny*nz)
p.SetData(vtknp.numpy_to_vtk(np.ascontiguousarray(grid.T), deep=True, array_type=vtknp.get_vtk_array_type(grid.dtype)))
grid.shape = shp
self.grids[-1].SetPoints(p)
#Couleur
color = np.random.rand(3)
#Create a vtkOutlineFilter to draw the bounding box of the data set.
ol = vtk.vtkOutlineFilter()
if (vtk.vtkVersion().GetVTKMajorVersion()>=6):
ol.SetInputData(self.grids[-1])
else:
ol.SetInput(self.grids[-1])
olm = vtk.vtkPolyDataMapper()
olm.SetInputConnection(ol.GetOutputPort())
ola = vtk.vtkActor()
ola.SetMapper(olm)
ola.GetProperty().SetColor(color)
s=vtk.vtkShrinkFilter()
if (vtk.vtkVersion().GetVTKMajorVersion()>=6):
s.SetInputData(self.grids[-1])
else:
s.SetInput(self.grids[-1])
s.SetShrinkFactor(0.8)
#
mapper = vtk.vtkDataSetMapper()
#map.SetInputData(data)
mapper.SetInputConnection(s.GetOutputPort())
act = vtk.vtkLODActor()
act.SetMapper(mapper)
#act.GetProperty().SetRepresentationToWireframe()
#act.GetProperty().SetRepresentationToPoints()
act.GetProperty().SetColor(color)
act.GetProperty().SetEdgeColor(color)
act.GetProperty().EdgeVisibilityOff()
self.actors.append(act)
self.setBounds()
self.ren.SetActiveCamera(self.cam)
def save_image(arr,
filename,
compression_quality=75,
compression_type='deflation',
use_pillow=True):
"""Save a 2d or 3d image.
Parameters
----------
arr : ndarray
array to save
filename : string
should be png, bmp, jpeg or jpg files
compression_quality : int
compression_quality for jpeg data.
0 = Low quality, 100 = High quality
compression_type : str
compression type for tiff file
select between: None, lzw, deflation (default)
use_pillow : bool
Use imageio python library to save the files.
"""
if arr.ndim > 3:
raise IOError("Image Dimensions should be <=3")
d_writer = {
".png": vtk.vtkPNGWriter,
".bmp": vtk.vtkBMPWriter,
".jpeg": vtk.vtkJPEGWriter,
".jpg": vtk.vtkJPEGWriter,
".tiff": vtk.vtkTIFFWriter,
".tif": vtk.vtkTIFFWriter,
}
extension = os.path.splitext(os.path.basename(filename).lower())[1]
if extension.lower() not in d_writer.keys():
raise IOError(
"Impossible to save the file {0}: Unknown extension {1}".format(
filename, extension))
if use_pillow:
im = Image.fromarray(arr)
im.save(filename, quality=compression_quality)
return
if arr.ndim == 2:
arr = arr[..., None]
vtk_array_type = numpy_support.get_vtk_array_type(arr.dtype)
vtk_array = numpy_support.numpy_to_vtk(num_array=arr.ravel(),
deep=True,
array_type=vtk_array_type)
# Todo, look the following link for managing png 16bit
# https://stackoverflow.com/questions/15667947/vtkpngwriter-printing-out-black-images
vtk_data = vtk.vtkImageData()
vtk_data.SetDimensions(arr.shape)
vtk_data.SetSpacing(1.0, 1.0, 1.0)
vtk_data.SetOrigin(0.0, 0.0, 0.0)
vtk_data.GetPointData().SetScalars(vtk_array)
writer = d_writer.get(extension)()
writer.SetFileName(filename)
writer.SetInputData(vtk_data)
if extension.lower() in [".jpg", ".jpeg"]:
writer.ProgressiveOn()
writer.SetQuality(compression_quality)
if extension.lower() in [".tif", ".tiff"]:
if not compression_type:
writer.SetCompressionToNoCompression()
elif compression_type.lower() == 'lzw':
writer.SetCompressionToLZW()
elif compression_type.lower() == 'deflation':
writer.SetCompressionToDeflate()
writer.Write()
def to_vtk(
n_array,
spacing=(1.0, 1.0, 1.0),
slice_number=0,
orientation="AXIAL",
origin=(0, 0, 0),
padding=(0, 0, 0),
):
if orientation == "SAGITTAL":
orientation = "SAGITAL"
try:
dz, dy, dx = n_array.shape
except ValueError:
dy, dx = n_array.shape
dz = 1
px, py, pz = padding
v_image = numpy_support.numpy_to_vtk(n_array.flat)
if orientation == "AXIAL":
extent = (
0 - px,
dx - 1 - px,
0 - py,
dy - 1 - py,
slice_number - pz,
slice_number + dz - 1 - pz,
)
elif orientation == "SAGITAL":
dx, dy, dz = dz, dx, dy
extent = (
slice_number - px,
slice_number + dx - 1 - px,
0 - py,
dy - 1 - py,
0 - pz,
dz - 1 - pz,
)
elif orientation == "CORONAL":
dx, dy, dz = dx, dz, dy
extent = (
0 - px,
dx - 1 - px,
slice_number - py,
slice_number + dy - 1 - py,
0 - pz,
dz - 1 - pz,
)
# Generating the vtkImageData
image = vtk.vtkImageData()
image.SetOrigin(origin)
image.SetSpacing(spacing)
image.SetDimensions(dx, dy, dz)
# SetNumberOfScalarComponents and SetScalrType were replaced by
# AllocateScalars
# image.SetNumberOfScalarComponents(1)
# image.SetScalarType(numpy_support.get_vtk_array_type(n_array.dtype))
image.AllocateScalars(numpy_support.get_vtk_array_type(n_array.dtype), 1)
image.SetExtent(extent)
image.GetPointData().SetScalars(v_image)
image_copy = vtk.vtkImageData()
image_copy.DeepCopy(image)
return image_copy
def _points_to_vtk_cells(points, points_per_line=2):
"""
Returns the VTK cell array for the peaks given the set of points
coordinates.
Parameters
----------
points : (N, 3) array or ndarray
points coordinates array.
points_per_line : int (1 or 2), optional
number of points per peak direction.
Returns
-------
cell_array : vtkCellArray
connectivity + offset information.
"""
num_pnts = len(points)
num_cells = num_pnts // points_per_line
cell_array = vtk.vtkCellArray()
if vtk.vtkVersion.GetVTKMajorVersion() >= 9:
"""
Connectivity is an array that contains the indices of the points that
need to be connected in the visualization. The indices start from 0.
"""
connectivity = np.asarray(list(range(0, num_pnts)), dtype=int)
"""
Offset is an array that contains the indices of the first point of
each line. The indices start from 0 and given the known geometry of
this actor the creation of this array requires a 2 points padding
between indices.
"""
offset = np.asarray(list(range(0, num_pnts + 1, points_per_line)),
dtype=int)
vtk_array_type = numpy_support.get_vtk_array_type(connectivity.dtype)
cell_array.SetData(
numpy_support.numpy_to_vtk(offset,
deep=True,
array_type=vtk_array_type),
numpy_support.numpy_to_vtk(connectivity,
deep=True,
array_type=vtk_array_type))
else:
connectivity = np.array([], dtype=int)
i_pos = 0
while i_pos < num_pnts:
e_pos = i_pos + points_per_line
"""
In old versions of VTK (<9.0) the connectivity array should include
the length of each line and immediately after the indices of the
points in each line.
"""
connectivity = np.append(connectivity,
[points_per_line, i_pos, e_pos - 1])
i_pos = e_pos
cell_array.GetData().DeepCopy(numpy_support.numpy_to_vtk(connectivity))
cell_array.SetNumberOfCells(num_cells)
return cell_array