def polydata_from_numpy(coords):
"""
Converts Numpy Array to vtkPolyData
Parameters
----------
coords: array, shape= [number of points, point features]
array containing the point cloud in which each point has three coordinares [x, y, z]
and none, one or three values corresponding to colors.
Returns:
--------
PolyData: vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
"""
Npts, Ndim = np.shape(coords)
Points = vtkPoints()
ntype = get_numpy_array_type(Points.GetDataType())
coords_vtk = numpy_to_vtk(np.asarray(coords[:, 0:3],
order='C',
dtype=ntype),
deep=1)
Points.SetNumberOfPoints(Npts)
Points.SetData(coords_vtk)
Cells = vtkCellArray()
ids = np.arange(0, Npts, dtype=np.int64).reshape(-1, 1)
IDS = np.concatenate([np.ones(Npts, dtype=np.int64).reshape(-1, 1), ids],
axis=1)
ids_vtk = numpy_to_vtkIdTypeArray(IDS, deep=True)
Cells.SetNumberOfCells(Npts)
Cells.SetCells(Npts, ids_vtk)
if Ndim == 4:
color = [128] * len(coords)
color = np.c_[color, color, color]
elif Ndim == 6:
color = coords[:, 3:]
else:
color = [[128, 128, 128]] * len(coords)
color_vtk = numpy_to_vtk(np.ascontiguousarray(
color, dtype=get_vtk_to_numpy_typemap()[VTK_UNSIGNED_CHAR]),
deep=True)
color_vtk.SetName("colors")
PolyData = vtkPolyData()
PolyData.SetPoints(Points)
PolyData.SetVerts(Cells)
PolyData.GetPointData().SetScalars(color_vtk)
return PolyData
def polydata_from_numpy(coords):
"""
Converts Numpy Array to vtkPolyData
Parameters
----------
coords: array, shape= [number of points, point features]
array containing the point cloud in which each point has three coordinares [x, y, z]
and none, one or three values corresponding to colors.
Returns:
--------
PolyData: vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
"""
Npts, Ndim = np.shape(coords)
Points = vtkPoints()
ntype = get_numpy_array_type(Points.GetDataType())
coords_vtk = numpy_to_vtk(np.asarray(coords[:,0:3], order='C',dtype=ntype), deep=1)
Points.SetNumberOfPoints(Npts)
Points.SetData(coords_vtk)
Cells = vtkCellArray()
ids = np.arange(0,Npts, dtype=np.int64).reshape(-1,1)
IDS = np.concatenate([np.ones(Npts, dtype=np.int64).reshape(-1,1), ids],axis=1)
ids_vtk = numpy_to_vtkIdTypeArray(IDS, deep=True)
Cells.SetNumberOfCells(Npts)
Cells.SetCells(Npts,ids_vtk)
if Ndim == 4:
color = [128]*len(coords)
color = np.c_[color, color, color]
elif Ndim == 6:
color = coords[:,3:]
else:
color = [[128, 128, 128]]*len(coords)
color_vtk = numpy_to_vtk(
np.ascontiguousarray(color, dtype=get_vtk_to_numpy_typemap()[VTK_UNSIGNED_CHAR]),
deep=True)
color_vtk.SetName("colors")
PolyData = vtkPolyData()
PolyData.SetPoints(Points)
PolyData.SetVerts(Cells)
PolyData.GetPointData().SetScalars(color_vtk)
return PolyData
def polydata_from_numpy(coords, color):
"""
:param coords:
:param color:
:return:
"""
Npts, Ndim = np.shape(coords)
Points = vtkPoints()
ntype = get_numpy_array_type(Points.GetDataType())
coords_vtk = numpy_to_vtk(np.asarray(coords, order='C',dtype=ntype), deep=1)
Points.SetNumberOfPoints(Npts)
Points.SetData(coords_vtk)
Cells = vtkCellArray()
ids = np.arange(0,Npts, dtype=np.int64).reshape(-1,1)
IDS = np.concatenate([np.ones(Npts, dtype=np.int64).reshape(-1,1), ids],axis=1)
ids_vtk = numpy_to_vtkIdTypeArray(IDS, deep=True)
Cells.SetNumberOfCells(Npts)
Cells.SetCells(Npts,ids_vtk)
if color is None:
[[128, 128, 128]]*len(coords)
size = np.shape(color)
if len(size)==1:
color = [128]*len(coords)
color = np.c_[color, color, color]
color_vtk = numpy_to_vtk(
np.ascontiguousarray(color, dtype=get_vtk_to_numpy_typemap()[VTK_UNSIGNED_CHAR]),
deep=True
)
color_vtk.SetName("colors")
PolyData = vtkPolyData()
PolyData.SetPoints(Points)
PolyData.SetVerts(Cells)
PolyData.GetPointData().SetScalars(color_vtk)
return PolyData
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 save_vtk_labels(filename, tracts, scalars, lines_indices=None):
lengths = [len(p) for p in tracts]
line_starts = ns.numpy.r_[0, ns.numpy.cumsum(lengths)]
if lines_indices is None:
lines_indices = [
ns.numpy.arange(length) + line_start
for length, line_start in izip(lengths, line_starts)
]
ids = ns.numpy.hstack(
[ns.numpy.r_[c[0], c[1]] for c in izip(lengths, lines_indices)])
vtk_ids = ns.numpy_to_vtkIdTypeArray(ids, deep=True)
cell_array = vtk.vtkCellArray()
cell_array.SetCells(len(tracts), vtk_ids)
points = ns.numpy.vstack(tracts).astype(
ns.get_vtk_to_numpy_typemap()[vtk.VTK_DOUBLE])
points_array = ns.numpy_to_vtk(points, deep=True)
poly_data = vtk.vtkPolyData()
vtk_points = vtk.vtkPoints()
vtk_points.SetData(points_array)
poly_data.SetPoints(vtk_points)
poly_data.SetLines(cell_array)
poly_data.GetPointData().SetScalars(ns.numpy_to_vtk(scalars))
poly_data.BuildCells()
# poly_data.SetScalars(scalars)
if filename.endswith(".xml") or filename.endswith(".vtp"):
writer = vtk.vtkXMLPolyDataWriter()
writer.SetDataModeToBinary()
else:
writer = vtk.vtkPolyDataWriter()
writer.SetFileTypeToBinary()
writer.SetFileName(filename)
if hasattr(vtk, "VTK_MAJOR_VERSION") and vtk.VTK_MAJOR_VERSION > 5:
writer.SetInputData(poly_data)
else:
writer.SetInput(poly_data)
writer.Write()
def tracts_to_vtkPolyData64(tracts, tracts_data={}, lines_indices=None):
# if isinstance(tracts, Tractography):
tracts_data = tracts.tracts_data()
tracts = tracts.tracts()
lengths = [len(p) for p in tracts]
line_starts = ns.numpy.r_[0, ns.numpy.cumsum(lengths)]
if lines_indices is None:
lines_indices = [
ns.numpy.arange(length) + line_start
for length, line_start in izip(lengths, line_starts)
]
ids = ns.numpy.hstack([
ns.numpy.r_[c[0], c[1]]
for c in izip(lengths, lines_indices)
])
ids=np.int64(ids)
vtk_ids = ns.numpy_to_vtkIdTypeArray(ids, deep=True)
cell_array = vtk.vtkCellArray()
cell_array.SetCells(len(tracts), vtk_ids)
points = ns.numpy.vstack(tracts).astype(
ns.get_vtk_to_numpy_typemap()[vtk.VTK_DOUBLE]
)
points_array = ns.numpy_to_vtk(points, deep=True)
poly_data = vtk.vtkPolyData()
vtk_points = vtk.vtkPoints()
vtk_points.SetData(points_array)
poly_data.SetPoints(vtk_points)
poly_data.SetLines(cell_array)
saved_keys = set()
for key, value in tracts_data.items():
if key in saved_keys:
continue
if key.startswith('Active'):
saved_keys.add(value)
name = value
value = tracts_data[value]
else:
name = key
if len(value) == len(tracts):
if value[0].ndim == 1:
value_ = ns.numpy.hstack(value)[:, None]
else:
value_ = ns.numpy.vstack(value)
elif len(value) == len(points):
value_ = value
else:
raise ValueError(
"Data in %s does not have the correct number of items")
vtk_value = ns.numpy_to_vtk(np.ascontiguousarray(value_), deep=True)
vtk_value.SetName(name)
if key == 'ActiveScalars' or key == 'Scalars_':
poly_data.GetPointData().SetScalars(vtk_value)
elif key == 'ActiveVectors' or key == 'Vectors_':
poly_data.GetPointData().SetVectors(vtk_value)
elif key == 'ActiveTensors' or key == 'Tensors_':
poly_data.GetPointData().SetTensors(vtk_value)
else:
poly_data.GetPointData().AddArray(vtk_value)
poly_data.BuildCells()
return poly_data
def tracts_to_vtkPolyData64(tracts, tracts_data={}, lines_indices=None):
# if isinstance(tracts, Tractography):
tracts_data = tracts.tracts_data()
tracts = tracts.tracts()
lengths = [len(p) for p in tracts]
line_starts = ns.numpy.r_[0, ns.numpy.cumsum(lengths)]
if lines_indices is None:
lines_indices = [
ns.numpy.arange(length) + line_start
for length, line_start in izip(lengths, line_starts)
]
ids = ns.numpy.hstack(
[ns.numpy.r_[c[0], c[1]] for c in izip(lengths, lines_indices)])
ids = np.int64(ids)
vtk_ids = ns.numpy_to_vtkIdTypeArray(ids, deep=True)
cell_array = vtk.vtkCellArray()
cell_array.SetCells(len(tracts), vtk_ids)
points = ns.numpy.vstack(tracts).astype(
ns.get_vtk_to_numpy_typemap()[vtk.VTK_DOUBLE])
points_array = ns.numpy_to_vtk(points, deep=True)
poly_data = vtk.vtkPolyData()
vtk_points = vtk.vtkPoints()
vtk_points.SetData(points_array)
poly_data.SetPoints(vtk_points)
poly_data.SetLines(cell_array)
saved_keys = set()
for key, value in tracts_data.items():
if key in saved_keys:
continue
if key.startswith('Active'):
saved_keys.add(value)
name = value
value = tracts_data[value]
else:
name = key
if len(value) == len(tracts):
if value[0].ndim == 1:
value_ = ns.numpy.hstack(value)[:, None]
else:
value_ = ns.numpy.vstack(value)
elif len(value) == len(points):
value_ = value
else:
raise ValueError(
"Data in %s does not have the correct number of items")
vtk_value = ns.numpy_to_vtk(np.ascontiguousarray(value_), deep=True)
vtk_value.SetName(name)
if key == 'ActiveScalars' or key == 'Scalars_':
poly_data.GetPointData().SetScalars(vtk_value)
elif key == 'ActiveVectors' or key == 'Vectors_':
poly_data.GetPointData().SetVectors(vtk_value)
elif key == 'ActiveTensors' or key == 'Tensors_':
poly_data.GetPointData().SetTensors(vtk_value)
else:
poly_data.GetPointData().AddArray(vtk_value)
poly_data.BuildCells()
return poly_data
import numpy as np
import os
from pathlib2 import Path
from matplotlib.cm import get_cmap
import vtk
from vtk.util.numpy_support import (
numpy_to_vtk,
numpy_to_vtkIdTypeArray,
vtk_to_numpy,
get_vtk_to_numpy_typemap
)
import itertools
ID_ARRAY_NUMPY_DTYPE = get_vtk_to_numpy_typemap()[vtk.VTK_ID_TYPE]
# def unpack_id_array(arr, max_size):
#
from vtkplotlib import colors as vpl_colors
_numpy_to_vtk = numpy_to_vtk
def numpy_to_vtk(num_array, deep=0, array_type=None):
assert deep or num_array.flags.contiguous
return _numpy_to_vtk(np.ascontiguousarray(num_array), deep, array_type)
def cell_array_handler_property(name, doc=""):
def getter(self):
