# Version: $Id$
#
#
# Commentary:
#
#
# Change Log:
#
#
# Code:
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import vtk
from vtk.util.numpy_support import numpy_to_vtk, vtk_to_numpy, get_vtk_array_type
from cellcomplex.property_topomesh.analysis import compute_topomesh_property
from cellcomplex.utils import array_dict
from time import time as current_time
import logging
logging.getLogger().setLevel(logging.INFO)
[docs]def vtk_lookuptable_from_mpl_cmap(colormap='gray',value_range=(0,1)):
cmap = mpl.cm.get_cmap(colormap)
if isinstance(cmap,mpl.colors.LinearSegmentedColormap):
if np.all([np.all(np.sort(np.array(cmap._segmentdata[k])[:,0])==np.array(cmap._segmentdata['red'])[:,0]) for k in ['red','green','blue']]):
cmap_data = np.transpose([cmap._segmentdata[k] for k in ['red','green','blue']],(1,0,2))[:,:,:2]
cmap_dict = dict(zip(cmap_data[:,0,0],cmap_data[:,:,1]))
else:
cmap_keys = np.unique(np.concatenate([np.array(cmap._segmentdata[k])[:,0] for k in ['red','green','blue']]))
cmap_values = mpl.cm.ScalarMappable(cmap=cmap,norm=mpl.colors.Normalize(0,1)).to_rgba(cmap_keys)[:,:3]
cmap_dict = dict(zip(cmap_keys,cmap_values))
elif isinstance(cmap,mpl.colors.ListedColormap):
cmap_dict = dict(zip(np.linspace(0,1,len(cmap.colors)),cmap.colors))
lut = vtk.vtkColorTransferFunction()
lut.RemoveAllPoints()
for val in np.sort(list(cmap_dict.keys())):
node = val*value_range[1] + (1-val)*value_range[0]
lut.AddRGBPoint(node, *cmap_dict[val])
lut.ClampingOn()
lut.Modified()
return lut
[docs]def vtk_glyph_polydata(input_polydata, glyph_scale=1., tensor_glyph='crosshair', vector_glyph='arrow', point_glyph='sphere'):
print(input_polydata.GetNumberOfCells(),"Cells, ",input_polydata.GetNumberOfPoints()," Points")
print("Point Data : ",input_polydata.GetPointData().GetArray(0).GetNumberOfComponents())
if (input_polydata.GetNumberOfCells() == 0) and (input_polydata.GetNumberOfPoints() > 0):
if input_polydata.GetPointData().GetArray(0).GetNumberOfComponents() == 1:
glyph = vtk.vtkGlyph3D()
if point_glyph == 'sphere':
sphere = vtk.vtkSphereSource()
sphere.SetRadius(glyph_scale)
sphere.SetThetaResolution(12)
sphere.SetPhiResolution(12)
sphere.Update()
glyph.SetSourceData(sphere.GetOutput())
elif point_glyph == 'point':
point = vtk.vtkPointSource()
point.SetRadius(0)
point.SetNumberOfPoints(1)
point.Update()
glyph.SetSourceData(point.GetOutput())
glyph.SetScaleModeToDataScalingOff()
glyph.SetColorModeToColorByScalar()
glyph.SetInputData(input_polydata)
elif input_polydata.GetPointData().GetArray(0).GetNumberOfComponents() == 3:
glyph = vtk.vtkGlyph3D()
if vector_glyph == 'line':
line = vtk.vtkLineSource()
line.SetPoint1(0,0,0)
line.SetPoint2(1,0,0)
line.Update()
glyph.SetSourceConnection(line.GetOutputPort())
elif vector_glyph == 'arrow':
arrow = vtk.vtkArrowSource()
arrow.SetTipLength(0.2)
arrow.SetShaftRadius(0.05)
arrow.SetTipRadius(0.1)
arrow.SetTipResolution(32)
arrow.SetShaftResolution(32)
arrow.Update()
glyph.SetSourceConnection(arrow.GetOutputPort())
elif vector_glyph == 'tube':
tube = vtk.vtkCylinderSource()
tube.SetRadius(0.5)
tube.SetResolution(100)
tube.CappingOff()
tube.Update()
rotation = vtk.vtkTransform()
rotation.RotateZ(90)
rotation.Translate(0,-0.5,0)
transform = vtk.vtkTransformPolyDataFilter()
transform.SetInputConnection(tube.GetOutputPort())
transform.SetTransform(rotation)
transform.Update()
glyph.SetSourceData(transform.GetOutput())
glyph.SetInputData(input_polydata)
glyph.SetVectorModeToUseVector()
glyph.SetColorModeToColorByVector()
glyph.SetScaleModeToScaleByVector()
glyph.SetScaleFactor(glyph_scale)
elif input_polydata.GetPointData().GetArray(0).GetNumberOfComponents() == 9:
glyph = vtk.vtkTensorGlyph()
if tensor_glyph == 'ellipsoid':
sphere = vtk.vtkSphereSource()
sphere.SetThetaResolution(12)
sphere.SetPhiResolution(8)
sphere.Update()
glyph.SetSourceConnection(sphere.GetOutputPort())
glyph.ThreeGlyphsOff()
elif tensor_glyph == 'crosshair':
# line = vtk.vtkLineSource()
# line.SetPoint1(0,0,0)
# line.SetPoint2(1,0,0)
line = vtk.vtkCylinderSource()
line.SetCenter(0.0, 0.0, 0.0)
line.SetRadius(0.05/np.sqrt(glyph_scale))
line.SetHeight(1.0)
line.SetResolution(16)
line.Update()
rotation = vtk.vtkTransform()
rotation.RotateZ(90)
rotation_filter = vtk.vtkTransformPolyDataFilter()
rotation_filter.SetInputConnection(line.GetOutputPort())
rotation_filter.SetTransform(rotation)
translation = vtk.vtkTransform()
translation.Translate(0.5,0,0)
translation_filter = vtk.vtkTransformPolyDataFilter()
translation_filter.SetInputConnection(rotation_filter.GetOutputPort())
translation_filter.SetTransform(translation)
glyph.SetSourceConnection(translation_filter.GetOutputPort())
glyph.ThreeGlyphsOn()
glyph.SetInputData(input_polydata)
glyph.ColorGlyphsOn()
glyph.SetColorModeToEigenvalues()
glyph.SymmetricOn()
glyph.SetScaleFactor(glyph_scale)
glyph.ExtractEigenvaluesOn()
glyph.Update()
polydata = glyph.GetOutput()
else:
polydata = input_polydata
return polydata
[docs]def vtk_combine_polydatas(polydata_list):
if len(polydata_list)>0:
appender = vtk.vtkAppendPolyData()
for polydata in polydata_list:
appender.AddInputData(polydata)
appender.Update()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(appender.GetOutputPort())
cleaner.Update()
return cleaner.GetOutput()
else:
return vtk.vtkPolyData()
[docs]def vtk_tube_polydata(input_polydata, radius=1.):
all_lines = input_polydata.GetLines()
all_line_data = input_polydata.GetCellData().GetArray(0)
line_polydatas = []
all_lines.InitTraversal()
point_list = vtk.vtkIdList()
# for line_id in range(all_lines.GetNumberOfCells()):
while (all_lines.GetNextCell(point_list)):
# point_list = vtk.vtkIdList()
# all_lines.GetCell(line_id, point_list)
# line_data = all_line_data.GetNextTuple()
line_data = 0
print("Line : "+str(point_list.GetNumberOfIds())+" Points")
if point_list.GetNumberOfIds() == 2:
points = vtk.vtkPoints()
for i_point in range(point_list.GetNumberOfIds()):
print(" -->"+str(i_point)+" : "+str(input_polydata.GetPoint(point_list.GetId(i_point))))
points.InsertPoint(i_point,input_polydata.GetPoint(point_list.GetId(i_point)))
spline = vtk.vtkParametricSpline()
spline.SetPoints(points)
function_source = vtk.vtkParametricFunctionSource()
function_source.SetParametricFunction(spline)
function_source.SetUResolution(8*points.GetNumberOfPoints())
function_source.Update()
n_points = function_source.GetOutput().GetNumberOfPoints()
interpolated_radius = vtk.vtkTupleInterpolator()
interpolated_radius.SetInterpolationTypeToLinear()
interpolated_radius.SetNumberOfComponents(1)
for i_r in range(point_list.GetNumberOfIds()):
interpolated_radius.AddTuple(i_r,[radius])
tube_data = vtk.vtkDoubleArray()
tube_data.SetNumberOfTuples(n_points)
tube_data.SetName("TubeData")
tube_radius = vtk.vtkDoubleArray()
tube_radius.SetNumberOfTuples(n_points)
tube_radius.SetName("TubeRadius")
tMin = interpolated_radius.GetMinimumT()
tMax = interpolated_radius.GetMaximumT()
for i_r,i in enumerate(np.arange(n_points)/float(n_points-1)):
r = [0.]
interpolated_radius.InterpolateTuple(tMin + i*(tMax - tMin),r)
tube_radius.SetTuple1(i_r,r[0])
tube_data.SetTuple1(i_r,line_data)
tube_polydata = function_source.GetOutput()
tube_polydata.GetPointData().AddArray(tube_radius)
tube_polydata.GetPointData().AddArray(tube_data)
tube_polydata.GetPointData().SetActiveScalars("TubeRadius")
tuber = vtk.vtkTubeFilter()
tuber.SetInputData(tube_polydata)
tuber.SetNumberOfSides(16)
tuber.SetVaryRadiusToVaryRadiusByAbsoluteScalar()
tuber.Update()
polydata = tuber.GetOutput()
polydata.GetPointData().RemoveArray("TubeRadius")
polydata.GetPointData().SetActiveScalars("TubeData")
line_polydatas += [polydata]
return vtk_combine_polydatas(line_polydatas)
[docs]def face_scalar_property_polydata(positions, face_vertex_ids, face_property_data, polydata=None, update_polydata=True):
assert face_property_data.ndim == 1
assert not face_property_data.dtype in ['O']
assert len(face_property_data) == len(face_vertex_ids)
unique_vertex_ids = np.unique(np.concatenate(face_vertex_ids))
if polydata is None:
polydata = vtk.vtkPolyData()
update_polydata = True
if update_polydata:
polydata.Initialize()
logging.info("--> Face Scalar Polydata : Re-computing polydata...")
vtk_points = vtk.vtkPoints()
vtk_faces = vtk.vtkCellArray()
double_array = numpy_to_vtk(positions.values(unique_vertex_ids), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_points.SetData(double_array)
point_mapping = array_dict(dict(zip(unique_vertex_ids, range(len(unique_vertex_ids)))))
for face_vids, face_property in zip(face_vertex_ids, face_property_data):
vtk_face_point_ids = point_mapping.values(face_vids)
vtk_face_id = vtk_faces.InsertNextCell(len(vtk_face_point_ids))
for vtk_point_id in vtk_face_point_ids:
vtk_faces.InsertCellPoint(vtk_point_id)
polydata.SetPoints(vtk_points)
polydata.SetPolys(vtk_faces)
property_double_array = numpy_to_vtk(face_property_data.astype(float), deep=True, array_type=vtk.VTK_DOUBLE)
property_double_array.SetName("Property")
polydata.GetCellData().SetScalars(property_double_array)
return polydata
[docs]def face_scalar_vertex_property_polydata(positions, face_vertex_ids, vertex_property_data, polydata=None, update_polydata=True):
assert vertex_property_data.ndim == 1
assert not vertex_property_data.dtype in ['O']
assert len(vertex_property_data) == len(positions)
unique_vertex_ids = np.unique(np.concatenate(face_vertex_ids))
if polydata is None:
polydata = vtk.vtkPolyData()
update_polydata = True
if update_polydata:
polydata.Initialize()
logging.info("--> Face Scalar Polydata : Re-computing polydata...")
vtk_points = vtk.vtkPoints()
vtk_faces = vtk.vtkCellArray()
double_array = numpy_to_vtk(positions.values(unique_vertex_ids), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_points.SetData(double_array)
point_mapping = array_dict(dict(zip(unique_vertex_ids, range(len(unique_vertex_ids)))))
for face_vids in face_vertex_ids:
vtk_face_point_ids = point_mapping.values(face_vids)
vtk_face_id = vtk_faces.InsertNextCell(len(vtk_face_point_ids))
for vtk_point_id in vtk_face_point_ids:
vtk_faces.InsertCellPoint(vtk_point_id)
polydata.SetPoints(vtk_points)
polydata.SetPolys(vtk_faces)
property_double_array = numpy_to_vtk(vertex_property_data.astype(float), deep=True, array_type=vtk.VTK_DOUBLE)
property_double_array.SetNumberOfComponents(1)
property_double_array.SetName("Property")
polydata.GetPointData().SetScalars(property_double_array)
return polydata
[docs]def edge_scalar_property_polydata(positions, edge_vertex_ids, edge_property_data, polydata=None, line_glyph='line', glyph_scale=1.):
assert edge_property_data.ndim == 1
assert not edge_property_data.dtype in ['O']
assert edge_vertex_ids.ndim == 2
assert edge_vertex_ids.shape[1] == 2
assert len(edge_property_data) == len(edge_vertex_ids)
unique_vertex_ids = np.unique(np.concatenate(edge_vertex_ids))
if polydata is None:
polydata = vtk.vtkPolyData()
polydata.Initialize()
vtk_points = vtk.vtkPoints()
vtk_edges = vtk.vtkCellArray()
vtk_edge_data = vtk.vtkDoubleArray()
double_array = numpy_to_vtk(positions.values(unique_vertex_ids), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_points.SetData(double_array)
point_mapping = array_dict(dict(zip(unique_vertex_ids, range(len(unique_vertex_ids)))))
for edge_vids, edge_property in zip(edge_vertex_ids, edge_property_data):
vtk_edge_point_ids = point_mapping.values(edge_vids)
line = vtk.vtkLine()
for i_p,vtk_point_id in enumerate(vtk_edge_point_ids):
line.GetPointIds().SetId(i_p,vtk_point_id)
vtk_edge_id = vtk_edges.InsertNextCell(line)
print("Line "+str(vtk_edge_id)+" : "+str(line.GetPointIds().GetNumberOfIds())+" Points")
# vtk_edge_id = vtk_edges.InsertNextCell(len(vtk_edge_point_ids))
# print("Line "+str(vtk_edge_id)+" : "+str(len(vtk_edge_point_ids))+" Points")
# for vtk_point_id in vtk_edge_point_ids:
# vtk_edges.InsertCellPoint(vtk_point_id)
vtk_edge_data.InsertValue(vtk_edge_id, edge_property)
vtk_edge_data.SetName("Property")
polydata.SetPoints(vtk_points)
polydata.SetLines(vtk_edges)
polydata.GetPointData().Initialize()
polydata.GetCellData().SetScalars(vtk_edge_data)
if line_glyph == 'line':
return polydata
elif line_glyph == 'tube':
return vtk_tube_polydata(polydata, radius=glyph_scale)
[docs]def vertex_tensor_property_polydata(positions, vertex_property_data, polydata=None):
assert vertex_property_data.ndim == 3
assert len(vertex_property_data) == len(positions)
if polydata is None:
polydata = vtk.vtkPolyData()
polydata.Initialize()
vtk_points = vtk.vtkPoints()
double_array = numpy_to_vtk(positions.values(), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_points.SetData(double_array)
property_validity = np.logical_not(np.any(np.any(np.isnan(vertex_property_data),axis=1),axis=1))
eigval, eigvec = np.linalg.eig(vertex_property_data[property_validity])
eps = 1e-2
eigval[eigval < 1e-4] = eps
vertex_property_data[property_validity] = np.einsum('ni, nji, nki->njk', eigval,eigvec,eigvec)
vtk_point_data = numpy_to_vtk(vertex_property_data.reshape(len(positions),9), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_point_data.SetName("Property")
# for fid, face_property in enumerate(face_property_data):
# vtk_point_data.InsertTuple9(fid, *np.ravel(face_property))
polydata.SetPoints(vtk_points)
polydata.GetPointData().SetTensors(vtk_point_data)
return polydata
[docs]def vertex_vector_property_polydata(positions, vertex_property_data, polydata=None, update_polydata=True):
assert vertex_property_data.ndim == 2
assert len(vertex_property_data) == len(positions)
if polydata is None:
polydata = vtk.vtkPolyData()
update_polydata = True
polydata.Initialize()
# if update_polydata:
logging.info("--> Vertex Vector Polydata : Re-computing polydata...")
vtk_points = vtk.vtkPoints()
# vtk_faces = vtk.vtkCellArray()
double_array = numpy_to_vtk(positions.values(), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_points.SetData(double_array)
polydata.SetPoints(vtk_points)
# polydata.SetPolys(vtk_faces)
vtk_point_data = numpy_to_vtk(vertex_property_data.reshape(len(positions), 3), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_point_data.SetName("Property")
polydata.GetPointData().SetVectors(vtk_point_data)
return polydata
[docs]def vertex_scalar_property_polydata(positions, vertex_property_data, polydata=None):
assert vertex_property_data.ndim == 1
assert not vertex_property_data.dtype in ['O']
assert len(vertex_property_data) == len(positions)
if polydata is None:
polydata = vtk.vtkPolyData()
polydata.Initialize()
vtk_points = vtk.vtkPoints()
double_array = numpy_to_vtk(positions.values(), deep=True, array_type=vtk.VTK_DOUBLE)
vtk_points.SetData(double_array)
vtk_point_data = numpy_to_vtk(vertex_property_data, deep=True, array_type=vtk.VTK_DOUBLE)
vtk_point_data.SetNumberOfComponents(1)
vtk_point_data.SetName("Property")
polydata.SetPoints(vtk_points)
polydata.GetPointData().SetScalars(vtk_point_data)
return polydata
[docs]def property_topomesh_to_vtk_polydata(topomesh, degree=2, property_name=None, tensor_glyph='ellipsoid', vector_glyph='arrow', glyph_scale=1.):
if degree == 3:
positions = topomesh.wisp_property("barycenter", 0)
compute_topomesh_property(topomesh,"oriented_vertices",2)
if topomesh.has_wisp_property(property_name,3,is_computed=True):
cell_property = topomesh.wisp_property(property_name,3)
else:
cell_property = array_dict(dict(zip(topomesh.wisps(3),topomesh.wisps(3))))
cell_polydatas = []
for cid in topomesh.wisps(3):
face_vertices = topomesh.wisp_property("oriented_vertices", 2).values(list(topomesh.borders(3,cid)))
property_data = np.array([cell_property[cid] for fid in topomesh.borders(3,cid)])
cell_polydatas += [face_scalar_property_polydata(positions, face_vertices, property_data)]
return vtk_combine_polydatas(cell_polydatas)
elif degree == 2:
positions = topomesh.wisp_property("barycenter", 0)
compute_topomesh_property(topomesh,"oriented_vertices",2)
face_vertices = topomesh.wisp_property("oriented_vertices", 2).values()
if topomesh.has_wisp_property(property_name,2,is_computed=True):
property_data = topomesh.wisp_property(property_name,2).values()
if property_data.ndim == 3:
compute_topomesh_property(topomesh, 'barycenter', 2)
positions = topomesh.wisp_property("barycenter", 2)
if property_data.shape[1] == 3 and property_data.shape[2] == 3:
return vertex_tensor_property_polydata(positions, property_data,tensor_glyph=tensor_glyph, glyph_scale=glyph_scale)
if property_data.ndim == 2:
compute_topomesh_property(topomesh, 'barycenter', 2)
positions = topomesh.wisp_property("barycenter", 2)
return vertex_vector_property_polydata(positions, property_data, vector_glyph=vector_glyph, glyph_scale=glyph_scale)
else:
property_data = np.ones(topomesh.nb_wisps(2))
return face_scalar_property_polydata(positions, face_vertices, property_data)
elif degree == 1:
positions = topomesh.wisp_property("barycenter", 0)
compute_topomesh_property(topomesh,"vertices",1)
edge_vertices = topomesh.wisp_property("vertices", 1).values()
if topomesh.has_wisp_property(property_name,1,is_computed=True):
property_data = topomesh.wisp_property(property_name,1).values()
else:
property_data = np.ones(topomesh.nb_wisps(1))
return edge_scalar_property_polydata(positions, edge_vertices, property_data)
elif degree == 0:
positions = topomesh.wisp_property("barycenter", 0)
if topomesh.has_wisp_property(property_name,0,is_computed=True):
property_data = topomesh.wisp_property(property_name,0).values(positions.keys())
else:
property_data = np.ones(topomesh.nb_wisps(0))
return vertex_scalar_property_polydata(positions, property_data)
[docs]def vtk_actor(polydata, actor=None, colormap='viridis', value_range=None, opacity=1):
if value_range is None:
if polydata.GetCellData().GetNumberOfArrays()>0:
scalars = vtk_to_numpy(polydata.GetCellData().GetArray(0))
value_range = (np.nanmin(scalars),np.nanmax(scalars))
elif polydata.GetPointData().GetNumberOfArrays()>0:
scalars = vtk_to_numpy(polydata.GetPointData().GetArray(0))
value_range = (np.nanmin(scalars),np.nanmax(scalars))
else:
value_range = (0,1)
lut = vtk_lookuptable_from_mpl_cmap(colormap,value_range)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polydata)
mapper.SetLookupTable(lut)
if actor is None:
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetOpacity(opacity)
return actor
[docs]def vtk_display_polydata(polydata, background=(0.1, 0.1, 0.15), focal_point=(1, 0, 0), view_up=(0, 0, 1)):
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polydata)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
vtk_display_actor(actor, background=background, focal_point=focal_point, view_up=view_up)
[docs]def vtk_axes_actor(actor, axes_actor=None, font_size=20):
if axes_actor is None:
axes = vtk.vtkAxesActor()
transform = vtk.vtkTransform()
bounds = np.array(actor.GetBounds())
min_x = bounds[0]
max_x = bounds[1]
mean_x = 0.1*(max_x - min_x)
min_y = bounds[2]
max_y = bounds[3]
mean_y = 0.1*(max_y- min_y)
min_z = bounds[4]
max_z = bounds[5]
mean_z = 0.1*(max_z - min_z)
max = np.max(np.array((mean_x, mean_y, mean_z)))
axes.SetTotalLength(max, max, max)
transform.Translate(min_x-0.5*mean_x, min_y-0.5*mean_y, min_z-0.5*mean_z)
axes.SetUserTransform(transform)
axes.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
axes.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
axes.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(font_size)
axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(font_size)
axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(font_size)
return axes
[docs]def vtk_display_actors(actors, renderer=None, background=(0.1, 0.1, 0.1), focal_point=(1, 0, 0), view_up=(0, 0, 1), set_scalar_bar=False, set_axes=False, show=True):
actor = vtk.vtkAssembly()
for a in actors:
if a is not None:
actor.AddPart(a)
return vtk_display_actor(actor, renderer, background, focal_point, view_up, set_scalar_bar, set_axes, show=show)
[docs]def vtk_display_actor(actor, renderer=None, background=(0.1, 0.1, 0.1), focal_point=(1, 0, 0), view_up=(0, 0, 1), set_scalar_bar=False, set_axes=False, show=True):
if renderer is None:
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(1000,1000)
if set_axes:
axes = vtk_axes_actor(actor)
renderer.AddActor(axes)
renderer.AddActor(actor)
renderer.SetBackground(*background)
camera = renderer.GetActiveCamera()
camera.SetPosition(0, 0, 0)
camera.SetFocalPoint(*focal_point)
camera.SetViewUp(*view_up)
renderer.ResetCamera()
render_window.Render()
if show:
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
render_window_interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
if set_scalar_bar:
scalar_bar_widget = vtk_scalar_bar_widget(actor, render_window_interactor)
scalar_bar_widget.On()
render_window_interactor.Start()
return renderer
[docs]def vtk_save_webgl_actors(actors, webgl_filename, background=(0.1, 0.1, 0.1), focal_point=(1, 0, 0), view_up=(0, 0, 1)):
renderer = vtk_display_actors(actors,background=background,focal_point=focal_point,view_up=view_up,show=False)
render_window = renderer.GetRenderWindow()
webgl_exporter = vtk.vtkPVWebGLExporter()
webgl_exporter.SetFileName(webgl_filename)
webgl_exporter.SetRenderWindow(render_window)
webgl_exporter.Update()
[docs]def vtk_save_png_actors(actors, png_filename, background=(0.1, 0.1, 0.1), focal_point=(1, 0, 0), view_up=(0, 0, 1)):
renderer = vtk_display_actors(actors, background=background, focal_point=focal_point, view_up=view_up, show=False)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetOffScreenRendering(1)
render_window.SetSize(1500, 1500)
render_window.Render()
window_to_image = vtk.vtkWindowToImageFilter()
window_to_image.SetInput(render_window)
window_to_image.SetInputBufferTypeToRGBA()
window_to_image.Update()
png_writer = vtk.vtkPNGWriter()
png_writer.SetInputConnection(window_to_image.GetOutputPort())
png_writer.SetFileName(png_filename)
png_writer.Write()
[docs]def vtk_image_actors(actors, focal_point=(1, 0, 0), view_up=(0, 0, 1)):
actor = vtk.vtkAssembly()
for a in actors:
if a is not None:
actor.AddPart(a)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
size = 2000
pad = 300
render_window = vtk.vtkRenderWindow()
render_window.SetOffScreenRendering(1)
render_window.AddRenderer(renderer)
render_window.SetSize(size+2*pad, size+2*pad)
camera = renderer.GetActiveCamera()
camera.SetPosition(0, 0, 0)
camera.SetFocalPoint(*focal_point)
camera.SetViewUp(*view_up)
renderer.ResetCamera()
render_window.Render()
renderer.ResetCamera()
window_to_image = vtk.vtkWindowToImageFilter()
window_to_image.SetInput(render_window)
window_to_image.SetInputBufferTypeToRGBA()
window_to_image.Update()
vtk_image = window_to_image.GetOutput()
vtk_array = vtk_image.GetPointData().GetArray(0)
shape = (size+2*pad,size+2*pad,4)
img = vtk_to_numpy(vtk_array).reshape(shape)
img = img[pad:size+pad,pad:size+pad]
return img
