def initialize(self):
# Bring used components
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebStartupRemoteConnection(
_FileOpener.dsHost, _FileOpener.dsPort, _FileOpener.rsHost,
_FileOpener.rsPort))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebFileListing(_FileOpener.pathToList,
"Home"))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPort())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
# Update authentication key to use
self.updateSecret(_FileOpener.authKey)
# Create default pipeline
if _FileOpener.fileToLoad:
_FileOpener.reader = simple.OpenDataFile(_FileOpener.fileToLoad)
simple.Show()
_FileOpener.view = simple.Render()
_FileOpener.view.ViewSize = [800, 800]
# If this is running on a Mac DO NOT use Offscreen Rendering
#view.UseOffscreenRendering = 1
simple.ResetCamera()
else:
_FileOpener.view = simple.GetRenderView()
simple.Render()
_FileOpener.view.ViewSize = [800, 800]
simple.SetActiveView(_FileOpener.view)
def __init__(self):
super(ParaViewWebPipelineManager, self).__init__()
# Setup global variables
self.pipeline = web_helper.Pipeline('Kitware')
self.lutManager = web_helper.LookupTableManager()
self.view = simple.GetRenderView()
simple.SetActiveView(self.view)
simple.Render()
self.view.ViewSize = [800, 800]
self.lutManager.setView(self.view)
def init_view(self):
pasi.SetActiveView(pasi.GetRenderView())
if paraview_loaded:
camera = pasi.GetActiveCamera()
self.camera = camera
# cm = CameraMover(camera)
print("Camera loaded")
if self.view_size is not None:
pasi.GetActiveView().ViewSize = self.view_size
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebStartupRemoteConnection(
_FileOpener.dsHost, _FileOpener.dsPort, _FileOpener.rsHost,
_FileOpener.rsPort))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebFileListing(_FileOpener.pathToList,
"Home"))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPort())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
# Update authentication key to use
self.updateSecret(_FileOpener.authKey)
# Create default pipeline
if _FileOpener.fileToLoad:
_FileOpener.reader = simple.OpenDataFile(_FileOpener.fileToLoad)
simple.Show()
_FileOpener.view = simple.Render()
_FileOpener.view.ViewSize = [800, 800]
# If this is running on a Mac DO NOT use Offscreen Rendering
#view.UseOffscreenRendering = 1
simple.ResetCamera()
else:
_FileOpener.view = simple.GetRenderView()
simple.Render()
_FileOpener.view.ViewSize = [800, 800]
# test to prove server's working
# independently from the web components
#c = simple.Cone()
#c.Resolution = 128
#simple.Hide(c)
#p = simple.ProcessIdScalars()
#r = simple.Show(p)
#a = p.PointData.GetArray('ProcessId')
#r.ColorArrayName = 'ProcessId'
#simple.AssignLookupTable(a,'Cool to Warm')
#simple.Render()
#simple.SaveScreenshot('/usr/common/graphics/ParaView/4.2.0-PDACS/data/test.png')
simple.SetActiveView(_FileOpener.view)
def __init__(self, baseDir=None, fileToLoad=None):
super(ParaViewWebPipelineManager, self).__init__()
# Setup global variables
self.pipeline = helper.Pipeline('Kitware')
self.lutManager = helper.LookupTableManager()
self.view = simple.GetRenderView()
self.baseDir = baseDir
simple.SetActiveView(self.view)
simple.Render()
self.view.ViewSize = [800, 800]
self.lutManager.setView(self.view)
if fileToLoad and fileToLoad[-5:] != '.pvsm':
try:
self.openFile(fileToLoad)
except:
print "error loading..."
def ArrowsScript(Input1, Input2, Output, CamDirVec=None, CamUpVec=None):
#### disable automatic camera reset on 'Show'
pvs._DisableFirstRenderCameraReset()
# create a new 'XML Unstructured Grid Reader'
VTU1 = pvs.XMLUnstructuredGridReader(FileName=[Input1])
VTU1.PointArrayStatus = ['Curvature']
# create a new 'XML Unstructured Grid Reader'
VTU2 = pvs.XMLUnstructuredGridReader(FileName=[Input2])
VTU2.PointArrayStatus = ['Curvature']
# get active view
renderView1 = pvs.GetActiveViewOrCreate('RenderView')
# show data in view
VTU1Display = pvs.Show(VTU1, renderView1)
VTU1Display.Representation = 'Surface'
VTU1Display.Diffuse = 0.85
VTU1Display.Ambient = 0.25
makeGlyph(VTU1, renderView1, scale=40.0, color=[1.0, 0.0, 0.0])
makeGlyph(VTU2, renderView1, scale=30.0, color=[0.0, 0.0, 1.0])
# Save Screenshot
AdjustCameraAndSave(renderView1,
Output,
ImageResolution=(2048, 2048),
CamDirVec=CamDirVec,
CamUpVec=CamUpVec)
# set active source
pvs.SetActiveSource(None)
pvs.SetActiveView(None)
pvs.Disconnect()
def UpdateCinema(self, view, datadescription, specLevel):
""" called from catalyst at each timestep to add to the cinema database """
if not view.IsA("vtkSMRenderViewProxy") == True:
return
try:
import paraview.tpl.cinema_python.adaptors.explorers as explorers
import paraview.tpl.cinema_python.adaptors.paraview.pv_explorers as pv_explorers
import paraview.tpl.cinema_python.adaptors.paraview.pv_introspect as pv_introspect
except ImportError as e:
import paraview
paraview.print_error("Cannot import cinema")
paraview.print_error(e)
return
#figure out where to put this store
import os.path
vfname = view.cpFileName
extension = os.path.splitext(vfname)[1]
vfname = vfname[0:vfname.rfind("_")] #strip _num.ext
fname = os.path.join(os.path.dirname(vfname), "cinema",
os.path.basename(vfname), "info.json")
def float_limiter(x):
#a shame, but needed to make sure python, javascript and (directory/file)name agree
if isinstance(x, (float)):
return '%.6e' % x #arbitrarily chose 6 significant digits
else:
return x
#what time?
time = datadescription.GetTime()
view.ViewTime = time
formatted_time = float_limiter(time)
#ensure that cinema operates on the specified view
simple.SetActiveView(view)
# Include camera information in the user defined parameters.
# pv_introspect uses __CinemaTracks to customize the exploration.
co = view.cpCinemaOptions
camType = co["camera"]
if "phi" in co:
self.__CinemaTracks["phi"] = co["phi"]
if "theta" in co:
self.__CinemaTracks["theta"] = co["theta"]
if "roll" in co:
self.__CinemaTracks["roll"] = co["roll"]
tracking_def = {}
if "tracking" in co:
tracking_def = co['tracking']
#figure out what we show now
pxystate = pv_introspect.record_visibility()
# a conservative global bounds for consistent z scaling
minbds, maxbds = pv_introspect.max_bounds()
#make sure depth rasters are consistent
view.MaxClipBounds = [minbds, maxbds, minbds, maxbds, minbds, maxbds]
view.LockBounds = 1
disableValues = False if 'noValues' not in co else co['noValues']
if specLevel == "B":
p = pv_introspect.inspect(skip_invisible=True)
else:
p = pv_introspect.inspect(skip_invisible=False)
fs = pv_introspect.make_cinema_store(p,
fname,
view,
forcetime=formatted_time,
userDefined=self.__CinemaTracks,
specLevel=specLevel,
camType=camType,
extension=extension,
disableValues=disableValues)
#all nodes participate, but only root can writes out the files
pm = servermanager.vtkProcessModule.GetProcessModule()
pid = pm.GetPartitionId()
enableFloatVal = False if 'floatValues' not in co else co['floatValues']
new_files = {}
ret = pv_introspect.explore(fs,
p,
iSave=(pid == 0),
currentTime={'time': formatted_time},
userDefined=self.__CinemaTracks,
specLevel=specLevel,
camType=camType,
tracking=tracking_def,
floatValues=enableFloatVal,
disableValues=disableValues)
if pid == 0:
fs.save()
new_files[vfname] = ret
view.LockBounds = 0
#restore what we showed
pv_introspect.restore_visibility(pxystate)
return os.path.basename(vfname), new_files
def export_scene(baseDirName, viewSelection, trackSelection):
'''This explores a set of user-defined views and tracks. export_scene is
called from vtkCinemaExport. The expected order of parameters is as follows:
- viewSelection (following the format defined in Wrapping/Python/paraview/cpstate.py):
Directory of the form {'ViewName' : [parameters], ...}, with parameters defined in the
order: Image filename, freq, fittoscreen, magnification, width, height, cinema).
- trackSelection:
Directory of the form {'TrackName' : [v1, v2, v3], ...}
Note: baseDirName is used as the parent directory of the database generated for
each view in viewSelection. 'Image filename' is used as the database directory name.
'''
import paraview.simple as pvs
# save initial state
initialView = pvs.GetActiveView()
pvstate = record_visibility()
atLeastOneViewExported = False
for viewName, viewParams in viewSelection.iteritems():
# check if this view was selected to export as spec b
cinemaParams = viewParams[6]
if len(cinemaParams) == 0:
print "Skipping view: Not selected to export as cinema spherical."
continue
# get the view and save the initial status
view = pvs.FindView(viewName)
pvs.SetActiveView(view)
view.ViewSize = [viewParams[4], viewParams[5]]
pvs.Render() # fully renders the scene (if not, some faces might be culled)
view.LockBounds = 1
#writeFreq = viewParams[1] # TODO where to get the timestamp in this case?
#if (writeFreq and timestamp % writeFreq == 0):
#magnification = viewParams[3] # Not used in cinema (TODO hide in UI)
fitToScreen = viewParams[2]
if fitToScreen != 0:
if view.IsA("vtkSMRenderViewProxy") == True:
view.ResetCamera()
elif view.IsA("vtkSMContextViewProxy") == True:
view.ResetDisplay()
else:
print ' do not know what to do with a ', view.GetClassName()
userDefValues = {}
if "theta" in cinemaParams:
userDefValues["theta"] = cinemaParams["theta"]
if "phi" in cinemaParams:
userDefValues["phi"] = cinemaParams["phi"]
userDefValues.update(trackSelection)
# generate file path
import os.path
viewFileName = viewParams[0]
viewDirName = viewFileName[0:viewFileName.rfind("_")] #strip _num.ext
filePath = os.path.join(baseDirName, viewDirName, "info.json")
p = inspect()
cs = make_cinema_store(p, filePath, forcetime = False,
_userDefinedValues = userDefValues)
explore(cs, p)
view.LockBounds = 0
cs.save()
atLeastOneViewExported = True
if not atLeastOneViewExported:
print "No view was selected to export as cinema spherical."
return
# restore initial state
pvs.SetActiveView(initialView)
restore_visibility(pvstate)
pv._DisableFirstRenderCameraReset()
# create a new 'CSV Reader'
hitsCsv = pv.CSVReader(FileName=[args.hitsFile])
# create a new 'Table To Points'
tableToPoints1 = pv.TableToPoints(Input=hitsCsv)
tableToPoints1.XColumn = 'X'
tableToPoints1.YColumn = 'Y'
tableToPoints1.ZColumn = 'Z'
# find view
renderView1 = pv.FindViewOrCreate('RenderView1', viewtype='RenderView')
# set active view
pv.SetActiveView(renderView1)
# create a new 'Glyph'
# sphere
glyph1 = pv.Glyph(Input=tableToPoints1, GlyphType='Sphere')
glyph1.Scalars = ['POINTS', 'Q']
glyph1.ScaleMode = 'scalar'
glyph1.ScaleFactor = scaleFactor
glyph1.GlyphMode = 'All Points'
#glyph1.GlyphType.ThetaResolution = 8
#glyph1.GlyphType.PhiResolution = 8
# get color transfer function/color map for args.colourColumn
cLUT = pv.GetColorTransferFunction(args.colourColumn)
nc = vtk.vtkNamedColors()
rgb = [0. for i in range(3)]
def createViews(self):
"""Create views
"""
# Disable automatic camera reset on 'Show'
pv._DisableFirstRenderCameraReset()
# Create render view
renderView = self.createRenderView([900, 900])
# Activate render view
pv.SetActiveView(renderView)
# Create ExodusII reader
reader = self.createExodusIIReader("Weight", "Load")
# Create sqrt(load) calculator to optimize visuals
sqrt_load = self.createCalculator(reader, "sqrt", "Load")
# Create sqrt(load) glyph
glyph = self.createGlyph(sqrt_load,
factor=0.05)
# Instantiate weight colors and points
weight_colors = [223.48540319420192,
0.231373,
0.298039,
0.752941,
784.8585271892204,
0.865003,
0.865003,
0.865003,
1346.2316511842387,
0.705882,
0.0156863,
0.14902]
weight_points = [223.48540319420192,
0.0,
0.5,
0.0,
1346.2316511842387,
1.0,
0.5,
0.0]
# Create color transfert functions
weightLUT = self.createColorTransferFunction(
"Weight",
weight_colors,
[1., 1., 1.],
0.0)
weightPWF = self.createOpacityTransferFunction(
"Weight",
weight_points)
readerDisplay = self.createDisplay(
reader,
renderView,
['CELLS', 'Weight'],
weightLUT,
4.0,
None,
None,
weightPWF)
# Instantiate load colors and points
load_colors = [0.0,
0.231373,
0.298039,
0.752941,
130.73569142337513,
0.865003,
0.865003,
0.865003,
261.47138284675026,
0.705882,
0.0156863,
0.14902]
load_points = [0.0,
0.0,
0.5,
0.0,
261.47138284675026,
1.0,
0.5,
0.0]
# Create color transfert functions
loadLUT = self.createColorTransferFunction(
"Load",
load_colors,
[1.,1.,1.],
None,
"Never")
loadPWF = self.createOpacityTransferFunction(
"Load",
load_points)
# Create displays
glyphDisplay = self.createDisplay(
glyph,
renderView,
['POINTS', 'Load'],
loadLUT,
None,
0.005)
# Activate glyph source
pv.SetActiveSource(glyph)
return reader
def StreamlinesScript(Input1,
Input2,
Output,
N1=None,
N2=None,
Offset1=0.0,
Offset2=0.0,
CamDirVec=None,
CamUpVec=None,
Origin=None):
''' Creates an image with the streamlines from two VTUs.
Inputs:
Input1 - VTU with first direction of curvatures
Input2 - VTU with second direction of curvatures
N1 - List of normal of slice for VTU1
N2 - List of normal of slice for VTU2
Offset1 - Value of offset for slice of VTU1
Offset2 - Value of offset for slice of VTU2
CamDirVec - Vector for camera direction
CamUpVec - Vector for camera up direction
Origin - Vector with the position for the origin'''
#### disable automatic camera reset on 'Show'
pvs._DisableFirstRenderCameraReset()
# create a new 'XML Unstructured Grid Reader'
VTU1 = pvs.XMLUnstructuredGridReader(FileName=[Input1])
VTU1.PointArrayStatus = ['Curvature']
## Fix data for Slices
if N1 is None:
N1 = [0.9, 0.4, 0.2]
if N2 is None:
# N2 = np.cross(N1,[0,0,1])
N2 = [-0.8, 0.5, 0.16]
if Origin is None:
Origin = paraview.servermanager.Fetch(
pvs.IntegrateVariables(Input=VTU1)).GetPoint(0)
# create a new 'XML Unstructured Grid Reader'
VTU2 = pvs.XMLUnstructuredGridReader(FileName=[Input2])
VTU2.PointArrayStatus = ['Curvature']
# get active view
renderView1 = pvs.GetActiveViewOrCreate('RenderView')
# show data in view
VTU1Display = pvs.Show(VTU1, renderView1)
VTU1Display.Representation = 'Surface'
VTU1Display.Diffuse = 0.85
VTU1Display.Ambient = 0.25
# show data in view
VTU2Display = pvs.Show(VTU2, renderView1)
VTU2Display.Representation = 'Surface'
VTU2Display.Diffuse = 0.85
VTU2Display.Ambient = 0.25
# create a new 'Slice'
slice1 = pvs.Slice(Input=VTU1)
slice1.SliceType.Origin = Origin
slice1.SliceType.Normal = N1
slice1.SliceType.Offset = 0.0
slice1.SliceOffsetValues = [Offset1]
# create a new 'Slice'
slice2 = pvs.Slice(Input=VTU2)
slice2.SliceType.Origin = Origin
slice2.SliceType.Normal = N2
slice2.SliceType.Offset = 0.0
slice2.SliceOffsetValues = [Offset2]
# make stremlines
makestream(VTU1, slice1, renderView1, [1.0, 0.0, 0.0])
makestream(VTU2, slice2, renderView1, [0.0, 0.0, 1.0])
# Save Screenshot
AdjustCameraAndSave(renderView1,
Output,
ImageResolution=(2048, 2048),
CamDirVec=CamDirVec,
CamUpVec=CamUpVec)
# set active source
pvs.SetActiveSource(None)
pvs.SetActiveView(None)
pvs.Disconnect()
def RequestData():
# R.1.2018.354
import sys
sys.path.insert(0, "EMC_SRC_PATH")
from operator import itemgetter
from datetime import datetime
import numpy as np
from vtk.numpy_interface import dataset_adapter as dsa
from vtk.util import numpy_support
import IrisEMC_Paraview_Lib as lib
import paraview.simple as simple
views = simple.GetViews(viewtype="SpreadSheetView")
if len(views) > 0:
# set active view
view = simple.SetActiveView(views[0])
else:
view = simple.GetActiveView()
layout = simple.GetLayout(view)
location_id = layout.SplitViewVertical(view=view, fraction=0.7)
myId = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
proxyList = []
for key in proxies:
list_elt = dict()
list_elt['name'] = key[0]
list_elt['id'] = key[1]
proxy = proxies[key]
parent_id = '0'
if hasattr(proxy, 'Input'):
parent_id = proxy.Input.GetGlobalIDAsString()
list_elt['parent'] = parent_id
proxyList.append(list_elt)
pdi = self.GetInput() # VTK PolyData Type
try:
np = pdi.GetNumberOfPoints()
except Exception:
raise Exception('Invalid input!')
na = pdi.GetPointData().GetNumberOfArrays()
val_arrays = []
for i in range(na):
val_arrays.append(pdi.GetPointData().GetArray(i))
latitude = {}
longitude = {}
value = {}
depth = {}
pdo = self.GetOutput() # VTK Table Type
poly_data = vtk.vtkPolyData()
data_points = vtk.vtkPoints()
if len(Label.strip()) <= 0:
pid = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
for key in proxies:
if key[1] == pid:
Label = " ".join(["Coordinates:", key[0]])
break
for i in range(np):
point = pdi.GetPoints().GetPoint(i)
(lat, lon, this_depth) = lib.xyz2llz(point[0], point[1], point[2])
data_points.InsertNextPoint((lat, lon, this_depth))
key = "%0.2f" % this_depth
if key not in list(latitude.keys()):
latitude[key] = []
longitude[key] = []
value[key] = []
# need to control precision to have a reasonable sort order
# note that these coordinates are recomputed
if key not in list(depth.keys()):
depth[key] = float('%0.4f' % this_depth)
latitude[key].append(float('%0.4f' % lat))
longitude[key].append(float('%0.4f' % lon))
value_array = []
for j in range(na):
value_array.append(float(val_arrays[j].GetTuple1(i)))
value[key].append(value_array)
# store boundary metadata
field_data = poly_data.GetFieldData()
field_data.AllocateArrays(5) # number of fields
depth_data = vtk.vtkFloatArray()
depth_data.SetName('depth')
lat_data = vtk.vtkFloatArray()
lat_data.SetName('latitude')
lon_data = vtk.vtkFloatArray()
lon_data.SetName('longitude')
val_data = []
for j in range(na):
val_data.append(vtk.vtkFloatArray())
val_data[j].SetName('value(%s)' %
pdi.GetPointData().GetArray(j).GetName())
depth_keys = list(latitude.keys())
for i in range(len(depth_keys)):
depth_key = depth_keys[i]
lon_list = longitude[depth_key]
lat_list = latitude[depth_key]
val_list = value[depth_key]
point_list = list(zip(lat_list, lon_list, val_list))
point_list.sort(key=itemgetter(0, 1))
for index, data in enumerate(point_list):
depth_data.InsertNextValue(float(depth[depth_key]))
lat_data.InsertNextValue(float(data[0]))
lon_data.InsertNextValue(float(data[1]))
for k in range(na):
point_data = data[2]
val_data[k].InsertNextValue(point_data[k])
field_data.AddArray(lat_data)
field_data.AddArray(lon_data)
field_data.AddArray(depth_data)
for j in range(na):
field_data.AddArray(val_data[j])
if len(Label.strip()) > 0:
simple.RenameSource(Label)
pdo.SetFieldData(field_data)
