def test_mesh_to_geometry():
# 3D
Dimension = 3
PixelType = itk.ctype('double')
MeshType = itk.Mesh[PixelType, Dimension]
mesh = MeshType.New()
PointType = itk.Point[itk.F, Dimension]
point0 = PointType()
point0[0] = -1
point0[1] = -1
point0[2] = 0
mesh.SetPoint(0, point0)
mesh.SetPointData(0, 8.0)
point1 = PointType()
point1[0] = 1
point1[1] = -1
point1[2] = 0
mesh.SetPointData(1, 9.0)
mesh.SetPoint(1, point1)
point2 = PointType()
point2[0] = 1
point2[1] = 1
point2[2] = 0
mesh.SetPoint(2, point2)
mesh.SetPointData(2, 19.0)
point3 = PointType()
point3[0] = 1
point3[1] = 1
point3[2] = 0
mesh.SetPoint(3, point3)
mesh.SetPointData(3, 24.0)
geometry = to_geometry(mesh)
points = mesh.GetPoints()
point_template = itk.template(points)
identifier_type = point_template[1][0]
element_type = point_template[1][1]
point_values = itk.array_from_vector_container(points)
assert (geometry['vtkClass'] == 'vtkPolyData')
assert (geometry['points']['vtkClass'] == 'vtkPoints')
assert (geometry['points']['numberOfComponents'] == 3)
assert (geometry['points']['dataType'] == 'Float32Array')
assert (geometry['points']['size'] == 4 * 3)
assert (np.array_equal(geometry['points']['values'],
point_values.astype(np.float32)))
assert (geometry['pointData']['vtkClass'] == 'vtkDataSetAttributes')
assert (geometry['pointData']['arrays'][0]['data']['vtkClass'] ==
'vtkDataArray')
assert (geometry['pointData']['arrays'][0]['data']['name'] == 'Point Data')
assert (
geometry['pointData']['arrays'][0]['data']['numberOfComponents'] == 1)
assert (geometry['pointData']['arrays'][0]['data']['size'] == 4)
assert (geometry['pointData']['arrays'][0]['data']['dataType'] ==
'Float64Array')
assert (np.array_equal(
geometry['pointData']['arrays'][0]['data']['values'],
np.array([8.0, 9.0, 19.0, 24.0], dtype=np.float64)))
def test_itkpolylineparametricpath_to_geometry():
Dimension = 2
polyline = itk.PolyLineParametricPath[Dimension].New()
polyline.AddVertex([3.0, 3.0])
polyline.AddVertex([4.0, 7.0])
polyline.AddVertex([5.0, 5.0])
geometry = to_geometry(polyline)
assert (geometry['vtkClass'] == 'vtkPolyData')
assert (geometry['points']['vtkClass'] == 'vtkPoints')
assert (geometry['points']['numberOfComponents'] == 3)
assert (geometry['points']['dataType'] == 'Float32Array')
assert (geometry['points']['size'] == 3 * 3)
assert (np.array_equal(
geometry['points']['values'],
np.array([3.0, 3.0, -5.0e-6, 4.0, 7.0, -5e-6, 5.0, 5.0,
-5e-6]).astype(np.float32)))
assert (geometry['verts']['vtkClass'] == 'vtkCellArray')
assert (geometry['verts']['numberOfComponents'] == 1)
assert (geometry['verts']['dataType'] == 'Uint32Array')
assert (geometry['verts']['size'] == 6)
assert (np.array_equal(geometry['verts']['values'], [1, 0, 1, 1, 1, 2]))
assert (geometry['lines']['vtkClass'] == 'vtkCellArray')
assert (geometry['lines']['numberOfComponents'] == 1)
assert (geometry['lines']['dataType'] == 'Uint32Array')
assert (geometry['lines']['size'] == 6)
assert (np.array_equal(geometry['lines']['values'], [2, 0, 1, 2, 1, 2]))
def test_vtkpolydata_to_geometry():
vtk = pytest.importorskip("vtk")
from vtk.util.numpy_support import vtk_to_numpy
cone_source = vtk.vtkConeSource()
cone_source.Update()
cone = cone_source.GetOutput()
geometry = to_geometry(cone)
assert (geometry['vtkClass'] == 'vtkPolyData')
points = cone.GetPoints()
assert (geometry['points']['vtkClass'] == 'vtkPoints')
assert (geometry['points']['numberOfComponents'] == 3)
assert (geometry['points']['dataType'] == 'Float32Array')
assert (geometry['points']['size'] == points.GetNumberOfPoints() * 3)
assert (np.array_equal(
geometry['points']['values'],
vtk_to_numpy(points.GetData()).astype(np.float32).ravel()))
polys = cone.GetPolys()
assert (geometry['polys']['vtkClass'] == 'vtkCellArray')
assert (geometry['polys']['numberOfComponents'] == 1)
assert (geometry['polys']['dataType'] == 'Uint32Array')
assert (geometry['polys']['size'] == polys.GetData().GetNumberOfValues())
assert (np.array_equal(
geometry['polys']['values'],
vtk_to_numpy(polys.GetData()).astype(np.uint32).ravel()))
def add_mesh(self, mesh, color=None, scalars=None, clim=None,
opacity=1.0, n_colors=256, cmap='Viridis (matplotlib)',
**kwargs):
"""Add mesh to the scene."""
if not pv.is_pyvista_dataset(mesh):
mesh = pv.wrap(mesh)
mesh = mesh.copy()
if scalars is None and color is None:
scalars = mesh.active_scalars_name
if scalars is not None:
array = mesh[scalars].copy()
mesh.clear_arrays()
mesh[scalars] = array
mesh.active_scalars_name = scalars
elif color is not None:
mesh.clear_arrays()
mesh = to_geometry(mesh)
self._geometries.append(mesh)
self._geometry_colors.append(pv.parse_color(color))
self._geometry_opacities.append(opacity)
self._cmap = cmap
return
def test_mesh_to_geometry():
# 3D
Dimension = 3
PixelType = itk.ctype('double')
MeshType = itk.Mesh[PixelType, Dimension]
mesh = MeshType.New()
PointType = itk.Point[itk.F, Dimension]
point0 = PointType()
point0[0] = -1
point0[1] = -1
point0[2] = 0
mesh.SetPoint(0, point0)
point1 = PointType()
point1[0] = 1
point1[1] = -1
point1[2] = 0
mesh.SetPoint(1, point1)
point2 = PointType()
point2[0] = 1
point2[1] = 1
point2[2] = 0
mesh.SetPoint(2, point2)
point3 = PointType()
point3[0] = 1
point3[1] = 1
point3[2] = 0
mesh.SetPoint(3, point3)
geometry = to_geometry(mesh)
points = mesh.GetPoints()
point_template = itk.template(points)
element_type = point_template[1][1]
point_values = itk.PyVectorContainer[
element_type].array_from_vector_container(points)
assert (geometry['vtkClass'] == 'vtkPolyData')
assert (geometry['points']['vtkClass'] == 'vtkPoints')
assert (geometry['points']['numberOfComponents'] == 3)
assert (geometry['points']['dataType'] == 'Float32Array')
assert (geometry['points']['size'] == 4 * 3)
assert (np.array_equal(geometry['points']['values'],
point_values.astype(np.float32)))
def add_mesh(self,
mesh,
color=None,
scalars=None,
opacity=1.0,
smooth_shading=False):
"""Add a PyVista/VTK mesh or dataset.
Adds any PyVista/VTK mesh that itkwidgets can wrap to the
scene.
Parameters
----------
mesh : pyvista.DataSet or pyvista.MultiBlock
Any PyVista or VTK mesh is supported. Also, any dataset
that :func:`pyvista.wrap` can handle including NumPy arrays of XYZ
points.
color : string or 3 item list, optional, defaults to white
Use to make the entire mesh have a single solid color.
Either a string, RGB list, or hex color string. For example:
``color='white'``, ``color='w'``, ``color=[1, 1, 1]``, or
``color='#FFFFFF'``. Color will be overridden if scalars are
specified.
scalars : str or numpy.ndarray, optional
Scalars used to "color" the mesh. Accepts a string name of an
array that is present on the mesh or an array equal
to the number of cells or the number of points in the
mesh. Array should be sized as a single vector. If both
``color`` and ``scalars`` are ``None``, then the active scalars are
used.
opacity : float, optional
Opacity of the mesh. If a single float value is given, it will be
the global opacity of the mesh and uniformly applied everywhere -
should be between 0 and 1. Default 1.0
smooth_shading : bool, optional
Smooth mesh surface mesh by taking into account surface
normals. Surface will appear smoother while sharp edges
will still look sharp. Default False.
"""
if not pv.is_pyvista_dataset(mesh):
mesh = pv.wrap(mesh)
# smooth shading requires point normals to be freshly computed
if smooth_shading:
# extract surface if mesh is exterior
if not isinstance(mesh, pv.PolyData):
grid = mesh
mesh = grid.extract_surface()
ind = mesh.point_arrays['vtkOriginalPointIds']
# remap scalars
if isinstance(scalars, np.ndarray):
scalars = scalars[ind]
mesh.compute_normals(cell_normals=False, inplace=True)
elif 'Normals' in mesh.point_arrays:
# if 'normals' in mesh.point_arrays:
mesh.point_arrays.pop('Normals')
# make the scalars active
if isinstance(scalars, str):
if scalars in mesh.point_arrays or scalars in mesh.cell_arrays:
array = mesh[scalars].copy()
else:
raise ValueError(f'Scalars ({scalars}) not in mesh')
mesh[scalars] = array
mesh.active_scalars_name = scalars
elif isinstance(scalars, np.ndarray):
array = scalars
scalar_name = '_scalars'
mesh[scalar_name] = array
mesh.active_scalars_name = scalar_name
elif color is not None:
mesh.active_scalars_name = None
# itkwidgets does not support VTK_ID_TYPE
if 'vtkOriginalPointIds' in mesh.point_arrays:
mesh.point_arrays.pop('vtkOriginalPointIds')
if 'vtkOriginalCellIds' in mesh.cell_arrays:
mesh.cell_arrays.pop('vtkOriginalCellIds')
from itkwidgets._transform_types import to_geometry
mesh = to_geometry(mesh)
self._geometries.append(mesh)
self._geometry_colors.append(pv.parse_color(color))
self._geometry_opacities.append(opacity)
def test_vtkpolydata_to_geometry():
vtk = pytest.importorskip("vtk")
from vtk.util.numpy_support import vtk_to_numpy
cone_source = vtk.vtkConeSource()
cone_source.Update()
cone = cone_source.GetOutput()
points = cone.GetPoints()
point_scalars = vtk.vtkFloatArray()
for ii in range(points.GetNumberOfPoints()):
point_scalars.InsertTuple1(ii, ii)
cone.GetPointData().SetScalars(point_scalars)
cell_scalars = vtk.vtkFloatArray()
for ii in range(cone.GetNumberOfCells()):
cell_scalars.InsertTuple1(ii, ii)
cone.GetCellData().SetScalars(cell_scalars)
geometry = to_geometry(cone)
assert (geometry['vtkClass'] == 'vtkPolyData')
assert (geometry['points']['vtkClass'] == 'vtkPoints')
assert (geometry['points']['numberOfComponents'] == 3)
assert (geometry['points']['dataType'] == 'Float32Array')
assert (geometry['points']['size'] == points.GetNumberOfPoints() * 3)
assert (np.array_equal(
geometry['points']['values'],
vtk_to_numpy(points.GetData()).astype(np.float32).ravel()))
polys = cone.GetPolys()
assert (geometry['polys']['vtkClass'] == 'vtkCellArray')
assert (geometry['polys']['numberOfComponents'] == 1)
assert (geometry['polys']['dataType'] == 'Uint32Array')
assert (geometry['polys']['size'] == polys.GetData().GetNumberOfValues())
assert (np.array_equal(
geometry['polys']['values'],
vtk_to_numpy(polys.GetData()).astype(np.uint32).ravel()))
assert (geometry['pointData']['vtkClass'] == 'vtkDataSetAttributes')
assert (geometry['pointData']['arrays'][0]['data']['vtkClass'] ==
'vtkDataArray')
assert (
geometry['pointData']['arrays'][0]['data']['numberOfComponents'] == 1)
assert (geometry['pointData']['arrays'][0]['data']['size'] == 7)
assert (geometry['pointData']['arrays'][0]['data']['dataType'] ==
'Float32Array')
assert (np.array_equal(
geometry['pointData']['arrays'][0]['data']['values'],
np.arange(points.GetNumberOfPoints(), dtype=np.float32)))
assert (geometry['cellData']['vtkClass'] == 'vtkDataSetAttributes')
assert (geometry['cellData']['arrays'][0]['data']['vtkClass'] ==
'vtkDataArray')
assert (
geometry['cellData']['arrays'][0]['data']['numberOfComponents'] == 1)
assert (geometry['cellData']['arrays'][0]['data']['size'] == 7)
assert (geometry['cellData']['arrays'][0]['data']['dataType'] ==
'Float32Array')
assert (np.array_equal(
geometry['cellData']['arrays'][0]['data']['values'],
np.arange(cone.GetNumberOfCells(), dtype=np.float32)))
